Add face shape measurement sheet, dataset card and four-measurement CLI

README.md

@@ -0,0 +1,60 @@
+---
+license: cc0-1.0
+language:
+- en
+pretty_name: Face Shape Measurement Reference (8 Shapes)
+task_categories:
+- tabular-classification
+tags:
+- face-shape
+- beauty
+- measurements
+- reference-table
+size_categories:
+- n<1K
+---
+
+# Face Shape Measurement Reference (8 Shapes)
+
+A compact, reusable reference for identifying face shape from four tape measurements:
+**forehead width, cheekbone width, jawline width, and face length**.
+
+## Files
+
+| File | What it is |
+| --- | --- |
+| `face_shape_measurement_sheet.csv` | One row per shape — oval, round, square, heart, diamond, oblong, triangle/pear, hourglass. The four columns state where each measurement sits *relative to the other three*; `fastest_check` gives the single quickest screening rule for that shape. |
+| `classify_face_shape.py` | Zero-dependency Python CLI: give it your four numbers, it returns the shapes whose rules actually match, ranked, with every matched and failed condition listed. Usage: `python classify_face_shape.py --forehead 14.2 --cheekbones 15.0 --jawline 13.6 --length 19.1` |
+
+## How the rules are expressed — and why
+
+The sheet is deliberately **relative, not absolute**. Published face-shape guides describe
+shapes with language like "slightly narrower than the cheekbones" or "cheekbones clearly the
+widest part". This sheet preserves that structure instead of inventing millimetre cutoffs that
+no source supports. The tool's tie band for "roughly equal" is its own adjustable parameter
+(`--tol`, default 3%) — not a figure taken from any study.
+
+## Limits, stated plainly
+
+Two judgments cannot come from a tape measure: the **jaw angle** (which separates round from
+square) and **chin shape** (which separates heart from diamond). When the four numbers cannot
+separate two candidates, the tool reports both and flags the manual check rather than guessing.
+
+## Relationship to image datasets
+
+This is a **rule/measurement reference, not an image dataset**. It is intended to complement
+the image-based face-shape datasets on Kaggle and Hugging Face: those train classifiers to
+output a shape label, while this sheet documents the relative-width rules that define the
+labels themselves.
+
+## Source and full guide
+
+The worked guide — how to set up an honest reading, how to resolve cases where published
+guides disagree, and the dated research milestones behind the four-measurement method — is
+maintained at **https://faceshapechart.com/**
+
+Code is also mirrored at https://github.com/heroin546-afk/face-shape-measurements
+
+## License
+
+Data sheet: **CC0-1.0** (public domain, no attribution required). Script: MIT.

classify_face_shape.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""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):        # clearly below the widest
+                return False
+            if strict:                          # must beat the others outright
+                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())

face_shape_measurement_sheet.csv

@@ -0,0 +1,9 @@
+"face_shape","forehead","cheekbones","jawline","face_length","fastest_check"
+"oval","slightly narrower than cheekbones","widest, gently rounded","softly curved, narrower than cheekbones","longer than width","length greater than width; cheekbones widest; soft jaw"
+"round","about equal to jawline","full cheeks; width roughly equals length","soft, no strong angle","roughly equal to width","length equals width; no angles"
+"square","broad; roughly equal to cheekbones and jawline","roughly equal to forehead and jawline","strong and angular","roughly equal to width","forehead, cheekbones and jawline equal; angular jaw"
+"heart","widest point (broad forehead)","taper toward the chin","narrow; chin narrow and pointed","longer than lower-face width","widest at forehead; narrow chin"
+"diamond","narrower than cheekbones","clearly the widest point","narrow; chin pointed","longer than width","cheekbones dominant; narrow forehead and chin"
+"oblong","roughly equal to cheekbones and jawline","straight cheek line","similar width to forehead","noticeably longer than width","length clearly greater than width; straight sides"
+"triangle (pear)","narrowest feature","narrower than jawline","widest and broad","varies","jaw is the widest point"
+"hourglass (rare)","narrower than cheekbones","prominent and wide","wide and angular","balanced","cheekbones AND jawline both prominent"