Add files using upload-large-folder tool

derived/Source/circuit_generation_code/DC/00056.eps

@@ -303,9 +303,7 @@ endgate
 1.00 30 672 656 arrowhead90
 1  1.00 672 656 752 704 2 polygon
 1.00 0 288 368 gnd
-1.00 0 840 592 person_shocked
 1  1.00 704 608 784 608 2 polygon
-1.00 0 864 512 gnd
 3  1.00 304 320 864 320 864 448 3 polygon
 (path for current through the dirt) {/Helvetica 1.000 cf} 2 16 0 304 256 label
 1.00 -1 688 304 arrowhead90

derived/Source/circuit_generation_code/DC/00057.eps

@@ -284,8 +284,6 @@ endgate
 1.00 30 672 700 arrowhead90
 1  1.00 672 700 752 748 2 polygon
 1.00 0 288 412 gnd
-1.00 0 880 316 gnd
-1.00 0 848 396 person
 (person \(not shocked\)) {/Helvetica 1.000 cf} 2 16 0 896 460 label
 1  1.00 704 412 784 412 2 polygon
 3  1.00 304 364 864 268 2 polygon

derived/Source/circuit_generation_code/DC/00058.eps

@@ -284,8 +284,6 @@ endgate
 1.00 30 672 548 arrowhead90
 1  1.00 672 548 752 596 2 polygon
 1  1.00 704 500 784 500 2 polygon
-1.00 0 864 404 gnd
-1.00 0 832 484 person
 (person \(not shocked\)) {/Helvetica 1.000 cf} 2 16 0 880 548 label
 1.00 0 704 500 dot
 pgsave restore showpage

derived/Source/circuit_generation_code/DC/00059.eps

@@ -325,9 +325,7 @@ endgate
 (bird \(not shocked\)) {/Helvetica 1.000 cf} 2 16 0 819 1024 label
 1.00 30 787 960 arrowhead90
 1  1.00 787 960 867 1008 2 polygon
-1.00 0 955 896 person_shocked
 1  1.00 819 912 899 912 2 polygon
-1.00 0 979 816 gnd
 1.00 -1 791 404 arrowhead90
 1  1.00 791 404 551 404 2 polygon
 1.00 0 1011 656 arrowhead

derived/Source/circuit_generation_code/DC/00060.eps

@@ -326,9 +326,7 @@ endgate
 (bird \(not shocked\)) {/Helvetica 1.000 cf} 2 16 0 867 1024 label
 1.00 30 835 960 arrowhead90
 1  1.00 835 960 915 1008 2 polygon
-1.00 0 1003 656 person_shocked
 1  1.00 867 672 947 672 2 polygon
-1.00 0 1027 576 gnd
 1.00 0 599 404 arrowhead90
 1  1.00 839 404 599 404 2 polygon
 1.00 -181 1075 432 arrowhead
@@ -341,9 +339,7 @@ endgate
 (for shock current through the victim.) {/Helvetica-Oblique 1.000 cf} 2 16 0 419 256 label
 3  1.00 435 432 339 432 339 736 3 polygon
 3  1.00 435 432 1027 432 1027 512 3 polygon
-1.00 0 995 896 person
 1  1.00 867 912 947 912 2 polygon
-1.00 0 1021 824 gnd
 (person \(not shocked\)) {/Helvetica 1.000 cf} 2 16 0 1043 960 label
 1.00 0 451 912 dot
 1.00 0 867 912 dot

derived/Source/circuit_generation_code/DC/00061.eps

@@ -302,13 +302,9 @@ endgate
 (bird \(not shocked\)) {/Helvetica 1.000 cf} 2 16 0 704 796 label
 1.00 30 672 732 arrowhead90
 1  1.00 672 732 752 780 2 polygon
-1.00 0 840 428 person_shocked
 1  1.00 704 444 784 444 2 polygon
-1.00 0 864 348 gnd
 (person \(SHOCKED!\)) {/Helvetica 1.000 cf} 2 16 0 896 476 label
 1  1.00 704 684 784 684 2 polygon
-1.00 0 858 596 gnd
-1.00 0 824 668 person_shocked
 (person \(SHOCKED!\)) {/Helvetica 1.000 cf} 2 16 0 880 716 label
 3  1.00 864 556 1312 556 1312 300 880 300 4 polygon
 1.00 -1 1024 268 arrowhead90

derived/Source/circuit_generation_code/DC/00069.eps

@@ -315,7 +315,6 @@ endgate
 1  1.00 1498 1114 1146 1242 2 polygon
 5  1.00 458 602 458 458 2 polygon
 5  1.00 1834 602 1834 458 2 polygon
-1.00 0 1338 682 person_shocked
 5  1.00 1306 602 1306 506 2 polygon
 5  1.00 1370 602 1370 506 2 polygon
 1.00 270 1274 522 arrow

derived/Source/hf_dataset/state.json

@@ -4,7 +4,7 @@
       "filename": "data-00000-of-00001.arrow"
     }
   ],
-  "_fingerprint": "006442694d37a914",
+  "_fingerprint": "545a5d8fc5886e81",
   "_format_columns": null,
   "_format_kwargs": {},
   "_format_type": null,

derived/Source/metadata/pruned_figures.jsonl

@@ -0,0 +1,33 @@
+{"book": "DC", "figure_id": "00017", "reason": "hydraulic analogy illustration", "references": [{"caption": null, "chapter": "BASIC CONCEPTS OF ELECTRICITY", "line": 390, "raw_reference": "00017.png", "reference_source": "basiccon.sml", "section": "Voltage and current"}]}
+{"book": "DC", "figure_id": "00019", "reason": "hydraulic analogy illustration", "references": [{"caption": null, "chapter": "BASIC CONCEPTS OF ELECTRICITY", "line": 406, "raw_reference": "00019.png", "reference_source": "basiccon.sml", "section": "Voltage and current"}]}
+{"book": "DC", "figure_id": "00022", "reason": "hydraulic analogy illustration", "references": [{"caption": null, "chapter": "BASIC CONCEPTS OF ELECTRICITY", "line": 467, "raw_reference": "00022.png", "reference_source": "basiccon.sml", "section": "Voltage and current"}]}
+{"book": "DC", "figure_id": "00023", "reason": "hydraulic analogy illustration", "references": [{"caption": null, "chapter": "BASIC CONCEPTS OF ELECTRICITY", "line": 477, "raw_reference": "00023.png", "reference_source": "basiccon.sml", "section": "Voltage and current"}]}
+{"book": "DC", "figure_id": "00031", "reason": "hydraulic analogy illustration", "references": [{"caption": null, "chapter": "BASIC CONCEPTS OF ELECTRICITY", "line": 663, "raw_reference": "00031.png", "reference_source": "basiccon.sml", "section": "Voltage and current in a practical circuit"}]}
+{"book": "DC", "figure_id": "00146", "reason": "meter illustration section", "references": [{"caption": null, "chapter": "DC METERING CIRCUITS", "line": 47, "raw_reference": "00146.png", "reference_source": "dcmeter.sml", "section": "What is a meter?"}]}
+{"book": "DC", "figure_id": "00148", "reason": "meter illustration section", "references": [{"caption": null, "chapter": "DC METERING CIRCUITS", "line": 78, "raw_reference": "00148.png", "reference_source": "dcmeter.sml", "section": "What is a meter?"}]}
+{"book": "DC", "figure_id": "00149", "reason": "meter illustration section", "references": [{"caption": null, "chapter": "DC METERING CIRCUITS", "line": 91, "raw_reference": "00149.png", "reference_source": "dcmeter.sml", "section": "What is a meter?"}]}
+{"book": "DC", "figure_id": "00152", "reason": "instrument or device illustration", "references": [{"caption": null, "chapter": "DC METERING CIRCUITS", "line": 224, "raw_reference": "00152.png", "reference_source": "dcmeter.sml", "section": "Voltmeter design"}]}
+{"book": "DC", "figure_id": "00181", "reason": "instrument or device illustration", "references": [{"caption": null, "chapter": "DC METERING CIRCUITS", "line": 1397, "raw_reference": "00181.png", "reference_source": "dcmeter.sml", "section": "Wattmeter design"}]}
+{"book": "DC", "figure_id": "00182", "reason": "instrument or device illustration", "references": [{"caption": null, "chapter": "DC METERING CIRCUITS", "line": 1403, "raw_reference": "00182.png", "reference_source": "dcmeter.sml", "section": "Wattmeter design"}]}
+{"book": "DC", "figure_id": "00202", "reason": "chemical cell illustration", "references": [{"caption": null, "chapter": "ELECTRICAL INSTRUMENTATION SIGNALS", "line": 474, "raw_reference": "00202.png", "reference_source": "dcsignal.sml", "section": "pH measurement"}]}
+{"book": "DC", "figure_id": "00203", "reason": "chemical cell illustration", "references": [{"caption": null, "chapter": "ELECTRICAL INSTRUMENTATION SIGNALS", "line": 487, "raw_reference": "00203.png", "reference_source": "dcsignal.sml", "section": "pH measurement"}]}
+{"book": "DC", "figure_id": "00259", "reason": "chemical cell illustration", "references": [{"caption": null, "chapter": "BATTERIES AND POWER SYSTEMS", "line": 82, "raw_reference": "00259.png", "reference_source": "batt.sml", "section": "Electron activity in chemical reactions"}]}
+{"book": "DC", "figure_id": "00271", "reason": "chemical cell illustration", "references": [{"caption": null, "chapter": "BATTERIES AND POWER SYSTEMS", "line": 377, "raw_reference": "00271.png", "reference_source": "batt.sml", "section": "Special-purpose batteries"}]}
+{"book": "AC", "figure_id": "02157", "reason": "instrument or device illustration", "references": [{"caption": "Short-circuit switch allows ammeter to be removed from an active current transformer circuit.", "chapter": "TRANSFORMERS", "line": 1233, "raw_reference": "02157.png", "reference_source": "trans.sml", "section": "Special transformers and applications"}]}
+{"book": "AC", "figure_id": "02224", "reason": "instrument or device illustration", "references": [{"caption": "Passing AC through this D'Arsonval meter movement causes useless flutter of the needle.", "chapter": "AC METERING CIRCUITS", "line": 18, "raw_reference": "02224.png", "reference_source": "acmeter.sml", "section": "AC voltmeters and ammeters"}]}
+{"book": "AC", "figure_id": "02225", "reason": "instrument or device illustration", "references": [{"caption": "Passing AC through this Rectified AC meter movement will drive it in one direction.", "chapter": "AC METERING CIRCUITS", "line": 28, "raw_reference": "02225.png", "reference_source": "acmeter.sml", "section": "AC voltmeters and ammeters"}]}
+{"book": "AC", "figure_id": "02246", "reason": "instrument or device illustration", "references": [{"caption": "Iron-vane electromechanical meter movement.", "chapter": "AC METERING CIRCUITS", "line": 34, "raw_reference": "02246.png", "reference_source": "acmeter.sml", "section": "AC voltmeters and ammeters"}]}
+{"book": "AC", "figure_id": "02250", "reason": "instrument or device illustration", "references": [{"caption": "Resonant frequency meter ``peaks'' as L-C resonant frequency is tuned to test frequency.", "chapter": "AC METERING CIRCUITS", "line": 189, "raw_reference": "02250.png", "reference_source": "acmeter.sml", "section": "Frequency and phase measurement"}]}
+{"book": "AC", "figure_id": "02315", "reason": "instrument or device illustration", "references": [{"caption": "Multiplier resistor (a) or resistive divider (b) scales the range of the basic meter movement.", "chapter": "AC METERING CIRCUITS", "line": 47, "raw_reference": "02315.png", "reference_source": "acmeter.sml", "section": "AC voltmeters and ammeters"}]}
+{"book": "AC", "figure_id": "02316", "reason": "instrument or device illustration", "references": [{"caption": "AC voltmeter with capacitive divider.", "chapter": "AC METERING CIRCUITS", "line": 55, "raw_reference": "02316.png", "reference_source": "acmeter.sml", "section": "AC voltmeters and ammeters"}]}
+{"book": "AC", "figure_id": "02317", "reason": "instrument or device illustration", "references": [{"caption": "An electrostatic meter movement may use a capacitive multiplier to multiply the scale of the basic meter movement..", "chapter": "AC METERING CIRCUITS", "line": 61, "raw_reference": "02317.png", "reference_source": "acmeter.sml", "section": "AC voltmeters and ammeters"}]}
+{"book": "AC", "figure_id": "12148", "reason": "instrument or device illustration", "references": [{"caption": null, "chapter": "TRANSMISSION LINES", "line": 186, "raw_reference": "12148.png", "reference_source": "lines.sml", "section": "Characteristic impedance"}]}
+{"book": "SEMI", "figure_id": "03015", "reason": "chemical cell illustration", "references": [{"caption": null, "chapter": "ELECTRON TUBES", "line": 418, "raw_reference": "03015.png", "reference_source": "tubes.sml", "section": "Ionization (gas-filled) tubes"}]}
+{"book": "SEMI", "figure_id": "03492", "reason": "instrument or device illustration", "references": [{"caption": "TR One, one transistor radio. No-bias-resistor causes operation as a detector. After Stoner, Figure 4.4A. <cite>DLS</cite>", "chapter": "PRACTICAL ANALOG SEMICONDUCTOR CIRCUITS", "line": 707, "raw_reference": "03492.png", "reference_source": "analog.sml", "section": "Radio circuits -- INCOMPLETE"}]}
+{"book": "SEMI", "figure_id": "03493", "reason": "instrument or device illustration", "references": [{"caption": "Crystal radio with one transistor audio amplifer, base-bias. After Stoner, Figure 4.3A. <cite>DLS</cite>", "chapter": "PRACTICAL ANALOG SEMICONDUCTOR CIRCUITS", "line": 718, "raw_reference": "03493.png", "reference_source": "analog.sml", "section": "Radio circuits -- INCOMPLETE"}]}
+{"book": "REF", "figure_id": "01056", "reason": "instrument or device illustration", "references": [{"caption": null, "chapter": "CIRCUIT SCHEMATIC SYMBOLS", "line": 133, "raw_reference": "01056.png", "reference_source": "symbol.sml", "section": "Diodes"}]}
+{"book": "EXP", "figure_id": "05036", "reason": "instrument or device illustration", "references": [{"caption": null, "chapter": "BASIC CONCEPTS AND TEST EQUIPMENT", "line": 78, "raw_reference": "05036.png", "reference_source": "basic.sml", "section": "Voltmeter usage"}]}
+{"book": "EXP", "figure_id": "05069", "reason": "instrument or device illustration", "references": [{"caption": null, "chapter": "BASIC CONCEPTS AND TEST EQUIPMENT", "line": 1233, "raw_reference": "05069.png", "reference_source": "basic.sml", "section": "Electromagnetism"}]}
+{"book": "LIII", "figure_id": "motor_16", "reason": "instrument or device illustration", "references": [{"caption": null, "chapter": "Variable-speed motor controls", "line": 43100, "line_excerpt": "$$\\includegraphics{motor_16.eps}$$", "reference_source": "liii_2v16.latex", "section": "DC motor speed control", "subsection": null}]}
+{"book": "LIII", "figure_id": "optical_27", "reason": "instrument or device illustration", "references": [{"caption": null, "chapter": "Continuous analytical measurement", "line": 35788, "line_excerpt": "$$\\includegraphics{optical_27.eps}$$", "reference_source": "liii_2v16.latex", "section": "Fluorescence", "subsection": null}]}
+{"book": "LIII", "figure_id": "pressure04", "reason": "hydraulic analogy illustration", "references": [{"caption": null, "chapter": "Physics", "line": 4353, "line_excerpt": "$$\\includegraphics{pressure04.eps}$$", "reference_source": "liii_2v16.latex", "section": "Fluid mechanics", "subsection": "Pressure"}]}

derived/Source/metadata/structure_summary.json

@@ -1,66 +1,81 @@
 {
   "books": {
     "AC": {
-      "circuit_rows": 303,
+      "circuit_rows": 294,
+      "cropped_rows": 19,
       "display_name": "Lessons In Electric Circuits, Volume II \u2013 AC",
       "pdf_name": "AC.pdf",
       "pdf_origin": "bundled",
       "pdf_path_used": "/workspace/SchemID/SchemSourceAvailable/AC.pdf",
       "pdf_url_used": null,
       "pdf_version_sync": true,
+      "pruned_rows": 9,
       "referenced_figures": 727,
+      "sanitized_rows": 0,
       "source_kind": "sml",
       "source_notes": [],
       "source_version": null
     },
     "DC": {
-      "circuit_rows": 368,
+      "circuit_rows": 353,
+      "cropped_rows": 14,
       "display_name": "Lessons In Electric Circuits, Volume I \u2013 DC",
       "pdf_name": "DC.pdf",
       "pdf_origin": "bundled",
       "pdf_path_used": "/workspace/SchemID/SchemSourceAvailable/DC.pdf",
       "pdf_url_used": null,
       "pdf_version_sync": true,
+      "pruned_rows": 15,
       "referenced_figures": 787,
+      "sanitized_rows": 13,
       "source_kind": "sml",
       "source_notes": [],
       "source_version": null
     },
     "DIGI": {
       "circuit_rows": 358,
+      "cropped_rows": 6,
       "display_name": "Lessons In Electric Circuits, Volume IV \u2013 Digital",
       "pdf_name": "DIGI.pdf",
       "pdf_origin": "bundled",
       "pdf_path_used": "/workspace/SchemID/SchemSourceAvailable/DIGI.pdf",
       "pdf_url_used": null,
       "pdf_version_sync": true,
+      "pruned_rows": 0,
       "referenced_figures": 674,
+      "sanitized_rows": 0,
       "source_kind": "sml",
       "source_notes": [],
       "source_version": null
     },
     "EXP": {
-      "circuit_rows": 281,
+      "circuit_rows": 279,
+      "cropped_rows": 9,
       "display_name": "Lessons In Electric Circuits, Volume VI \u2013 Experiments",
       "pdf_name": "EXP.pdf",
       "pdf_origin": "bundled",
       "pdf_path_used": "/workspace/SchemID/SchemSourceAvailable/EXP.pdf",
       "pdf_url_used": null,
       "pdf_version_sync": true,
+      "pruned_rows": 2,
       "referenced_figures": 396,
+      "sanitized_rows": 0,
       "source_kind": "sml",
       "source_notes": [],
       "source_version": null
     },
     "LIII": {
-      "circuit_rows": 117,
+      "circuit_rows": 114,
+      "cropped_rows": 11,
       "display_name": "Lessons In Industrial Instrumentation",
       "pdf_name": "liii_2v16.pdf",
       "pdf_origin": "downloaded",
       "pdf_path_used": "/workspace/SchemID/derived/Source/work/cache/pdfs/liii_2v16.pdf",
       "pdf_url_used": "https://www.ibiblio.org/kuphaldt/socratic/sinst/book/liii_2v16.pdf",
       "pdf_version_sync": true,
+      "pruned_rows": 3,
       "referenced_figures": 2714,
+      "sanitized_rows": 0,
       "source_kind": "latex",
       "source_notes": [
         "Using the source-matched Lessons in Industrial Instrumentation version 2.16 PDF downloaded from ibiblio for verification."
@@ -68,27 +83,33 @@
       "source_version": "2.16"
     },
     "REF": {
-      "circuit_rows": 43,
+      "circuit_rows": 42,
+      "cropped_rows": 1,
       "display_name": "Lessons In Electric Circuits, Volume V \u2013 Reference",
       "pdf_name": "REF.pdf",
       "pdf_origin": "bundled",
       "pdf_path_used": "/workspace/SchemID/SchemSourceAvailable/REF.pdf",
       "pdf_url_used": null,
       "pdf_version_sync": true,
+      "pruned_rows": 1,
       "referenced_figures": 164,
+      "sanitized_rows": 0,
       "source_kind": "sml",
       "source_notes": [],
       "source_version": null
     },
     "SEMI": {
-      "circuit_rows": 339,
+      "circuit_rows": 336,
+      "cropped_rows": 34,
       "display_name": "Lessons In Electric Circuits, Volume III \u2013 Semiconductors",
       "pdf_name": "SEMI.pdf",
       "pdf_origin": "bundled",
       "pdf_path_used": "/workspace/SchemID/SchemSourceAvailable/SEMI.pdf",
       "pdf_url_used": null,
       "pdf_version_sync": true,
+      "pruned_rows": 3,
       "referenced_figures": 630,
+      "sanitized_rows": 0,
       "source_kind": "sml",
       "source_notes": [],
       "source_version": null

derived/Source/metadata/verification_summary.json

@@ -1,81 +1,81 @@
 {
   "books": {
     "AC": {
-      "html_png_exact_false": 253,
+      "html_png_exact_false": 247,
       "html_png_exact_missing": 0,
-      "html_png_exact_true": 50,
-      "pdf_proxy_verified_false": 253,
-      "pdf_proxy_verified_true": 50,
-      "reference_png_exact_false": 253,
+      "html_png_exact_true": 47,
+      "pdf_proxy_verified_false": 247,
+      "pdf_proxy_verified_true": 47,
+      "reference_png_exact_false": 247,
       "reference_png_exact_missing": 0,
-      "reference_png_exact_true": 50,
-      "rows": 303
+      "reference_png_exact_true": 47,
+      "rows": 294
     },
     "DC": {
-      "html_png_exact_false": 0,
+      "html_png_exact_false": 27,
       "html_png_exact_missing": 0,
-      "html_png_exact_true": 368,
-      "pdf_proxy_verified_false": 0,
-      "pdf_proxy_verified_true": 368,
-      "reference_png_exact_false": 0,
+      "html_png_exact_true": 326,
+      "pdf_proxy_verified_false": 27,
+      "pdf_proxy_verified_true": 326,
+      "reference_png_exact_false": 27,
       "reference_png_exact_missing": 0,
-      "reference_png_exact_true": 368,
-      "rows": 368
+      "reference_png_exact_true": 326,
+      "rows": 353
     },
     "DIGI": {
-      "html_png_exact_false": 0,
+      "html_png_exact_false": 6,
       "html_png_exact_missing": 0,
-      "html_png_exact_true": 358,
-      "pdf_proxy_verified_false": 0,
-      "pdf_proxy_verified_true": 358,
-      "reference_png_exact_false": 0,
+      "html_png_exact_true": 352,
+      "pdf_proxy_verified_false": 6,
+      "pdf_proxy_verified_true": 352,
+      "reference_png_exact_false": 6,
       "reference_png_exact_missing": 0,
-      "reference_png_exact_true": 358,
+      "reference_png_exact_true": 352,
       "rows": 358
     },
     "EXP": {
-      "html_png_exact_false": 0,
+      "html_png_exact_false": 5,
       "html_png_exact_missing": 0,
-      "html_png_exact_true": 281,
-      "pdf_proxy_verified_false": 0,
-      "pdf_proxy_verified_true": 281,
-      "reference_png_exact_false": 0,
+      "html_png_exact_true": 274,
+      "pdf_proxy_verified_false": 5,
+      "pdf_proxy_verified_true": 274,
+      "reference_png_exact_false": 5,
       "reference_png_exact_missing": 0,
-      "reference_png_exact_true": 281,
-      "rows": 281
+      "reference_png_exact_true": 274,
+      "rows": 279
     },
     "LIII": {
       "html_png_exact_false": 0,
-      "html_png_exact_missing": 117,
+      "html_png_exact_missing": 114,
       "html_png_exact_true": 0,
-      "pdf_proxy_verified_false": 117,
+      "pdf_proxy_verified_false": 114,
       "pdf_proxy_verified_true": 0,
       "reference_png_exact_false": 0,
-      "reference_png_exact_missing": 117,
+      "reference_png_exact_missing": 114,
       "reference_png_exact_true": 0,
-      "rows": 117
+      "rows": 114
     },
     "REF": {
-      "html_png_exact_false": 0,
+      "html_png_exact_false": 1,
       "html_png_exact_missing": 0,
-      "html_png_exact_true": 43,
-      "pdf_proxy_verified_false": 0,
-      "pdf_proxy_verified_true": 43,
-      "reference_png_exact_false": 0,
+      "html_png_exact_true": 41,
+      "pdf_proxy_verified_false": 1,
+      "pdf_proxy_verified_true": 41,
+      "reference_png_exact_false": 1,
       "reference_png_exact_missing": 0,
-      "reference_png_exact_true": 43,
-      "rows": 43
+      "reference_png_exact_true": 41,
+      "rows": 42
     },
     "SEMI": {
-      "html_png_exact_false": 3,
+      "html_png_exact_false": 29,
       "html_png_exact_missing": 0,
-      "html_png_exact_true": 336,
-      "pdf_proxy_verified_false": 3,
-      "pdf_proxy_verified_true": 336,
-      "reference_png_exact_false": 3,
+      "html_png_exact_true": 307,
+      "pdf_proxy_verified_false": 29,
+      "pdf_proxy_verified_true": 307,
+      "reference_png_exact_false": 29,
       "reference_png_exact_missing": 0,
-      "reference_png_exact_true": 336,
-      "rows": 339
+      "reference_png_exact_true": 307,
+      "rows": 336
     }
   }
 }

derived/Source/scripts/build_circuit_dataset.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import math
 import os
 import re
 import shutil
@@ -17,6 +18,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
+import numpy as np
 import pyarrow as pa
 import pyarrow.parquet as pq
 from datasets import Dataset, Features, Image as HFImage, Value
@@ -65,9 +67,87 @@ CIRCUIT_PROCEDURE_WHITELIST = {
     "source",
     "transistor2",
 }
+PRIMARY_SEED_PROCEDURES = {
+    "LED",
+    "acsource",
+    "battery",
+    "capacitor",
+    "diode",
+    "fuse_blown",
+    "inductor",
+    "npn",
+    "opamp",
+    "pnp",
+    "potentiometer",
+    "resistor",
+    "source",
+}
+PROC_BBOX_CATALOG: dict[str, tuple[int, int, int, int]] = {
+    "LED": (-16, -32, 32, 59),
+    "acsource": (-32, -64, 64, 128),
+    "battery": (-32, -64, 64, 128),
+    "capacitor": (-32, -64, 64, 128),
+    "diode": (-8, -48, 36, 96),
+    "fuse_blown": (-16, -32, 32, 62),
+    "gnd": (-32, -60, 64, 68),
+    "inductor": (-14, -64, 29, 112),
+    "npn": (-64, -64, 72, 128),
+    "opamp": (-80, -80, 160, 160),
+    "pnp": (-64, -64, 72, 128),
+    "potentiometer": (-46, -64, 78, 128),
+    "resistor": (-14, -64, 28, 128),
+    "source": (-32, -64, 64, 128),
+}
+STRIP_INVOCATION_PROCEDURES = {"person", "person_shocked"}
+NON_CIRCUIT_SOURCE_PATTERNS: tuple[tuple[re.Pattern[str], str], ...] = (
+    (
+        re.compile(r"\breservoir\b|\bpond\b|\bpump\b|water flow", re.I),
+        "hydraulic analogy illustration",
+    ),
+    (
+        re.compile(
+            r"lead-acid|fuel cell|electrolyte|electrode|hydrogen|oxygen|membranes?\b",
+            re.I,
+        ),
+        "chemical cell illustration",
+    ),
+    (
+        re.compile(
+            r"meter movement|moving coil|electron gun|view-screen|vacuum|needle|magnet\b",
+            re.I,
+        ),
+        "instrument or device illustration",
+    ),
+)
 
 XCIRCUIT_CREATOR_RE = re.compile(r"^%%Creator:\s*(.+)$", re.M)
 EPS_PROC_RE = re.compile(r"^/([A-Za-z][A-Za-z0-9_-]*)\s*\{", re.M)
+PROC_BBOX_RE = re.compile(
+    r"^/(?P<name>[A-Za-z][A-Za-z0-9_-]*)\s*\{\n%\s*"
+    r"(?P<x>-?\d+)\s+(?P<y>-?\d+)\s+(?P<w>-?\d+)\s+(?P<h>-?\d+)\s+bbox",
+    re.M,
+)
+PAGE_BODY_RE = re.compile(
+    r"(?P<prefix>^%%Page:.*?^/pgsave save def bop\n)(?P<body>.*?)(?P<suffix>^pgsave restore showpage.*?\Z)",
+    re.S | re.M,
+)
+PROC_CALL_RE = re.compile(
+    r"(?P<scale>-?\d+(?:\.\d+)?)\s+(?P<rot>-?\d+(?:\.\d+)?)\s+"
+    r"(?P<x>-?\d+(?:\.\d+)?)\s+(?P<y>-?\d+(?:\.\d+)?)\s+"
+    r"(?P<name>[A-Za-z][A-Za-z0-9_]*)\b"
+)
+PAGE_SCALE_RE = re.compile(r"(?P<scale>[0-9.]+)\s+(?P<kind>inchscale|cmscale)")
+PAGE_TRANSLATE_RE = re.compile(
+    r"(?P<x>-?\d+(?:\.\d+)?)\s+(?P<y>-?\d+(?:\.\d+)?)\s+translate"
+)
+INVOCATION_LINE_RE = re.compile(
+    r"^\s*-?\d+(?:\.\d+)?\s+-?\d+(?:\.\d+)?\s+-?\d+(?:\.\d+)?\s+-?\d+(?:\.\d+)?\s+(?P<name>[A-Za-z][A-Za-z0-9_]*)\s*$"
+)
+FULL_INVOCATION_LINE_RE = re.compile(
+    r"^\s*(?P<scale>-?\d+(?:\.\d+)?)\s+(?P<rot>-?\d+(?:\.\d+)?)\s+"
+    r"(?P<x>-?\d+(?:\.\d+)?)\s+(?P<y>-?\d+(?:\.\d+)?)\s+"
+    r"(?P<name>[A-Za-z][A-Za-z0-9_]*)\s*$"
+)
 SML_TOKEN_RE = re.compile(
     r"(?P<chapter><chaptertitle>(?P<chapter_text>.*?)</chaptertitle>)"
     r"|(?P<section><sectiontitle>(?P<section_text>.*?)</sectiontitle>)"
@@ -391,6 +471,456 @@ def parse_eps_metadata(eps_path: Path) -> dict[str, Any]:
     }
 
 
+def parse_eps_bounding_box(source_code: str) -> tuple[float, float, float, float]:
+    match = re.search(
+        r"^%%BoundingBox:\s*(\S+)\s+(\S+)\s+(\S+)\s+(\S+)", source_code, re.M
+    )
+    if not match:
+        raise ValueError("Missing EPS bounding box")
+    return tuple(float(value) for value in match.groups())
+
+
+def split_page_body(source_code: str) -> tuple[str, str, str] | None:
+    match = PAGE_BODY_RE.search(source_code)
+    if not match:
+        return None
+    return match.group("prefix"), match.group("body"), match.group("suffix")
+
+
+def replace_page_body(source_code: str, new_body: str) -> str:
+    page_parts = split_page_body(source_code)
+    if not page_parts:
+        return source_code
+    prefix, _, suffix = page_parts
+    return source_code[: PAGE_BODY_RE.search(source_code).start()] + prefix + new_body + suffix
+
+
+def strip_forbidden_invocations(source_code: str) -> tuple[str, list[str]]:
+    page_parts = split_page_body(source_code)
+    if not page_parts:
+        return source_code, []
+
+    prefix, body, suffix = page_parts
+    kept_lines: list[str] = []
+    removed: list[str] = []
+    for line in body.splitlines():
+        match = INVOCATION_LINE_RE.match(line)
+        if match and match.group("name") in STRIP_INVOCATION_PROCEDURES:
+            removed.append(match.group("name"))
+            continue
+        kept_lines.append(line)
+
+    rewritten = source_code[: PAGE_BODY_RE.search(source_code).start()] + prefix
+    if kept_lines:
+        rewritten += "\n".join(kept_lines) + "\n"
+    rewritten += suffix
+    return rewritten, sorted(set(removed))
+
+
+def strip_trailing_ground_invocations(source_code: str) -> tuple[str, int]:
+    page_parts = split_page_body(source_code)
+    if not page_parts:
+        return source_code, 0
+
+    prefix, body, suffix = page_parts
+    anchor_x: float | None = None
+    for line in body.splitlines():
+        match = FULL_INVOCATION_LINE_RE.match(line)
+        if not match:
+            continue
+        name = match.group("name")
+        if name in PRIMARY_SEED_PROCEDURES:
+            x = float(match.group("x"))
+            anchor_x = x if anchor_x is None else max(anchor_x, x)
+
+    if anchor_x is None:
+        return source_code, 0
+
+    kept_lines: list[str] = []
+    removed = 0
+    for line in body.splitlines():
+        match = FULL_INVOCATION_LINE_RE.match(line)
+        if match and match.group("name") == "gnd" and float(match.group("x")) > anchor_x + 64.0:
+            removed += 1
+            continue
+        kept_lines.append(line)
+
+    rewritten = source_code[: PAGE_BODY_RE.search(source_code).start()] + prefix
+    if kept_lines:
+        rewritten += "\n".join(kept_lines) + "\n"
+    rewritten += suffix
+    return rewritten, removed
+
+
+def reject_reason_for_figure(
+    book: BookConfig,
+    refs: list[dict[str, Any]],
+    source_code: str,
+) -> str | None:
+    chapter = normalize_space(refs[0].get("chapter") or "").lower() if refs else ""
+    section = normalize_space(refs[0].get("section") or "").lower() if refs else ""
+    if (
+        book.slug == "DC"
+        and chapter == "dc metering circuits"
+        and section == "what is a meter?"
+    ):
+        return "meter illustration section"
+
+    for pattern, reason in NON_CIRCUIT_SOURCE_PATTERNS:
+        if pattern.search(source_code):
+            return reason
+    return None
+
+
+def parse_page_transform(source_code: str) -> tuple[tuple[float, float, float, float], float, float, float]:
+    bbox = parse_eps_bounding_box(source_code)
+    page_parts = split_page_body(source_code)
+    if not page_parts:
+        return bbox, 1.0, 0.0, 0.0
+
+    _, body, _ = page_parts
+    scale_match = PAGE_SCALE_RE.search(body)
+    scale = 1.0
+    if scale_match:
+        unit_scale = 0.375 if scale_match.group("kind") == "inchscale" else 0.35433071
+        scale = float(scale_match.group("scale")) * unit_scale
+
+    translate_match = PAGE_TRANSLATE_RE.search(body)
+    tx = float(translate_match.group("x")) if translate_match else 0.0
+    ty = float(translate_match.group("y")) if translate_match else 0.0
+    return bbox, scale, tx, ty
+
+
+def placed_seed_boxes(source_code: str, image_size: tuple[int, int]) -> list[tuple[str, int, int, int, int]]:
+    bbox, page_scale, tx, ty = parse_page_transform(source_code)
+    page_parts = split_page_body(source_code)
+    if not page_parts:
+        return []
+
+    definitions = {
+        match.group("name"): (
+            int(match.group("x")),
+            int(match.group("y")),
+            int(match.group("w")),
+            int(match.group("h")),
+        )
+        for match in PROC_BBOX_RE.finditer(source_code)
+    }
+
+    _, body, _ = page_parts
+    llx, lly, urx, ury = bbox
+    width, height = image_size
+    seeds: list[tuple[str, int, int, int, int]] = []
+
+    for match in PROC_CALL_RE.finditer(body):
+        name = match.group("name")
+        if name not in PRIMARY_SEED_PROCEDURES:
+            continue
+        local_bbox = definitions.get(name) or PROC_BBOX_CATALOG.get(name)
+        if not local_bbox:
+            continue
+
+        scale = abs(float(match.group("scale")))
+        rotation = math.radians(float(match.group("rot")))
+        x = float(match.group("x"))
+        y = float(match.group("y"))
+        bx, by, bw, bh = local_bbox
+        corners = [
+            (bx, by),
+            (bx + bw, by),
+            (bx, by + bh),
+            (bx + bw, by + bh),
+        ]
+        page_points: list[tuple[float, float]] = []
+        for cx, cy in corners:
+            sx = cx * scale
+            sy = cy * scale
+            rx = sx * math.cos(rotation) - sy * math.sin(rotation)
+            ry = sx * math.sin(rotation) + sy * math.cos(rotation)
+            page_points.append((page_scale * (tx + x + rx), page_scale * (ty + y + ry)))
+
+        xs = [point[0] for point in page_points]
+        ys = [point[1] for point in page_points]
+        left = max(0, int((min(xs) - llx) / (urx - llx) * width))
+        right = min(width - 1, int((max(xs) - llx) / (urx - llx) * width))
+        top = max(0, int((ury - max(ys)) / (ury - lly) * height))
+        bottom = min(height - 1, int((ury - min(ys)) / (ury - lly) * height))
+        seeds.append((name, left, top, right, bottom))
+
+    return seeds
+
+
+def widest_low_ink_run(values: np.ndarray, max_dark: int) -> tuple[int, int] | None:
+    best: tuple[int, int] | None = None
+    run_start: int | None = None
+    for index, value in enumerate(values):
+        if int(value) <= max_dark:
+            if run_start is None:
+                run_start = index
+            continue
+        if run_start is not None:
+            candidate = (run_start, index - 1)
+            if not best or (candidate[1] - candidate[0]) > (best[1] - best[0]):
+                best = candidate
+            run_start = None
+    if run_start is not None:
+        candidate = (run_start, len(values) - 1)
+        if not best or (candidate[1] - candidate[0]) > (best[1] - best[0]):
+            best = candidate
+    return best
+
+
+def pixel_bbox_from_mask(mask: np.ndarray) -> tuple[int, int, int, int] | None:
+    ys, xs = np.where(mask)
+    if xs.size == 0 or ys.size == 0:
+        return None
+    return int(xs.min()), int(ys.min()), int(xs.max()), int(ys.max())
+
+
+def connected_components(mask: np.ndarray) -> tuple[np.ndarray, list[tuple[int, int, int, int, int, int]]]:
+    height, width = mask.shape
+    seen = np.zeros((height, width), dtype=np.uint8)
+    labels = np.full((height, width), -1, dtype=np.int32)
+    components: list[tuple[int, int, int, int, int, int]] = []
+    label = 0
+
+    for y in range(height):
+        for x in range(width):
+            if not mask[y, x] or seen[y, x]:
+                continue
+            stack = [(x, y)]
+            seen[y, x] = 1
+            area = 0
+            min_x = max_x = x
+            min_y = max_y = y
+            while stack:
+                cx, cy = stack.pop()
+                labels[cy, cx] = label
+                area += 1
+                min_x = min(min_x, cx)
+                max_x = max(max_x, cx)
+                min_y = min(min_y, cy)
+                max_y = max(max_y, cy)
+                for ny in range(max(0, cy - 1), min(height, cy + 2)):
+                    for nx in range(max(0, cx - 1), min(width, cx + 2)):
+                        if mask[ny, nx] and not seen[ny, nx]:
+                            seen[ny, nx] = 1
+                            stack.append((nx, ny))
+            components.append((label, area, min_x, min_y, max_x, max_y))
+            label += 1
+
+    return labels, components
+
+
+def crop_pixels_to_eps_points(
+    pixel_bbox: tuple[int, int, int, int],
+    image_size: tuple[int, int],
+    eps_bbox: tuple[float, float, float, float],
+) -> tuple[float, float, float, float]:
+    left, top, right, bottom = pixel_bbox
+    width, height = image_size
+    llx, lly, urx, ury = eps_bbox
+    eps_left = llx + (left / width) * (urx - llx)
+    eps_right = llx + ((right + 1) / width) * (urx - llx)
+    eps_top = ury - (top / height) * (ury - lly)
+    eps_bottom = ury - ((bottom + 1) / height) * (ury - lly)
+    return eps_left, eps_bottom, eps_right, eps_top
+
+
+def crop_eps_points_to_pixels(
+    crop_bbox: tuple[float, float, float, float],
+    image_size: tuple[int, int],
+    eps_bbox: tuple[float, float, float, float],
+) -> tuple[int, int, int, int]:
+    crop_llx, crop_lly, crop_urx, crop_ury = crop_bbox
+    llx, lly, urx, ury = eps_bbox
+    width, height = image_size
+    left = max(0, math.floor((crop_llx - llx) / (urx - llx) * width))
+    right = min(width, math.ceil((crop_urx - llx) / (urx - llx) * width))
+    top = max(0, math.floor((ury - crop_ury) / (ury - lly) * height))
+    bottom = min(height, math.ceil((ury - crop_lly) / (ury - lly) * height))
+    return left, top, right, bottom
+
+
+def apply_clip_bbox(
+    source_code: str, crop_bbox: tuple[float, float, float, float]
+) -> str:
+    page_parts = split_page_body(source_code)
+    if not page_parts:
+        return source_code
+
+    clip_llx, clip_lly, clip_urx, clip_ury = crop_bbox
+    prefix, body, suffix = page_parts
+    clip_ps = (
+        f"newpath {clip_llx:.3f} {clip_lly:.3f} moveto "
+        f"{clip_urx:.3f} {clip_lly:.3f} lineto "
+        f"{clip_urx:.3f} {clip_ury:.3f} lineto "
+        f"{clip_llx:.3f} {clip_ury:.3f} lineto closepath clip newpath\n"
+    )
+    rewritten = source_code[: PAGE_BODY_RE.search(source_code).start()] + prefix + clip_ps + body + suffix
+
+    bbox_line = "%%BoundingBox: {} {} {} {}".format(
+        math.floor(clip_llx),
+        math.floor(clip_lly),
+        math.ceil(clip_urx),
+        math.ceil(clip_ury),
+    )
+    rewritten = re.sub(r"^%%BoundingBox:.*$", bbox_line, rewritten, count=1, flags=re.M)
+    return rewritten
+
+
+def render_source_code_to_png(
+    source_code: str,
+    eps_path: Path,
+    png_path: Path,
+    *,
+    device: str,
+) -> None:
+    eps_path.parent.mkdir(parents=True, exist_ok=True)
+    eps_path.write_text(source_code)
+    render_eps_to_png(eps_path, png_path, device=device)
+
+
+def derive_crop_bbox(
+    source_code: str,
+    analysis_png_path: Path,
+) -> tuple[int, int, int, int] | None:
+    with Image.open(analysis_png_path) as image:
+        gray = np.array(image.convert("L"))
+
+    mask = gray < 220
+    full_bbox = pixel_bbox_from_mask(mask)
+    if not full_bbox:
+        return None
+
+    seeds = placed_seed_boxes(source_code, (gray.shape[1], gray.shape[0]))
+    if not seeds:
+        return None
+
+    seed_left = min(seed[1] for seed in seeds)
+    seed_top = min(seed[2] for seed in seeds)
+    seed_right = max(seed[3] for seed in seeds)
+    seed_bottom = max(seed[4] for seed in seeds)
+
+    full_left, _, full_right, _ = full_bbox
+    column_sums = mask.sum(axis=0)
+    gap_dark_max = 1
+    gap_min_width = max(24, int(gray.shape[1] * 0.08))
+    left_gap_abs: tuple[int, int] | None = None
+    right_gap_abs: tuple[int, int] | None = None
+
+    if seed_left - full_left >= gap_min_width:
+        left_gap = widest_low_ink_run(column_sums[full_left:seed_left], gap_dark_max)
+        if left_gap and (left_gap[1] - left_gap[0] + 1) >= gap_min_width:
+            left_gap_abs = (full_left + left_gap[0], full_left + left_gap[1])
+
+    if full_right - seed_right >= gap_min_width:
+        right_gap = widest_low_ink_run(column_sums[seed_right + 1 : full_right + 1], gap_dark_max)
+        if right_gap and (right_gap[1] - right_gap[0] + 1) >= gap_min_width:
+            right_gap_abs = (seed_right + 1 + right_gap[0], seed_right + 1 + right_gap[1])
+
+    if not left_gap_abs and not right_gap_abs:
+        return None
+
+    labels, components = connected_components(mask)
+    component_ids: set[int] = set()
+    for _, left, top, right, bottom in seeds:
+        if right < left or bottom < top:
+            continue
+        sub = labels[top : bottom + 1, left : right + 1]
+        component_ids.update(int(value) for value in np.unique(sub) if value >= 0)
+
+    picked = [component for component in components if component[0] in component_ids]
+    if not picked:
+        return None
+
+    margin_x = max(8, int(gray.shape[1] * 0.02))
+    margin_y = max(8, int(gray.shape[0] * 0.05))
+    left = max(0, min(component[2] for component in picked) - margin_x)
+    top = max(0, min(component[3] for component in picked) - margin_y)
+    right = min(gray.shape[1] - 1, max(component[4] for component in picked) + margin_x)
+    bottom = min(gray.shape[0] - 1, max(component[5] for component in picked) + margin_y)
+
+    if left_gap_abs:
+        left = max(left, left_gap_abs[1] + 1)
+    if right_gap_abs:
+        right = min(right, right_gap_abs[0] - 1)
+
+    if right <= left or bottom <= top:
+        return None
+
+    cropped_area = (right - left + 1) * (bottom - top + 1)
+    full_area = gray.shape[0] * gray.shape[1]
+    if cropped_area >= full_area * 0.94:
+        return None
+    return left, top, right, bottom
+
+
+def crop_image_to_bbox(
+    source_path: Path,
+    output_path: Path,
+    crop_bbox: tuple[float, float, float, float],
+    eps_bbox: tuple[float, float, float, float],
+) -> None:
+    with Image.open(source_path) as image:
+        left, top, right, bottom = crop_eps_points_to_pixels(crop_bbox, image.size, eps_bbox)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        image.crop((left, top, right, bottom)).save(output_path)
+
+
+def prepare_figure_artifact(
+    book: BookConfig,
+    figure_stem: str,
+    refs: list[dict[str, Any]],
+    source_code: str,
+    temp_root: Path,
+) -> dict[str, Any]:
+    reject_reason = reject_reason_for_figure(book, refs, source_code)
+    if reject_reason:
+        return {"keep": False, "reject_reason": reject_reason}
+
+    sanitized_code, removed_procedures = strip_forbidden_invocations(source_code)
+    removed_grounds = 0
+    if removed_procedures:
+        sanitized_code, removed_grounds = strip_trailing_ground_invocations(sanitized_code)
+    original_bbox = parse_eps_bounding_box(sanitized_code)
+
+    analysis_eps = temp_root / "analysis_eps" / book.slug / f"{figure_stem}.eps"
+    analysis_png = temp_root / "analysis_png" / book.slug / f"{figure_stem}.png"
+    analysis_eps.parent.mkdir(parents=True, exist_ok=True)
+    analysis_png.parent.mkdir(parents=True, exist_ok=True)
+    write_no_text_eps(sanitized_code, analysis_eps)
+    render_eps_to_png(analysis_eps, analysis_png, device="pnggray")
+
+    crop_bbox_px = None if removed_procedures else derive_crop_bbox(sanitized_code, analysis_png)
+    crop_bbox_eps = None
+    if crop_bbox_px:
+        with Image.open(analysis_png) as analysis_image:
+            crop_bbox_eps = crop_pixels_to_eps_points(
+                crop_bbox_px,
+                analysis_image.size,
+                original_bbox,
+            )
+    derived_code = apply_clip_bbox(sanitized_code, crop_bbox_eps) if crop_bbox_eps else sanitized_code
+
+    extraction_mode = "whole"
+    if crop_bbox_eps:
+        extraction_mode = "cropped"
+    elif removed_procedures:
+        extraction_mode = "sanitized"
+
+    return {
+        "keep": True,
+        "source_code": derived_code,
+        "original_eps_bbox": original_bbox,
+        "crop_bbox_eps": crop_bbox_eps,
+        "crop_bbox_px": crop_bbox_px,
+        "removed_procedures": removed_procedures,
+        "removed_auxiliary_grounds": removed_grounds,
+        "extraction_mode": extraction_mode,
+    }
+
+
 def write_no_text_eps(source_code: str, output_path: Path) -> None:
     needle = "%%EndComments\n"
     if needle in source_code:
@@ -441,21 +971,41 @@ def render_task(task: dict[str, Any]) -> dict[str, Any]:
     output_png = Path(task["output_png"])
     no_text_png = Path(task["no_text_png"])
     temp_no_text_eps = Path(task["temp_no_text_eps"])
+    temp_reference_png = Path(task["temp_reference_png"]) if task["temp_reference_png"] else None
+    temp_html_png = Path(task["temp_html_png"]) if task["temp_html_png"] else None
     reference_png = Path(task["reference_png"]) if task["reference_png"] else None
     html_png = Path(task["html_png"]) if task["html_png"] else None
     pdf_text_path = Path(task["pdf_text_path"]) if task["pdf_text_path"] else None
     captions = task["captions"]
     source_code = task["source_code"]
+    crop_bbox_eps = tuple(task["crop_bbox_eps"]) if task["crop_bbox_eps"] else None
+    original_eps_bbox = tuple(task["original_eps_bbox"]) if task["original_eps_bbox"] else None
     render_device = "pnggray"
     reference_png_exact = None
-    if reference_png and reference_png.exists():
+    reference_compare_path = reference_png
+    if (
+        reference_png
+        and reference_png.exists()
+        and crop_bbox_eps
+        and original_eps_bbox
+        and temp_reference_png
+    ):
+        crop_image_to_bbox(reference_png, temp_reference_png, crop_bbox_eps, original_eps_bbox)
+        reference_compare_path = temp_reference_png
+
+    html_compare_path = html_png
+    if html_png and html_png.exists() and crop_bbox_eps and original_eps_bbox and temp_html_png:
+        crop_image_to_bbox(html_png, temp_html_png, crop_bbox_eps, original_eps_bbox)
+        html_compare_path = temp_html_png
+
+    if reference_compare_path and reference_compare_path.exists():
         render_device = "pngalpha"
         render_eps_to_png(eps_path, output_png, device=render_device)
-        reference_png_exact = images_equal_rgba(output_png, reference_png)
+        reference_png_exact = images_equal_rgba(output_png, reference_compare_path)
         if not reference_png_exact:
             render_device = "pnggray"
             render_eps_to_png(eps_path, output_png, device=render_device)
-            reference_png_exact = images_equal_rgba(output_png, reference_png)
+            reference_png_exact = images_equal_rgba(output_png, reference_compare_path)
     else:
         render_eps_to_png(eps_path, output_png, device=render_device)
 
@@ -465,8 +1015,8 @@ def render_task(task: dict[str, Any]) -> dict[str, Any]:
     no_text_status = "rendered"
 
     html_exact = None
-    if html_png:
-        html_exact = images_equal_rgba(output_png, html_png)
+    if html_compare_path and html_compare_path.exists():
+        html_exact = images_equal_rgba(output_png, html_compare_path)
 
     pdf_caption_pages: list[int] = []
     if pdf_text_path.exists() and captions:
@@ -538,15 +1088,13 @@ def main() -> None:
     parquet_path = derived_root / "circuits.parquet"
     payload_root = Path("/workspace/hf_upload_payload")
 
-    for path in [
-        work_root,
-        extracted_root,
-        cache_root,
-        temp_root,
-        rendered_root,
-        code_root,
-        metadata_root,
-    ]:
+    for path in [rendered_root, code_root, metadata_root, dataset_root, temp_root]:
+        if path.exists():
+            shutil.rmtree(path)
+    if parquet_path.exists():
+        parquet_path.unlink()
+
+    for path in [work_root, extracted_root, cache_root, temp_root, rendered_root, code_root, metadata_root]:
         path.mkdir(parents=True, exist_ok=True)
 
     ensure_inputs(repo_root, extracted_root)
@@ -563,6 +1111,7 @@ def main() -> None:
 
     records: list[dict[str, Any]] = []
     render_jobs: list[dict[str, Any]] = []
+    pruned_records: list[dict[str, Any]] = []
     structure_summary: dict[str, Any] = {"books": {}}
 
     for book in BOOKS:
@@ -584,6 +1133,9 @@ def main() -> None:
             "pdf_version_sync": pdf_source["pdf_version_sync"],
             "referenced_figures": len(figure_refs),
             "circuit_rows": 0,
+            "cropped_rows": 0,
+            "sanitized_rows": 0,
+            "pruned_rows": 0,
             "source_notes": list(pdf_source["notes"]),
         }
         if not pdf_source["pdf_version_sync"]:
@@ -601,16 +1153,40 @@ def main() -> None:
             if not eps_meta["is_circuit"]:
                 continue
 
+            prepared = prepare_figure_artifact(
+                book,
+                figure_stem,
+                refs,
+                eps_meta["code"],
+                temp_root,
+            )
+            if not prepared["keep"]:
+                book_summary["pruned_rows"] += 1
+                pruned_records.append(
+                    {
+                        "book": book.slug,
+                        "figure_id": figure_stem,
+                        "reason": prepared["reject_reason"],
+                        "references": refs,
+                    }
+                )
+                continue
+
             book_summary["circuit_rows"] += 1
+            if prepared["extraction_mode"] == "cropped":
+                book_summary["cropped_rows"] += 1
+            if prepared["removed_procedures"]:
+                book_summary["sanitized_rows"] += 1
             book_code_dir = code_root / book.slug
             book_code_dir.mkdir(parents=True, exist_ok=True)
             code_copy_path = book_code_dir / eps_path.name
-            if not code_copy_path.exists():
-                shutil.copy2(eps_path, code_copy_path)
+            code_copy_path.write_text(prepared["source_code"])
 
             rendered_png = rendered_root / "original" / book.slug / f"{figure_stem}.png"
             no_text_png = rendered_root / "no_text" / book.slug / f"{figure_stem}.png"
             temp_no_text_eps = temp_root / "no_text_eps" / book.slug / f"{figure_stem}.eps"
+            temp_reference_png = temp_root / "reference_png" / book.slug / f"{figure_stem}.png"
+            temp_html_png = temp_root / "html_png" / book.slug / f"{figure_stem}.png"
 
             captions = sorted(
                 {
@@ -645,12 +1221,19 @@ def main() -> None:
                 "eps_path": str(code_copy_path.relative_to(derived_root)),
                 "eps_creator": eps_meta["creator"],
                 "circuit_tokens": eps_meta["circuit_tokens"],
+                "extraction": {
+                    "mode": prepared["extraction_mode"],
+                    "crop_bbox_eps": prepared["crop_bbox_eps"],
+                    "crop_bbox_px": prepared["crop_bbox_px"],
+                    "removed_procedures": prepared["removed_procedures"],
+                    "removed_auxiliary_grounds": prepared["removed_auxiliary_grounds"],
+                },
                 "references": refs,
                 "verification": {},
             }
 
             record = {
-                "Circuit Generation Code": eps_meta["code"],
+                "Circuit Generation Code": prepared["source_code"],
                 "Circuit generated image": str(rendered_png),
                 "Circuit Generated image with no text": str(no_text_png),
                 "Source": source_payload,
@@ -661,15 +1244,19 @@ def main() -> None:
                 {
                     "book": book.slug,
                     "figure_id": figure_stem,
-                    "eps_path": str(eps_path),
+                    "eps_path": str(code_copy_path),
                     "output_png": str(rendered_png),
                     "no_text_png": str(no_text_png),
                     "temp_no_text_eps": str(temp_no_text_eps),
+                    "temp_reference_png": str(temp_reference_png),
+                    "temp_html_png": str(temp_html_png),
                     "reference_png": str(reference_png) if reference_png else None,
                     "html_png": str(html_png) if html_png else None,
                     "pdf_text_path": str(pdf_text_cache_paths[book.slug]),
                     "captions": captions,
-                    "source_code": eps_meta["code"],
+                    "source_code": prepared["source_code"],
+                    "crop_bbox_eps": prepared["crop_bbox_eps"],
+                    "original_eps_bbox": prepared["original_eps_bbox"],
                 }
             )
 
@@ -723,6 +1310,15 @@ def main() -> None:
                 verification["notes"].append(
                     "Archived HTML PNG comparison was also recorded."
                 )
+        extraction_mode = source_payload.get("extraction", {}).get("mode")
+        if extraction_mode == "cropped":
+            verification["notes"].append(
+                "Verification used the cropped circuit-only region from the reference figure."
+            )
+        elif extraction_mode == "sanitized":
+            verification["notes"].append(
+                "Circuit-only rendering removed non-circuit procedural elements before verification."
+            )
 
         source_payload["verification"] = verification
 
@@ -778,6 +1374,9 @@ def main() -> None:
     with (metadata_root / "rows.jsonl").open("w") as handle:
         for row in dataset_rows:
             handle.write(json.dumps(row, sort_keys=True) + "\n")
+    with (metadata_root / "pruned_figures.jsonl").open("w") as handle:
+        for row in pruned_records:
+            handle.write(json.dumps(row, sort_keys=True) + "\n")
 
     features = Features(
         {

derived/Source/scripts/build_sheet_pdf.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import argparse
 import csv
 from pathlib import Path
 
@@ -10,21 +11,35 @@ import img2pdf
 
 SOURCE_ROOT = Path("/workspace/SchemID/derived/Source")
 SHEETS_ROOT = SOURCE_ROOT / "sheets"
-MANIFEST_PATH = SHEETS_ROOT / "sheet_manifest.csv"
-OUTPUT_PDF = SHEETS_ROOT / "all_visualization_sheets.pdf"
 FIXED_DPI = (300, 300)
 
 
 def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--manifest",
+        type=Path,
+        default=SHEETS_ROOT / "sheet_manifest.csv",
+        help="Sheet manifest CSV path.",
+    )
+    parser.add_argument(
+        "--output-pdf",
+        type=Path,
+        default=SHEETS_ROOT / "all_visualization_sheets.pdf",
+        help="Output PDF path.",
+    )
+    args = parser.parse_args()
+
     image_paths: list[str] = []
-    with MANIFEST_PATH.open(newline="") as handle:
+    with args.manifest.open(newline="") as handle:
         reader = csv.DictReader(handle)
         for row in reader:
             image_path = SHEETS_ROOT / row["sheet_png"]
             image_paths.append(str(image_path))
 
     layout_fun = img2pdf.get_fixed_dpi_layout_fun(FIXED_DPI)
-    with OUTPUT_PDF.open("wb") as handle:
+    args.output_pdf.parent.mkdir(parents=True, exist_ok=True)
+    with args.output_pdf.open("wb") as handle:
         handle.write(img2pdf.convert(image_paths, layout_fun=layout_fun))
 
 

derived/Source/scripts/generate_visual_sheets.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import argparse
 import csv
 import html
 import json
@@ -18,8 +19,6 @@ REPO_ROOT = Path("/workspace/SchemID")
 SOURCE_ROOT = REPO_ROOT / "derived" / "Source"
 ROWS_PATH = SOURCE_ROOT / "metadata" / "rows.jsonl"
 SHEETS_ROOT = SOURCE_ROOT / "sheets"
-SHEETS_ORIGINAL_ROOT = SHEETS_ROOT / "original"
-MANIFEST_PATH = SHEETS_ROOT / "sheet_manifest.csv"
 
 PAGE_W = 4200
 PAGE_H = 5940
@@ -224,7 +223,31 @@ def build_page(rows: list[dict], display_name: str, book: str, page_number: int,
 
 
 def main() -> None:
-    SHEETS_ORIGINAL_ROOT.mkdir(parents=True, exist_ok=True)
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--image-field",
+        default="Circuit generated image",
+        choices=[
+            "Circuit generated image",
+            "Circuit Generated image with no text",
+        ],
+        help="Dataset row field containing the image path to place on the sheets.",
+    )
+    parser.add_argument(
+        "--output-subdir",
+        default="original",
+        help="Subdirectory under derived/Source/sheets where the page PNGs will be written.",
+    )
+    parser.add_argument(
+        "--manifest-name",
+        default="sheet_manifest.csv",
+        help="Manifest filename written under derived/Source/sheets.",
+    )
+    args = parser.parse_args()
+
+    sheets_output_root = SHEETS_ROOT / args.output_subdir
+    manifest_path = SHEETS_ROOT / args.manifest_name
+    sheets_output_root.mkdir(parents=True, exist_ok=True)
 
     grouped: dict[str, list[dict]] = defaultdict(list)
     display_names: dict[str, str] = {}
@@ -239,7 +262,7 @@ def main() -> None:
                 {
                     "book": book,
                     "figure_id": source_payload["figure_id"],
-                    "image_path": Path(raw["Circuit generated image"]),
+                    "image_path": Path(raw[args.image_field]),
                     "primary_title": pick_primary_title(source_payload),
                     "context": pick_context(source_payload),
                     "source_line": pick_source_line(source_payload),
@@ -260,7 +283,7 @@ def main() -> None:
             end = start + PER_PAGE
             page_rows = rows[start:end]
             output_path = (
-                SHEETS_ORIGINAL_ROOT
+                sheets_output_root
                 / book
                 / f"{book}_sheet_{page_index + 1:03d}.png"
             )
@@ -284,7 +307,15 @@ def main() -> None:
                 }
             )
 
-    with MANIFEST_PATH.open("w", newline="") as handle:
+    keep_paths = {
+        (SHEETS_ROOT / row["sheet_png"]).resolve()
+        for row in manifest_rows
+    }
+    for path in sheets_output_root.rglob("*.png"):
+        if path.resolve() not in keep_paths:
+            path.unlink()
+
+    with manifest_path.open("w", newline="") as handle:
         writer = csv.DictWriter(
             handle,
             fieldnames=[