Image Segmentation
ultralytics
yolo
yolo11
instance-segmentation
object-detection
floor-plan
architecture
cad
autocad
building-elements
cctv
Eval Results (legacy)
Instructions to use swedishtech/RAQEEB-CCTV with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- ultralytics
How to use swedishtech/RAQEEB-CCTV with ultralytics:
from huggingface_hub import hf_hub_download from ultralytics import YOLO # pick the weights file from this repo's "Files and versions" tab weights = hf_hub_download("swedishtech/RAQEEB-CCTV", "<weights>.pt") model = YOLO(weights) source = 'http://images.cocodataset.org/val2017/000000039769.jpg' model.predict(source=source, save=True) - Notebooks
- Google Colab
- Kaggle
Download code/cad_raqeeb.py from swedishtech/RAQEEB-CCTV: direct link, hf CLI and curl.
- Browser
- Download file 19.9 kB
-
https://huggingface.co/swedishtech/RAQEEB-CCTV/resolve/main/code/cad_raqeeb.py
- Command line
-
hf download hf://swedishtech/RAQEEB-CCTV/code/cad_raqeeb.py
-
curl -L -o cad_raqeeb.py https://huggingface.co/swedishtech/RAQEEB-CCTV/resolve/main/code/cad_raqeeb.py
19.9 kB
| """RAQEEB on AutoCAD drawings (DWG or DXF): labelled boxes on the rendered drawing and inside the drawing itself. | |
| python cad_raqeeb.py drawing.dwg --weights raqeeb-cctv-v1.0.0.pt --thresholds thresholds.json --out out_dir ^ | |
| --region ground=194976,1278147,273726,1365497 [--region ...] [--px-per-unit 0.1] [--plot] [--tarch-check] | |
| Steps | |
| 1. DWG -> DXF with AutoCAD's headless accoreconsole (a DXF input is used as is). | |
| 2. Each region (drawing units) is rendered black on white at --px-per-unit pixels per drawing unit; 0.1 means | |
| 100 px per metre for a millimetre drawing, the scale of the CAD (FloorPlanCAD) training images. | |
| 3. RAQEEB runs in overlapping --tile px tiles with the validation-selected per-class thresholds (the same | |
| infer_raqeeb.infer_page used for PNG/JPEG/PDF) and every detection is drawn as a box with its class name. | |
| 4. Each box is mapped back to drawing coordinates and added to a copy of the drawing, one layer per class | |
| (RAQEEB-WALL, RAQEEB-DOOR, ...): a closed rectangle plus a 'door 0.91' text -> <name>_raqeeb.dxf and, through | |
| AutoCAD, <name>_raqeeb.dwg. | |
| 5. --plot: AutoCAD plots each region of the annotated DWG to PDF (DWG To PDF.pc3), i.e. the boxes and labels as | |
| AutoCAD itself draws them. | |
| 6. --tarch-check: for drawings made with TArch (layers WINDOW, COLUMN, WALL, STAIR, SPACE) the detections are scored | |
| against the drawing's own objects: door/window/column blocks, wall lines, stair lines and room-name texts. | |
| """ | |
| import argparse | |
| import glob | |
| import json | |
| import re | |
| import subprocess | |
| import time | |
| from pathlib import Path | |
| from types import SimpleNamespace | |
| import numpy as np | |
| from PIL import Image | |
| from annotate_raqeeb import COLORS, NAMES, before_after, boxes_from_detections, draw_boxes | |
| Image.MAX_IMAGE_PIXELS = 400_000_000 | |
| ACI = [1, 3, 5, 30, 6, 4, 200, 40, 221, 94, 150] # fallback AutoCAD colour index per class | |
| # ----------------------------------------------------------------------------------------------- AutoCAD | |
| def find_accoreconsole(): | |
| hits = sorted(glob.glob(r'C:\Program Files\Autodesk\AutoCAD 20*\accoreconsole.exe')) | |
| if not hits: | |
| raise FileNotFoundError('AutoCAD accoreconsole.exe not found; pass --accore or give a DXF') | |
| return hits[-1] | |
| def acad(accore, infile, lines, workdir, tag): | |
| """Run an AutoCAD script headless on `infile`; returns the console log text.""" | |
| scr = workdir / f'_{tag}.scr' | |
| scr.write_text('\n'.join(lines) + '\n', encoding='ascii') | |
| r = subprocess.run([accore, '/i', str(infile), '/s', str(scr), '/l', 'en-US'], cwd=str(workdir), | |
| capture_output=True, timeout=3600) | |
| log = (r.stdout + r.stderr).replace(b'\x00', b'').decode('utf-8', 'replace') | |
| (workdir / f'_{tag}.log').write_text(log, encoding='utf-8') | |
| return log | |
| def dwg_to_dxf(accore, dwg, dxf, workdir): | |
| dxf.unlink(missing_ok=True) | |
| acad(accore, dwg, ['_.FILEDIA', '0', '_.CMDDIA', '0', '_.SAVEAS', 'DXF', 'V', '2018', '16', | |
| f'"{dxf.as_posix()}"', '_.QUIT', 'Y'], workdir, 'dwg_to_dxf') | |
| if not dxf.exists(): | |
| raise RuntimeError(f'AutoCAD did not write {dxf}; see {workdir / "_dwg_to_dxf.log"}') | |
| def dxf_to_dwg(accore, dxf, dwg, workdir): | |
| dwg.unlink(missing_ok=True) | |
| acad(accore, dxf, ['_.FILEDIA', '0', '_.CMDDIA', '0', '_.SAVEAS', '2018', f'"{dwg.as_posix()}"', | |
| '_.QUIT', 'Y'], workdir, 'dxf_to_dwg') | |
| if not dwg.exists(): | |
| raise RuntimeError(f'AutoCAD did not write {dwg}; see {workdir / "_dxf_to_dwg.log"}') | |
| def plot_pdf(accore, dwg, region, pdf, workdir, tag): | |
| """Plot a model-space window of `dwg` to PDF with AutoCAD (object colours, lineweights).""" | |
| x0, y0, x1, y1 = region | |
| portrait = (y1 - y0) > (x1 - x0) | |
| pdf.unlink(missing_ok=True) | |
| acad(accore, dwg, [ | |
| '_.FILEDIA', '0', '_.CMDDIA', '0', '_.BACKGROUNDPLOT', '0', | |
| '-PLOT', 'Y', 'Model', 'DWG To PDF.pc3', 'ISO full bleed A1 (841.00 x 594.00 MM)', 'M', | |
| 'P' if portrait else 'L', 'N', 'W', f'{x0},{y0}', f'{x1},{y1}', 'F', 'C', 'Y', '.', 'Y', 'A', | |
| f'"{pdf.as_posix()}"', 'N', 'Y', '_.QUIT', 'Y'], workdir, tag) | |
| return pdf.exists() | |
| def pdf_to_png(pdf, png, max_side=5000): | |
| import pypdfium2 as pdfium | |
| doc = pdfium.PdfDocument(str(pdf)) | |
| page = doc[0] | |
| scale = max_side / max(page.get_width(), page.get_height()) | |
| page.render(scale=scale).to_pil().convert('RGB').save(png) | |
| doc.close() | |
| # ----------------------------------------------------------------------------------------------- rendering | |
| def load_for_render(dxf, font): | |
| import ezdxf | |
| from ezdxf import bbox | |
| doc = ezdxf.readfile(dxf) | |
| for s in doc.styles: # SHX/big fonts are not available outside AutoCAD; use one TrueType CJK-capable font | |
| s.dxf.font = font | |
| s.dxf.bigfont = '' | |
| cache = bbox.Cache() | |
| ents = [] | |
| for e in doc.modelspace(): | |
| b = bbox.extents([e], fast=True, cache=cache) | |
| if b.has_data: | |
| ents.append((e, (b.extmin.x, b.extmin.y, b.extmax.x, b.extmax.y))) | |
| return doc, ents | |
| def render(doc, ents, region, ppu, out_png, lineweight): | |
| import matplotlib | |
| matplotlib.use('Agg') | |
| import matplotlib.pyplot as plt | |
| from ezdxf.addons.drawing import Frontend, RenderContext | |
| from ezdxf.addons.drawing.config import BackgroundPolicy, ColorPolicy, Configuration | |
| from ezdxf.addons.drawing.matplotlib import MatplotlibBackend | |
| x0, y0, x1, y1 = region | |
| W, H = round((x1 - x0) * ppu), round((y1 - y0) * ppu) | |
| sel = [e for e, b in ents if b[2] >= x0 and b[0] <= x1 and b[3] >= y0 and b[1] <= y1] | |
| fig = plt.figure(figsize=(W / 100, H / 100), dpi=100) | |
| ax = fig.add_axes([0, 0, 1, 1]) | |
| ax.set_axis_off() | |
| cfg = Configuration(color_policy=ColorPolicy.BLACK, background_policy=BackgroundPolicy.WHITE, | |
| lineweight_scaling=0, min_lineweight=lineweight) | |
| Frontend(RenderContext(doc), MatplotlibBackend(ax), config=cfg).draw_entities(sel) | |
| ax.set_xlim(x0, x1) | |
| ax.set_ylim(y0, y1) | |
| fig.savefig(out_png, dpi=100, facecolor='white') | |
| plt.close(fig) | |
| im = Image.open(out_png).convert('RGB') | |
| if im.size != (W, H): | |
| im = im.resize((W, H), Image.LANCZOS) | |
| im.save(out_png) | |
| return im, len(sel) | |
| # ----------------------------------------------------------------------------------------------- geometry | |
| def px_to_world(box, region, ppu): | |
| x0, y0, x1, y1 = box | |
| rx0, _, _, ry1 = region | |
| return [rx0 + x0 / ppu, ry1 - y1 / ppu, rx0 + x1 / ppu, ry1 - y0 / ppu] | |
| def world_to_px(pt, region, ppu): | |
| return ((pt[0] - region[0]) * ppu, (region[3] - pt[1]) * ppu) | |
| def write_annotated(dxf_in, dxf_out, dets, text_h): | |
| import ezdxf | |
| doc = ezdxf.readfile(dxf_in) | |
| msp = doc.modelspace() | |
| if 'RAQEEB' not in doc.styles: | |
| doc.styles.new('RAQEEB', dxfattribs={'font': 'arial.ttf'}) | |
| for c, n in enumerate(NAMES): | |
| name = f'RAQEEB-{n.upper()}' | |
| if name not in doc.layers: | |
| lay = doc.layers.add(name, color=ACI[c]) | |
| lay.rgb = COLORS[c] | |
| lay.dxf.lineweight = 35 | |
| for d in dets: | |
| layer = f"RAQEEB-{d['label'].upper()}" | |
| X0, Y0, X1, Y1 = d['box_world'] | |
| msp.add_lwpolyline([(X0, Y0), (X1, Y0), (X1, Y1), (X0, Y1)], close=True, dxfattribs={'layer': layer}) | |
| t = msp.add_text(f"{d['label']} {d['confidence']:.2f}", height=text_h, | |
| dxfattribs={'layer': layer, 'style': 'RAQEEB'}) | |
| t.set_placement((X0, Y1 + 0.25 * text_h)) | |
| doc.saveas(dxf_out) | |
| # ----------------------------------------------------------------------------------------------- TArch check | |
| DOOR_BLOCK = re.compile(r'DOOR|DorLib|LDOR', re.I) | |
| WIN_BLOCK = re.compile(r'WIN', re.I) | |
| def tarch_truth(ents, region): | |
| x0, y0, x1, y1 = region | |
| inside = lambda b: x0 <= (b[0] + b[2]) / 2 <= x1 and y0 <= (b[1] + b[3]) / 2 <= y1 | |
| gt = dict(door=[], window=[], column=[], wall_lines=[], stair_lines=[], room_points=[]) | |
| for e, b in ents: | |
| if not inside(b): | |
| continue | |
| t, layer = e.dxftype(), e.dxf.layer.upper() | |
| if t == 'INSERT': | |
| name = e.dxf.name | |
| if WIN_BLOCK.search(name): | |
| gt['window'].append(b) | |
| elif DOOR_BLOCK.search(name): | |
| gt['door'].append(b) | |
| elif layer == 'COLUMN': | |
| gt['column'].append(b) | |
| elif t == 'LINE' and layer == 'WALL': | |
| gt['wall_lines'].append((e.dxf.start.x, e.dxf.start.y, e.dxf.end.x, e.dxf.end.y)) | |
| elif t in ('LINE', 'LWPOLYLINE') and layer in ('STAIR', '梯道'): | |
| pts = [(e.dxf.start.x, e.dxf.start.y), (e.dxf.end.x, e.dxf.end.y)] if t == 'LINE' else \ | |
| [(p[0], p[1]) for p in e.get_points('xy')] | |
| gt['stair_lines'].extend((*pts[i], *pts[i + 1]) for i in range(len(pts) - 1)) | |
| elif t == 'TEXT' and layer == 'SPACE' and e.dxf.text.strip(): | |
| p = e.dxf.insert | |
| gt['room_points'].append((p.x, p.y)) | |
| return gt | |
| def _iou_ios(p, g): | |
| ix = max(0.0, min(p[2], g[2]) - max(p[0], g[0])) | |
| iy = max(0.0, min(p[3], g[3]) - max(p[1], g[1])) | |
| inter = ix * iy | |
| ap, ag = (p[2] - p[0]) * (p[3] - p[1]), (g[2] - g[0]) * (g[3] - g[1]) | |
| return inter / max(ap + ag - inter, 1e-9), inter / max(min(ap, ag), 1e-9) | |
| def match(preds, gts, which, thr=0.5): | |
| """Greedy one-to-one matching by confidence; which=0 -> IoU, 1 -> intersection over the smaller box.""" | |
| used, tp = set(), 0 | |
| for p in sorted(preds, key=lambda d: -d['confidence']): | |
| best, bv = None, thr | |
| for j, g in enumerate(gts): | |
| if j in used: | |
| continue | |
| v = _iou_ios(p['box_world'], g)[which] | |
| if v >= bv: | |
| best, bv = j, v | |
| if best is not None: | |
| used.add(best) | |
| tp += 1 | |
| return tp | |
| def prf(tp, n_pred, n_gt): | |
| p = tp / n_pred if n_pred else None | |
| r = tp / n_gt if n_gt else None | |
| f = 2 * p * r / (p + r) if p and r else (0.0 if p is not None and r is not None else None) | |
| return dict(true_positives=tp, predictions=n_pred, truth=n_gt, precision=None if p is None else round(p, 3), | |
| recall=None if r is None else round(r, 3), f1=None if f is None else round(f, 3)) | |
| def tarch_check(gt, dets, raw_dets, region, ppu, size): | |
| import cv2 | |
| from shapely.geometry import Point | |
| from shapely.ops import unary_union | |
| W, H = size | |
| out = {} | |
| by = lambda n: [d for d in dets if d['label'] == n] | |
| for n in ('door', 'window', 'column'): | |
| out[n] = dict(IoU_0_5=prf(match(by(n), gt[n], 0), len(by(n)), len(gt[n])), | |
| overlap_0_5=prf(match(by(n), gt[n], 1), len(by(n)), len(gt[n]))) | |
| # walls: pixel agreement between predicted wall masks and the drawing's WALL lines | |
| lines = np.zeros((H, W), np.uint8) | |
| for x0, y0, x1, y1 in gt['wall_lines']: | |
| a, b = world_to_px((x0, y0), region, ppu), world_to_px((x1, y1), region, ppu) | |
| cv2.line(lines, tuple(int(round(v)) for v in a), tuple(int(round(v)) for v in b), 1, 1) | |
| pred = np.zeros((H, W), np.uint8) | |
| for d in raw_dets: | |
| if d['class_id'] != 0: | |
| continue | |
| geoms = getattr(d['geometry'], 'geoms', [d['geometry']]) | |
| for g in geoms: | |
| if g.geom_type == 'Polygon' and not g.is_empty: | |
| cv2.fillPoly(pred, [np.round(np.asarray(g.exterior.coords)).astype(np.int32)], 1) | |
| if lines.any() and pred.any(): | |
| tol_r, tol_p = max(1, round(50 * ppu)), max(1, round(250 * ppu)) | |
| near_pred = cv2.dilate(pred, np.ones((2 * tol_r + 1, 2 * tol_r + 1), np.uint8)) | |
| dist = cv2.distanceTransform((1 - lines).astype(np.uint8), cv2.DIST_L2, 3) | |
| out['wall'] = dict(line_pixels_covered=round(float(near_pred[lines > 0].mean()), 3), | |
| predicted_pixels_on_walls=round(float((dist[pred > 0] <= tol_p).mean()), 3), | |
| note='recall-like: share of WALL-layer line pixels within 50 units of a predicted ' | |
| 'wall mask; precision-like: share of predicted wall pixels within 250 units of a ' | |
| 'WALL-layer line (drawing units, mm here)') | |
| # stairs: connected groups of STAIR-layer lines -> boxes | |
| st = np.zeros((H, W), np.uint8) | |
| for x0, y0, x1, y1 in gt['stair_lines']: | |
| a, b = world_to_px((x0, y0), region, ppu), world_to_px((x1, y1), region, ppu) | |
| cv2.line(st, tuple(int(round(v)) for v in a), tuple(int(round(v)) for v in b), 1, 1) | |
| k = max(3, round(400 * ppu)) | 1 | |
| st = cv2.morphologyEx(st, cv2.MORPH_CLOSE, np.ones((k, k), np.uint8)) | |
| n, _, stats, _ = cv2.connectedComponentsWithStats(st) | |
| stair_gt = [] | |
| for i in range(1, n): | |
| x, y, w, h = stats[i, :4] | |
| if min(w, h) >= 800 * ppu: | |
| stair_gt.append(px_to_world((x, y, x + w, y + h), region, ppu)) | |
| out['stair'] = dict(overlap_0_5=prf(match(by('stair'), stair_gt, 1), len(by('stair')), len(stair_gt))) | |
| # rooms: are the room-name texts inside a predicted space_region? | |
| spaces = [d['geometry'] for d in raw_dets if d['class_id'] == 10] | |
| if gt['room_points']: | |
| u = unary_union(spaces) if spaces else None | |
| hit = sum(1 for p in gt['room_points'] if u is not None and u.contains(Point(*world_to_px(p, region, ppu)))) | |
| out['space_region'] = dict(room_labels=len(gt['room_points']), inside_a_predicted_space=hit, | |
| share=round(hit / len(gt['room_points']), 3), predicted_spaces=len(spaces)) | |
| out['truth_definition'] = ('door: TArch door blocks (*DOOR*, DorLib*, LDOR*), window: *WIN* blocks, column: ' | |
| 'blocks on layer COLUMN, stair: connected STAIR/梯道 line groups, rooms: SPACE texts. ' | |
| 'IoU_0_5 = box IoU >= 0.5; overlap_0_5 = intersection over the smaller box >= 0.5 ' | |
| '(tolerates door swing arcs being in or out of a box).') | |
| return out | |
| # ----------------------------------------------------------------------------------------------- main | |
| def main(): | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument('drawing', type=Path) | |
| ap.add_argument('--weights', type=Path, required=True) | |
| ap.add_argument('--thresholds', type=Path, required=True) | |
| ap.add_argument('--out', type=Path, required=True) | |
| ap.add_argument('--region', action='append', default=[], help='name=x0,y0,x1,y1 in drawing units') | |
| ap.add_argument('--px-per-unit', type=float, default=0.1) | |
| ap.add_argument('--tile', type=int, default=1024) | |
| ap.add_argument('--overlap', type=int, default=256) | |
| ap.add_argument('--imgsz', type=int, default=1024) | |
| ap.add_argument('--device', default='0') | |
| ap.add_argument('--lineweight', type=float, default=4, help='rendered line width in 1/300 inch at 100 dpi') | |
| ap.add_argument('--font', default='msyh.ttc') | |
| ap.add_argument('--text-height', type=float, help='label height in drawing units (default: 0.25%% of region)') | |
| ap.add_argument('--plot', action='store_true', help='plot the annotated DWG regions to PDF with AutoCAD') | |
| ap.add_argument('--tarch-check', action='store_true') | |
| ap.add_argument('--no-dwg', action='store_true', help='skip writing the annotated DWG') | |
| ap.add_argument('--accore', help='path to accoreconsole.exe') | |
| a = ap.parse_args() | |
| a.out.mkdir(parents=True, exist_ok=True) | |
| out = a.out.resolve() | |
| accore = None | |
| if a.drawing.suffix.lower() == '.dwg' or a.plot or not a.no_dwg: | |
| accore = a.accore or find_accoreconsole() | |
| stem = a.drawing.stem | |
| if a.drawing.suffix.lower() == '.dwg': | |
| dxf = out / f'{stem}.dxf' | |
| if not dxf.exists(): | |
| print('DWG -> DXF with', accore, flush=True) | |
| dwg_to_dxf(accore, a.drawing.resolve(), dxf, out) | |
| else: | |
| dxf = a.drawing.resolve() | |
| t = time.time() | |
| doc, ents = load_for_render(dxf, a.font) | |
| print(f'loaded {len(ents)} entities in {time.time() - t:.0f}s', flush=True) | |
| regions = [] | |
| for spec in a.region or []: | |
| name, coords = spec.split('=') | |
| regions.append((name, [float(v) for v in coords.split(',')])) | |
| if not regions: | |
| xs = [b for _, b in ents] | |
| regions = [('extents', [min(b[0] for b in xs), min(b[1] for b in xs), max(b[2] for b in xs), | |
| max(b[3] for b in xs)])] | |
| from ultralytics import YOLO | |
| from infer_raqeeb import infer_page | |
| model = YOLO(str(a.weights)) | |
| config = json.loads(a.thresholds.read_text()) | |
| args = SimpleNamespace(tile=a.tile, overlap=a.overlap, imgsz=a.imgsz, device=a.device) | |
| ppu = a.px_per_unit | |
| all_dets, summary = [], dict(drawing=str(a.drawing), dxf=str(dxf), px_per_unit=ppu, tile=a.tile, | |
| overlap=a.overlap, thresholds=str(a.thresholds), weights=str(a.weights), regions={}) | |
| for name, region in regions: | |
| t = time.time() | |
| im, n_ent = render(doc, ents, region, ppu, out / f'{name}_input.png', a.lineweight) | |
| t_render = time.time() - t | |
| raw, _ = infer_page(model, im, config, args) | |
| t_det = time.time() - t - t_render | |
| boxes = boxes_from_detections(raw) | |
| for b in boxes: | |
| b['box_world'] = [round(v, 1) for v in px_to_world(b['box_xyxy'], region, ppu)] | |
| all_dets.extend(boxes) | |
| draw_boxes(im, boxes, line=2, font_px=15).save(out / f'{name}_annotated_full.jpg', quality=90) | |
| s = min(1.0, 2400 / max(im.size)) | |
| small = im.resize((round(im.width * s), round(im.height * s)), Image.LANCZOS) | |
| after = draw_boxes(small, [dict(b, box_xyxy=[v * s for v in b['box_xyxy']]) for b in boxes], font_px=12) | |
| after.save(out / f'{name}_annotated.jpg', quality=92) | |
| before_after(small, after, title_left='AutoCAD drawing (rendered)').save(out / f'{name}_before_after.jpg', | |
| quality=90) | |
| counts = {} | |
| for b in boxes: | |
| counts[b['label']] = counts.get(b['label'], 0) + 1 | |
| rec = dict(region=region, image_size=list(im.size), entities_rendered=n_ent, counts=counts, | |
| seconds_render=round(t_render, 1), seconds_detect=round(t_det, 1)) | |
| if a.tarch_check: | |
| rec['tarch_check'] = tarch_check(tarch_truth(ents, region), boxes, raw, region, ppu, im.size) | |
| summary['regions'][name] = rec | |
| (out / f'{name}_detections.json').write_text(json.dumps(dict(rec, boxes=boxes), indent=1, ensure_ascii=False), | |
| encoding='utf-8') | |
| print(f'{name}: {len(boxes)} boxes {counts} render {t_render:.0f}s detect {t_det:.0f}s', flush=True) | |
| if a.tarch_check: | |
| print(json.dumps(rec['tarch_check'], ensure_ascii=False), flush=True) | |
| text_h = a.text_height or 0.0025 * max(max(r[2] - r[0], r[3] - r[1]) for _, r in regions) | |
| ann_dxf = out / f'{stem}_raqeeb.dxf' | |
| write_annotated(dxf, ann_dxf, all_dets, text_h) | |
| summary['annotated_dxf'] = str(ann_dxf) | |
| if not a.no_dwg: | |
| ann_dwg = out / f'{stem}_raqeeb.dwg' | |
| dxf_to_dwg(accore, ann_dxf, ann_dwg, out) | |
| summary['annotated_dwg'] = str(ann_dwg) | |
| if a.plot: | |
| for name, region in regions: | |
| pdf = out / f'{name}_autocad_plot.pdf' | |
| ok = plot_pdf(accore, ann_dwg, region, pdf, out, f'plot_{name}') | |
| if ok: | |
| pdf_to_png(pdf, out / f'{name}_autocad_plot.png') | |
| summary['regions'][name]['autocad_plot'] = str(pdf) if ok else 'failed (see log)' | |
| print(f'{name}: AutoCAD plot', 'ok' if ok else 'FAILED', flush=True) | |
| (out / 'summary.json').write_text(json.dumps(summary, indent=2, ensure_ascii=False), encoding='utf-8') | |
| print('done ->', out) | |
| if __name__ == '__main__': | |
| main() | |