#!/usr/bin/env python3
"""Generate a conceptual four-quadrant guide to PC1 and PC2 kernel scores."""
from __future__ import annotations
import argparse
from dataclasses import dataclass
from pathlib import Path
from xml.etree import ElementTree
OUTPUT_DEFAULT = Path(__file__).with_name("pca-toy-score-extremes.svg")
@dataclass(frozen=True)
class ToyKernel:
pc1: str
pc2: str
center_x: float
center_y: float
length: float
width: float
asymmetry: float
groove_fraction: float
KERNELS = (
ToyKernel("low", "high", 300, 205, 126, 82, 2, 0.48),
ToyKernel("high", "high", 730, 205, 184, 120, 3, 0.48),
ToyKernel("low", "low", 300, 438, 142, 60, 16, 0.72),
ToyKernel("high", "low", 730, 438, 205, 86, 22, 0.72),
)
def fmt(value: float) -> str:
return f"{value:.2f}".rstrip("0").rstrip(".")
def kernel_path(kernel: ToyKernel) -> str:
"""Return a smooth seed-like outline whose parameters encode the toy traits."""
cx = kernel.center_x
cy = kernel.center_y
half_length = kernel.length / 2
half_width = kernel.width / 2
skew = kernel.asymmetry
return (
f"M {fmt(cx - half_length)} {fmt(cy)} "
f"C {fmt(cx - half_length * 0.72)} {fmt(cy - half_width - skew * 0.18)}, "
f"{fmt(cx + half_length * 0.35)} {fmt(cy - half_width + skew * 0.08)}, "
f"{fmt(cx + half_length)} {fmt(cy - skew * 0.12)} "
f"C {fmt(cx + half_length * 0.55)} {fmt(cy + half_width + skew * 0.22)}, "
f"{fmt(cx - half_length * 0.35)} {fmt(cy + half_width - skew * 0.05)}, "
f"{fmt(cx - half_length)} {fmt(cy)} Z"
)
def groove_path(kernel: ToyKernel) -> str:
half_groove = kernel.length * kernel.groove_fraction / 2
shift = kernel.asymmetry * 0.18
return (
f"M {fmt(kernel.center_x - half_groove)} {fmt(kernel.center_y + shift)} "
f"Q {fmt(kernel.center_x)} {fmt(kernel.center_y - shift * 0.7)}, "
f"{fmt(kernel.center_x + half_groove)} {fmt(kernel.center_y - shift)}"
)
def kernel_group(kernel: ToyKernel) -> str:
label = f"{kernel.pc1} PC1, {kernel.pc2} PC2"
return f'''
'''
def render_svg() -> str:
kernels = "\n".join(kernel_group(kernel) for kernel in KERNELS)
return f'''
'''
def verify_concept() -> None:
combinations = {(kernel.pc1, kernel.pc2) for kernel in KERNELS}
assert combinations == {
("low", "low"),
("low", "high"),
("high", "low"),
("high", "high"),
}
by_scores = {(kernel.pc1, kernel.pc2): kernel for kernel in KERNELS}
for pc2 in ("low", "high"):
low_pc1 = by_scores[("low", pc2)]
high_pc1 = by_scores[("high", pc2)]
assert high_pc1.length > low_pc1.length
assert high_pc1.width > low_pc1.width
for pc1 in ("low", "high"):
low_pc2 = by_scores[(pc1, "low")]
high_pc2 = by_scores[(pc1, "high")]
assert high_pc2.width / high_pc2.length > low_pc2.width / low_pc2.length
assert abs(high_pc2.asymmetry) < abs(low_pc2.asymmetry)
assert high_pc2.groove_fraction < low_pc2.groove_fraction
def verify_svg(svg_text: str) -> None:
root = ElementTree.fromstring(svg_text)
assert root.tag.endswith("svg")
assert root.get("role") == "img"
assert root.get("aria-labelledby") == "toyPcaTitle toyPcaDesc"
namespace = {"svg": "http://www.w3.org/2000/svg"}
assert root.find("svg:title", namespace) is not None
assert root.find("svg:desc", namespace) is not None
groups = root.findall(".//svg:g[@data-pc1]", namespace)
assert len(groups) == 4
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--output", type=Path, default=OUTPUT_DEFAULT)
parser.add_argument("--verify", action="store_true")
args = parser.parse_args()
verify_concept()
svg_text = render_svg()
verify_svg(svg_text)
if args.verify:
if not args.output.exists() or args.output.read_text(encoding="utf-8") != svg_text:
raise SystemExit(f"verification failed: {args.output}")
print(f"verified toy PCA score guide in {args.output}")
return
args.output.parent.mkdir(parents=True, exist_ok=True)
args.output.write_text(svg_text, encoding="utf-8")
print(f"wrote {args.output}")
if __name__ == "__main__":
main()