sieve.py

"""Filter layers.

Either keep only a set of layers or drop a set of them. Polygons and labels on a removed layer are discarded;
everything else is carried through unchanged. Passing both keep and drop is ambiguous, so it is rejected.
"""
from __future__ import annotations
import argparse

import load as _load


def sieve(layout, keep=None, drop=None):
    """Return a new Layout with only the kept layers (or with the dropped layers removed)."""
    if keep is not None and drop is not None:
        raise ValueError("pass keep or drop, not both")
    keep_set = {tuple(k) for k in keep} if keep is not None else None
    drop_set = {tuple(d) for d in drop} if drop is not None else set()

    def kept(layer):
        return layer in keep_set if keep_set is not None else layer not in drop_set

    out = _load.Layout(name=layout.name)
    for layer, polys in layout.polys.items():
        if kept(layer):
            out.polys[layer] = list(polys)
    out.labels = [(layer, text, pos) for layer, text, pos in layout.labels if kept(layer)]
    return out


def _validate():
    layout = _load.from_gdstk_library(_load._build_demo_library())

    kept = sieve(layout, keep=[(1, 0)])
    ok_keep = kept.layers == {(1, 0)}

    dropped = sieve(layout, drop=[(2, 0)])
    ok_drop = dropped.layers == {(1, 0)} and dropped.labels == layout.labels   # label on (10,0) survives

    try:
        sieve(layout, keep=[(1, 0)], drop=[(2, 0)])
        ok_reject = False
    except ValueError:
        ok_reject = True

    for label, cond in [("keep-only", ok_keep), ("drop", ok_drop), ("keep+drop rejected", ok_reject)]:
        print(f"[{label}]  {'PASS' if cond else 'FAIL'}")
    print("RESULT:", "PASS" if all([ok_keep, ok_drop, ok_reject]) else "FAIL")


def main():
    ap = argparse.ArgumentParser(description="filter layers (keep / drop)")
    ap.add_argument("--validate", action="store_true")
    ap.parse_args(); _validate()


if __name__ == "__main__":
    main()