| |
| """Classify face shape candidates from four tape measurements. |
| |
| Only relative comparisons between your four numbers are used, because published |
| face-shape guides state their rules in relative terms. "Roughly equal" uses a |
| single tie band (--tol, default 3%) that is this tool's own parameter, not a |
| figure from any published study. Where measurements alone cannot separate two |
| shapes (e.g. round vs square depends on jaw angle), the tool says so instead |
| of inventing an answer. |
| |
| Usage: |
| python classify_face_shape.py --forehead 14.2 --cheekbones 15.0 \ |
| --jawline 13.6 --length 19.1 [--tol 0.03] [--json] |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
|
|
| WIDTHS = ("forehead", "cheekbones", "jawline") |
|
|
| MANUAL_CHECKS = ( |
| "Manual check (a tape cannot see this): " |
| "round vs square needs the jaw angle (soft curve vs strong angle); " |
| "heart vs diamond partly needs chin shape (pointed vs tapered)." |
| ) |
|
|
|
|
| def make_rules(tol: float): |
| """Rule table: shape -> list of (condition_fn, plain-English condition). |
| |
| The comparisons mirror the rules published in the guide at |
| https://faceshapechart.com/ — stated there in relative terms only. |
| """ |
|
|
| def width(m): |
| return max(m[k] for k in WIDTHS) |
|
|
| def roughly(a, b, factor=1.0): |
| return abs(a - b) <= tol * factor * max(a, b) |
|
|
| def widest_is(key, strict=False): |
| def check(m): |
| w = width(m) |
| if m[key] < w * (1 - tol): |
| return False |
| if strict: |
| return all(m[key] > m[o] * (1 - tol) for o in WIDTHS if o != key) |
| return True |
| return check |
|
|
| return { |
| "oval": [ |
| (widest_is("cheekbones"), "cheekbones widest"), |
| (lambda m: m["length"] > width(m) * (1 + tol * 0.5), "face longer than wide"), |
| (lambda m: m["jawline"] < m["cheekbones"] * (1 - tol * 0.5), "jaw narrower than cheekbones"), |
| ], |
| "round": [ |
| (lambda m: roughly(m["length"], width(m), 1.2), "length roughly equal to width"), |
| (lambda m: roughly(m["forehead"], m["jawline"], 1.5), "forehead roughly equal to jawline"), |
| ], |
| "square": [ |
| (lambda m: roughly(m["forehead"], m["cheekbones"], 1.5) and roughly(m["cheekbones"], m["jawline"], 1.5), "forehead, cheekbones, jawline roughly equal"), |
| (lambda m: roughly(m["length"], width(m), 1.2), "length roughly equal to width"), |
| ], |
| "heart": [ |
| (widest_is("forehead", strict=True), "forehead clearly widest"), |
| (lambda m: m["jawline"] < m["forehead"] * (1 - tol * 0.5), "jaw narrower than forehead"), |
| ], |
| "diamond": [ |
| (widest_is("cheekbones", strict=True), "cheekbones clearly widest"), |
| (lambda m: m["forehead"] < m["cheekbones"] * (1 - tol * 0.5), "forehead narrower than cheekbones"), |
| (lambda m: m["jawline"] < m["cheekbones"] * (1 - tol * 0.5), "jaw narrower than cheekbones"), |
| ], |
| "oblong": [ |
| (lambda m: m["length"] > width(m) * (1 + 4 * tol), "length clearly greater than width"), |
| (lambda m: roughly(m["forehead"], m["cheekbones"], 1.5) and roughly(m["cheekbones"], m["jawline"], 1.5), "forehead, cheekbones, jawline roughly equal"), |
| ], |
| "triangle (pear)": [ |
| (widest_is("jawline", strict=True), "jawline clearly widest"), |
| (lambda m: m["jawline"] > m["cheekbones"] * (1 + tol * 0.5), "jaw wider than cheekbones"), |
| ], |
| "hourglass": [ |
| (lambda m: m["cheekbones"] >= m["forehead"] * (1 - tol) and m["jawline"] > m["forehead"] * (1 - tol) and m["jawline"] >= width(m) * (1 - 2 * tol), "cheekbones AND jawline both prominent"), |
| (lambda m: roughly(m["length"], width(m) * 1.1, 2.0), "length balanced against width"), |
| ], |
| } |
|
|
|
|
| def classify(m: dict, tol: float): |
| rules = make_rules(tol) |
| results = {} |
| for shape, conds in rules.items(): |
| matched = [text for fn, text in conds if fn(m)] |
| failed = [text for fn, text in conds if not fn(m)] |
| results[shape] = {"score": len(matched), "total": len(conds), "matched": matched, "failed": failed} |
| return results |
|
|
|
|
| def main() -> int: |
| p = argparse.ArgumentParser(description="Rank face-shape candidates from four measurements.") |
| p.add_argument("--forehead", type=float, required=True, help="widest width across the forehead") |
| p.add_argument("--cheekbones", type=float, required=True, help="widest width across the cheekbones") |
| p.add_argument("--jawline", type=float, required=True, help="width across the jawline") |
| p.add_argument("--length", type=float, required=True, help="hairline-to-chin length") |
| p.add_argument("--tol", type=float, default=0.03, help="tie band for 'roughly equal' as a fraction (default 0.03 = 3%%); this tool's own parameter, not a published figure") |
| p.add_argument("--json", action="store_true", help="print raw JSON") |
| a = p.parse_args() |
|
|
| if min(a.forehead, a.cheekbones, a.jawline, a.length) <= 0: |
| p.error("all four measurements must be positive numbers (any consistent unit)") |
|
|
| m = {"forehead": a.forehead, "cheekbones": a.cheekbones, "jawline": a.jawline, "length": a.length} |
| results = classify(m, a.tol) |
|
|
| if a.json: |
| print(json.dumps({"measurements": m, "tol": a.tol, "results": results}, indent=2)) |
| return 0 |
|
|
| ranked = sorted(results.items(), key=lambda kv: (-kv[1]["score"], kv[0])) |
| best = ranked[0][1]["score"] |
| top = [s for s, r in ranked if r["score"] == best] |
|
|
| print("Measurements: forehead=%.4g cheekbones=%.4g jawline=%.4g length=%.4g (tol=%.0f%%)" |
| % (a.forehead, a.cheekbones, a.jawline, a.length, a.tol * 100)) |
| print() |
| print("Top candidate(s): %s" % ", ".join(top)) |
| print() |
| for shape, r in ranked: |
| tag = "OK " if not r["failed"] else " " |
| print(" %s[%s] %d/%d matched" % (tag, shape.ljust(16), r["score"], r["total"])) |
| for t in r["matched"]: |
| print(" + %s" % t) |
| for t in r["failed"]: |
| print(" - %s" % t) |
| print() |
| print(MANUAL_CHECKS) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
