ทำไมตาถึงอ่านกราฟนี้ได้เร็วกว่า

"""สร้างกองตัวเลขสำหรับการทดลอง 'หาเลข 3' — seed คงที่ ผลลัพธ์เหมือนกันทุกครั้ง"""
import random

ROWS, COLS, TARGET, N_TARGET = 8, 20, 3, 6
random.seed(1984)  # ปีที่ Cleveland กับ McGill ตีพิมพ์งานที่เราจะเจอในบทที่ 5

others = [d for d in range(10) if d != TARGET]
grid = [[random.choice(others) for _ in range(COLS)] for _ in range(ROWS)]

spots = random.sample([(r, c) for r in range(ROWS) for c in range(COLS)], N_TARGET)
for r, c in spots:
    grid[r][c] = TARGET

print(f"ตาราง {ROWS}x{COLS} = {ROWS * COLS} ตัว · ซ่อนเลข {TARGET} ไว้ {N_TARGET} ตัว")
print("ตำแหน่งเป้าหมาย (แถว,คอลัมน์ เริ่มที่ 0):", sorted(spots))
print()
for row in grid:
    print(" ".join(str(d) for d in row))

ตาราง 8x20 = 160 ตัว · ซ่อนเลข 3 ไว้ 6 ตัว
ตำแหน่งเป้าหมาย (แถว,คอลัมน์ เริ่มที่ 0): [(0, 19), (1, 17), (2, 14), (3, 1), (4, 8), (6, 9)]

6 8 6 5 4 7 1 4 5 0 2 1 9 7 6 4 2 7 2 3
6 9 9 5 5 8 7 6 8 4 9 6 9 9 2 9 9 3 6 1
7 1 7 2 2 0 8 6 4 9 9 7 5 0 3 2 5 7 1 8
4 3 1 8 5 4 1 4 0 6 4 4 0 8 7 2 8 4 1 0
7 5 9 1 1 0 5 4 3 6 7 0 4 2 4 7 5 4 0 6
0 0 2 5 4 7 1 1 6 6 1 5 5 0 6 9 5 5 6 7
2 7 2 7 8 7 1 2 5 3 1 2 7 0 6 0 1 1 1 9
0 9 5 4 1 7 6 6 5 5 8 6 6 8 9 5 4 9 4 1

"""คำนวณเรขาคณิตของกราฟชุดเดียวกันที่เข้ารหัสหลายแบบ — Python มาตรฐานล้วน"""
import math

# ชุดข้อมูลสมมติ: สัดส่วนการใช้จ่ายของ 5 หน่วยงาน (รวม 100)
DATA = [("ก", 22), ("ข", 18), ("ค", 25), ("ง", 16), ("จ", 19)]
vals = [v for _, v in DATA]
total = sum(vals)

order = sorted(DATA, key=lambda kv: -kv[1])
gap_val = min(order[i][1] - order[i + 1][1] for i in range(len(order) - 1))

# --- 1. ความยาว (แท่ง) : ค่า -> พิกเซล เชิงเส้น ---
BAR_MAX_PX = 110
print("=== เข้ารหัสด้วยความยาว (แท่ง) ===")
for k, v in DATA:
    print(f"  {k}: {v:>3} -> ยาว {v / max(vals) * BAR_MAX_PX:7.2f} px")
gap_len = gap_val / max(vals) * BAR_MAX_PX
print(f"  คู่ที่สูสีที่สุด (ต่าง {gap_val} จุด) ห่างกัน {gap_len:.2f} px "
      f"= {gap_len / BAR_MAX_PX * 100:.2f}% ของช่วงที่แท่งใช้ได้")

# --- 2. มุม (วงกลม) : ค่า -> องศา ---
print("\n=== เข้ารหัสด้วยมุม (วงกลม) ===")
start, R = -90.0, 90.0          # เริ่มที่ 12 นาฬิกา
for k, v in DATA:
    sweep = v / total * 360.0
    end = start + sweep
    x1, y1 = R * math.cos(math.radians(start)), R * math.sin(math.radians(start))
    x2, y2 = R * math.cos(math.radians(end)), R * math.sin(math.radians(end))
    print(f"  {k}: {v:>3} -> {sweep:6.2f} องศา | "
          f"M 0 0 L {x1:7.2f} {y1:7.2f} A {R} {R} 0 0 1 {x2:7.2f} {y2:7.2f} Z")
    start = end
gap_deg = gap_val / total * 360.0
print(f"  คู่ที่สูสีที่สุด (ต่าง {gap_val} จุด) ห่างกัน {gap_deg:.2f} องศา "
      f"= {gap_deg / 360 * 100:.2f}% ของช่วงที่วงกลมใช้ได้")

# --- 3. พื้นที่ (ฟอง) : ถูก = รากที่สอง, ผิด = เชิงเส้น ---
print("\n=== เข้ารหัสด้วยพื้นที่ (ฟอง) ===")
R_MAX = 28.0
for k, v in DATA:
    r_ok = math.sqrt(v / max(vals)) * R_MAX      # พื้นที่แปรตามค่า (ถูก)
    r_bad = v / max(vals) * R_MAX                # รัศมีแปรตามค่า (ผิด)
    area_bad = (r_bad / R_MAX) ** 2 * max(vals)  # ค่าที่ตา "อ่านได้" จากรูปที่ผิด
    print(f"  {k}: {v:>3} -> r ถูก {r_ok:5.2f} | r ผิด {r_bad:5.2f} "
          f"-> ตาอ่านได้ {area_bad:5.2f} (คลาดเคลื่อน {area_bad - v:+.2f})")

pct_bar, pct_pie = gap_len / BAR_MAX_PX * 100, gap_deg / 360 * 100
print(f"\n= แท่งขยายความต่างเดียวกันให้ใหญ่ขึ้น {pct_bar / pct_pie:.1f} เท่า")

# --- 4. คู่ที่ต่างกันมาก เพื่อให้เห็นความเพี้ยนของพื้นที่ชัด ๆ ---
print("\n=== คู่เทียบ 25 กับ 100 (ต่างกัน 4 เท่า) ===")
PAIR, R_BIG = [25, 100], 40.0
for v in PAIR:
    r_ok = math.sqrt(v / max(PAIR)) * R_BIG
    r_bad = v / max(PAIR) * R_BIG
    read = (r_bad / R_BIG) ** 2 * max(PAIR)
    print(f"  ค่า {v:>4} -> r ถูก {r_ok:5.2f} | r ผิด {r_bad:5.2f} "
          f"-> ตาอ่านได้ {read:6.2f} (เหลือ {read / v * 100:.0f}% ของค่าจริง)")

=== เข้ารหัสด้วยความยาว (แท่ง) ===
  ก:  22 -> ยาว   96.80 px
  ข:  18 -> ยาว   79.20 px
  ค:  25 -> ยาว  110.00 px
  ง:  16 -> ยาว   70.40 px
  จ:  19 -> ยาว   83.60 px
  คู่ที่สูสีที่สุด (ต่าง 1 จุด) ห่างกัน 4.40 px = 4.00% ของช่วงที่แท่งใช้ได้

=== เข้ารหัสด้วยมุม (วงกลม) ===
  ก:  22 ->  79.20 องศา | M 0 0 L    0.00  -90.00 A 90.0 90.0 0 0 1   88.41  -16.86 Z
  ข:  18 ->  64.80 องศา | M 0 0 L   88.41  -16.86 A 90.0 90.0 0 0 1   52.90   72.81 Z
  ค:  25 ->  90.00 องศา | M 0 0 L   52.90   72.81 A 90.0 90.0 0 0 1  -72.81   52.90 Z
  ง:  16 ->  57.60 องศา | M 0 0 L  -72.81   52.90 A 90.0 90.0 0 0 1  -83.68  -33.13 Z
  จ:  19 ->  68.40 องศา | M 0 0 L  -83.68  -33.13 A 90.0 90.0 0 0 1   -0.00  -90.00 Z
  คู่ที่สูสีที่สุด (ต่าง 1 จุด) ห่างกัน 3.60 องศา = 1.00% ของช่วงที่วงกลมใช้ได้

=== เข้ารหัสด้วยพื้นที่ (ฟอง) ===
  ก:  22 -> r ถูก 26.27 | r ผิด 24.64 -> ตาอ่านได้ 19.36 (คลาดเคลื่อน -2.64)
  ข:  18 -> r ถูก 23.76 | r ผิด 20.16 -> ตาอ่านได้ 12.96 (คลาดเคลื่อน -5.04)
  ค:  25 -> r ถูก 28.00 | r ผิด 28.00 -> ตาอ่านได้ 25.00 (คลาดเคลื่อน +0.00)
  ง:  16 -> r ถูก 22.40 | r ผิด 17.92 -> ตาอ่านได้ 10.24 (คลาดเคลื่อน -5.76)
  จ:  19 -> r ถูก 24.41 | r ผิด 21.28 -> ตาอ่านได้ 14.44 (คลาดเคลื่อน -4.56)

= แท่งขยายความต่างเดียวกันให้ใหญ่ขึ้น 4.0 เท่า

=== คู่เทียบ 25 กับ 100 (ต่างกัน 4 เท่า) ===
  ค่า   25 -> r ถูก 20.00 | r ผิด 10.00 -> ตาอ่านได้   6.25 (เหลือ 25% ของค่าจริง)
  ค่า  100 -> r ถูก 40.00 | r ผิด 40.00 -> ตาอ่านได้ 100.00 (เหลือ 100% ของค่าจริง)

"""ตรวจชุดข้อมูลของคุณเองกับทุกช่องทาง — วัดเฉพาะเรขาคณิต ไม่ได้วัดสายตาคน"""

DATA = [("ก", 22), ("ข", 18), ("ค", 25), ("ง", 16), ("จ", 19)]
K = 0.05  # เกณฑ์: ความต่างต้องกินอย่างน้อยกี่ส่วนของช่วง ถึงจะหวังให้ตาแยกออก

def share_of_range(gap, vals, channel):
    """ความต่าง gap หน่วย ได้ส่วนแบ่งเท่าไหร่ของช่วงที่ช่องทางนั้นมีให้ใช้"""
    hi, total = max(vals), sum(vals)
    if channel in ("ตำแหน่งบนแกนร่วม", "ความยาว"):
        return gap / hi                       # ทั้งคู่ยืดตามค่าเชิงเส้นเหมือนกัน
    if channel == "มุม":
        return gap / total                    # วงกลมต้องหารด้วยผลรวม ไม่ใช่ค่าสูงสุด
    if channel == "พื้นที่":
        lo = hi - gap
        return (hi ** 0.5 - lo ** 0.5) / hi ** 0.5   # ตาอ่านพื้นที่ จึงคิดที่รากที่สอง
    raise ValueError(channel)

vals = [v for _, v in DATA]
ranked = sorted(DATA, key=lambda kv: -kv[1])
gaps = [(ranked[i][0], ranked[i + 1][0], ranked[i][1] - ranked[i + 1][1])
        for i in range(len(ranked) - 1)]

print("ช่องว่างระหว่างอันดับที่ติดกัน")
for a, b, g in gaps:
    print(f"  {a} - {b} = {g}")
gap = min(g for _, _, g in gaps)
print(f"\nช่องว่างที่แคบที่สุด = {gap} หน่วย")
print("ถ้าช่องทางไหนทำช่องว่างนี้ให้เห็นไม่ได้ กราฟนั้นก็บอกลำดับไม่ครบ\n")

print(f"{'ช่องทาง':<20}{'ส่วนแบ่งของช่วง':>18}   {'ผล (เกณฑ์ ' + str(int(K * 100)) + '%)'}")
for ch in ("ตำแหน่งบนแกนร่วม", "ความยาว", "มุม", "พื้นที่"):
    share = share_of_range(gap, vals, ch)
    print(f"{ch:<20}{share * 100:>15.2f}%   {'ผ่าน' if share >= K else 'ไม่ผ่าน'}")

print("\nสองข้อที่ตารางนี้บอกไม่ได้:")
print("1. ตำแหน่งกับความยาวได้เท่ากันเป๊ะ เพราะเรขาคณิตแยกสองอย่างนี้ไม่ออก")
print("   ที่แยกออกคือการวัดกับคนจริง ซึ่งเป็นคนละเครื่องมือ")
print("2. เกณฑ์ K ไม่ใช่ค่าคงที่ของธรรมชาติ มันขึ้นกับงานและขนาดของภาพ")

ช่องว่างระหว่างอันดับที่ติดกัน
  ค - ก = 3
  ก - จ = 3
  จ - ข = 1
  ข - ง = 2

ช่องว่างที่แคบที่สุด = 1 หน่วย
ถ้าช่องทางไหนทำช่องว่างนี้ให้เห็นไม่ได้ กราฟนั้นก็บอกลำดับไม่ครบ

ช่องทาง                ส่วนแบ่งของช่วง   ผล (เกณฑ์ 5%)
ตำแหน่งบนแกนร่วม               4.00%   ไม่ผ่าน
ความยาว                        4.00%   ไม่ผ่าน
มุม                            1.00%   ไม่ผ่าน
พื้นที่                        2.02%   ไม่ผ่าน

สองข้อที่ตารางนี้บอกไม่ได้:
1. ตำแหน่งกับความยาวได้เท่ากันเป๊ะ เพราะเรขาคณิตแยกสองอย่างนี้ไม่ออก
   ที่แยกออกคือการวัดกับคนจริง ซึ่งเป็นคนละเครื่องมือ
2. เกณฑ์ K ไม่ใช่ค่าคงที่ของธรรมชาติ มันขึ้นกับงานและขนาดของภาพ

"""กฎของเวเบอร์ — ตาอ่าน 'กี่เท่า' ไม่ใช่ 'ต่างกันเท่าไหร่'"""

K = 0.05  # ความต่างต้องเป็นอย่างน้อย 5% ของค่าฐาน ถึงจะหวังให้ตาแยกออก

def detectable(a, b, k=K):
    """ต่างกันพอให้ตาแยกออกไหม — เทียบเป็นสัดส่วนของค่าที่ใหญ่กว่า"""
    return abs(a - b) / max(a, b) >= k

print("=== ความต่างเท่ากันเป๊ะ 5 หน่วย ที่ระดับค่าต่างกัน ===")
for base in (10, 50, 100, 500, 1000):
    a, b = base, base + 5
    ratio = 5 / b
    print(f"  {a:>5} กับ {b:>5} -> ต่างกัน {ratio * 100:5.2f}% "
          f"-> {'แยกออก' if detectable(a, b) else 'แยกไม่ออก'}")

print("\n=== อัตราส่วนเท่ากัน ที่ระดับค่าต่างกัน ===")
for base in (10, 100, 1000):
    b = base * 1.10
    print(f"  {base:>5} กับ {b:>7.1f} -> ต่างกัน 10.00% "
          f"-> {'แยกออก' if detectable(base, b) else 'แยกไม่ออก'}")
print("  ระดับค่าเปลี่ยนไป 100 เท่า แต่ผลเหมือนกันหมด นั่นคือสิ่งที่กฎนี้พูด")

print("\n=== ตัดฐานแกนออก แล้วอัตราส่วนที่ตาเห็นเปลี่ยนไปแค่ไหน ===")
A, B = 102, 100
for floor in (0, 90, 98, 99):
    ha, hb = A - floor, B - floor
    ratio = (ha - hb) / ha
    print(f"  แกนเริ่มที่ {floor:>3} -> แท่งสูง {ha:>4} กับ {hb:>4} "
          f"-> ตาเห็นต่างกัน {ratio * 100:6.2f}% "
          f"-> {'แยกออก' if ratio >= K else 'แยกไม่ออก'}")
print(f"  ข้อมูลไม่ขยับเลย {A} กับ {B} ต่างกัน 2 หน่วยตลอด")
print("  สิ่งที่ขยับคือค่าฐานที่ตาเอาไปหาร ซึ่งคนทำกราฟเป็นคนเลือก")

# --- ความสูงแท่งที่ใช้วาดสองภาพในบทนี้ เผื่ออยากตรวจว่าภาพตรงกับเลข ---
H = 120.0
print("\n=== ความสูงแท่งของ FIG 6.1 ===")
for pair in ((10, 15), (1000, 1005)):
    hi = max(pair)
    hs = [round(v / hi * H, 2) for v in pair]
    print(f"  {pair} -> สูง {hs} px -> ห่างกัน {round(hs[1] - hs[0], 2)} px")

print("\n=== ความสูงแท่งของ FIG 6.2 ===")
for floor in (0, 98):
    ha, hb = A - floor, B - floor
    low = round(hb / ha * H, 2)
    print(f"  ฐานแกน {floor:>3} -> สูง {low} กับ {H} px -> ห่างกัน {round(H - low, 2)} px")

=== ความต่างเท่ากันเป๊ะ 5 หน่วย ที่ระดับค่าต่างกัน ===
     10 กับ    15 -> ต่างกัน 33.33% -> แยกออก
     50 กับ    55 -> ต่างกัน  9.09% -> แยกออก
    100 กับ   105 -> ต่างกัน  4.76% -> แยกไม่ออก
    500 กับ   505 -> ต่างกัน  0.99% -> แยกไม่ออก
   1000 กับ  1005 -> ต่างกัน  0.50% -> แยกไม่ออก

=== อัตราส่วนเท่ากัน ที่ระดับค่าต่างกัน ===
     10 กับ    11.0 -> ต่างกัน 10.00% -> แยกออก
    100 กับ   110.0 -> ต่างกัน 10.00% -> แยกออก
   1000 กับ  1100.0 -> ต่างกัน 10.00% -> แยกออก
  ระดับค่าเปลี่ยนไป 100 เท่า แต่ผลเหมือนกันหมด นั่นคือสิ่งที่กฎนี้พูด

=== ตัดฐานแกนออก แล้วอัตราส่วนที่ตาเห็นเปลี่ยนไปแค่ไหน ===
  แกนเริ่มที่   0 -> แท่งสูง  102 กับ  100 -> ตาเห็นต่างกัน   1.96% -> แยกไม่ออก
  แกนเริ่มที่  90 -> แท่งสูง   12 กับ   10 -> ตาเห็นต่างกัน  16.67% -> แยกออก
  แกนเริ่มที่  98 -> แท่งสูง    4 กับ    2 -> ตาเห็นต่างกัน  50.00% -> แยกออก
  แกนเริ่มที่  99 -> แท่งสูง    3 กับ    1 -> ตาเห็นต่างกัน  66.67% -> แยกออก
  ข้อมูลไม่ขยับเลย 102 กับ 100 ต่างกัน 2 หน่วยตลอด
  สิ่งที่ขยับคือค่าฐานที่ตาเอาไปหาร ซึ่งคนทำกราฟเป็นคนเลือก

=== ความสูงแท่งของ FIG 6.1 ===
  (10, 15) -> สูง [80.0, 120.0] px -> ห่างกัน 40.0 px
  (1000, 1005) -> สูง [119.4, 120.0] px -> ห่างกัน 0.6 px

=== ความสูงแท่งของ FIG 6.2 ===
  ฐานแกน   0 -> สูง 117.65 กับ 120.0 px -> ห่างกัน 2.35 px
  ฐานแกน  98 -> สูง 60.0 กับ 120.0 px -> ห่างกัน 60.0 px

"""นับหมึกในกราฟ — ชิ้นไหนแบกข้อมูล ชิ้นไหนแค่มาอยู่เฉย ๆ"""

# นับจากภาพ FIG 7.1 ในบทนี้ ทีละชิ้นตามที่ตาเห็น
BEFORE = [
    ("แท่ง 5 อัน", 5, True),
    ("เส้นตารางแนวนอน", 6, False),
    ("กรอบรอบกราฟ 4 ด้าน", 4, False),
    ("เงาใต้แท่ง 5 อัน", 5, False),
    ("คำอธิบายสัญลักษณ์", 5, False),
    ("แกนตั้งพร้อมขีด 6 ขีด", 7, False),
    ("แกนนอน", 1, False),
]
AFTER = [
    ("แท่ง 5 อัน", 5, True),
    ("ตัวเลขบนแท่ง", 5, True),
    ("ป้ายชื่อใต้แท่ง", 5, True),
    ("เส้นฐานเส้นเดียว", 1, False),
]

def report(name, items):
    data = sum(n for _, n, is_data in items if is_data)
    total = sum(n for _, n, _ in items)
    print(f"=== {name} ===")
    for label, n, is_data in items:
        tag = "แบกข้อมูล" if is_data else "ไม่แบกข้อมูล"
        print(f"  {tag:<13}{label:<26} {n:>3}")
    print(f"  รวม {total} ชิ้น · แบกข้อมูล {data} ชิ้น "
          f"· สัดส่วนหมึกที่เป็นข้อมูล {data / total * 100:.1f}%\n")
    return data, total

d1, t1 = report("ก่อนแก้", BEFORE)
d2, t2 = report("หลังแก้", AFTER)

print(f"ชิ้นที่ตาต้องประมวลผลลดจาก {t1} เหลือ {t2} ({(1 - t2 / t1) * 100:.0f}% หายไป)")
print(f"แต่ข้อมูลที่สื่อได้เพิ่มจาก {d1} เป็น {d2} ชิ้น")
print("นี่คือจุดที่คำว่า 'เรียบง่ายกว่า' ไม่ได้แปลว่า 'บอกน้อยกว่า'")

=== ก่อนแก้ ===
  แบกข้อมูล    แท่ง 5 อัน                   5
  ไม่แบกข้อมูล เส้นตารางแนวนอน              6
  ไม่แบกข้อมูล กรอบรอบกราฟ 4 ด้าน           4
  ไม่แบกข้อมูล เงาใต้แท่ง 5 อัน             5
  ไม่แบกข้อมูล คำอธิบายสัญลักษณ์            5
  ไม่แบกข้อมูล แกนตั้งพร้อมขีด 6 ขีด        7
  ไม่แบกข้อมูล แกนนอน                       1
  รวม 33 ชิ้น · แบกข้อมูล 5 ชิ้น · สัดส่วนหมึกที่เป็นข้อมูล 15.2%

=== หลังแก้ ===
  แบกข้อมูล    แท่ง 5 อัน                   5
  แบกข้อมูล    ตัวเลขบนแท่ง                 5
  แบกข้อมูล    ป้ายชื่อใต้แท่ง              5
  ไม่แบกข้อมูล เส้นฐานเส้นเดียว             1
  รวม 16 ชิ้น · แบกข้อมูล 15 ชิ้น · สัดส่วนหมึกที่เป็นข้อมูล 93.8%

ชิ้นที่ตาต้องประมวลผลลดจาก 33 เหลือ 16 (52% หายไป)
แต่ข้อมูลที่สื่อได้เพิ่มจาก 5 เป็น 15 ชิ้น
นี่คือจุดที่คำว่า 'เรียบง่ายกว่า' ไม่ได้แปลว่า 'บอกน้อยกว่า'

"""สร้างชุดสีสองแบบแล้ววัดความสว่างของแต่ละขั้น — Python มาตรฐานล้วน"""
import colorsys

N = 7

def to_hex(r, g, b):
    return "#%02x%02x%02x" % (round(r * 255), round(g * 255), round(b * 255))

def luminance(r, g, b):
    """ความสว่างสัมพัทธ์ตามสูตร WCAG — ถ่วงน้ำหนักตามความไวของตาต่อแต่ละช่องสี"""
    def lin(c):
        return c / 12.92 if c <= 0.03928 else ((c + 0.055) / 1.055) ** 2.4
    return 0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b)

# แบบที่หนึ่ง: กวาดสีรุ้ง จากน้ำเงินไปแดง ความสว่างปล่อยตามยถากรรม
rainbow = [colorsys.hls_to_rgb(h, 0.5, 0.95)
           for h in [(240 - 240 * i / (N - 1)) / 360 for i in range(N)]]

# แบบที่สอง: สีเดียว ไล่ความสว่างอย่างเดียว
seq = [colorsys.hls_to_rgb(20 / 360, 0.92 - 0.72 * i / (N - 1), 0.55) for i in range(N)]

for name, ramp in (("สีรุ้ง", rainbow), ("ไล่เฉดสีเดียว", seq)):
    print(f"=== {name} ===")
    lums = []
    for i, (r, g, b) in enumerate(ramp):
        L = luminance(r, g, b)
        lums.append(L)
        print(f"  ขั้น {i + 1}: {to_hex(r, g, b)}  ความสว่าง {L:.3f}")
    steps = [round(lums[i + 1] - lums[i], 3) for i in range(len(lums) - 1)]
    print(f"  ผลต่างความสว่างทีละขั้น: {steps}")
    mono = all(s < 0 for s in steps) or all(s > 0 for s in steps)
    print(f"  ไล่ทางเดียวตลอดไหม: {'ใช่' if mono else 'ไม่ใช่'}")
    flips = sum(1 for i in range(len(steps) - 1) if steps[i] * steps[i + 1] < 0)
    print(f"  จำนวนครั้งที่กลับทิศ: {flips}\n")

=== สีรุ้ง ===
  ขั้น 1: #0606f9  ความสว่าง 0.070
  ขั้น 2: #06a8f9  ความสว่าง 0.348
  ขั้น 3: #06f9a8  ความสว่าง 0.704
  ขั้น 4: #06f906  ความสว่าง 0.676
  ขั้น 5: #a8f906  ความสว่าง 0.758
  ขั้น 6: #f9a806  ความสว่าง 0.480
  ขั้น 7: #f90606  ความสว่าง 0.202
  ผลต่างความสว่างทีละขั้น: [0.278, 0.356, -0.028, 0.083, -0.278, -0.278]
  ไล่ทางเดียวตลอดไหม: ไม่ใช่
  จำนวนครั้งที่กลับทิศ: 3

=== ไล่เฉดสีเดียว ===
  ขั้น 1: #f6e7df  ความสว่าง 0.820
  ขั้น 2: #e8c3b0  ความสว่าง 0.592
  ขั้น 3: #da9e81  ความสว่าง 0.411
  ขั้น 4: #cd7a51  ความสว่าง 0.275
  ขั้น 5: #ae5c32  ความสว่าง 0.168
  ขั้น 6: #7e4325  ความสว่าง 0.086
  ขั้น 7: #4f2a17  ความสว่าง 0.034
  ผลต่างความสว่างทีละขั้น: [-0.228, -0.18, -0.136, -0.107, -0.082, -0.052]
  ไล่ทางเดียวตลอดไหม: ใช่
  จำนวนครั้งที่กลับทิศ: 0

"""ตัวคูณคำโกหก — ขนาดของผลที่ภาพแสดง หารด้วยขนาดของผลที่มีจริงในข้อมูล"""

def lie_factor(a, b, floor):
    """a, b = ค่าจริงสองค่า · floor = จุดที่แกนเริ่มนับ"""
    real = abs(a - b) / min(a, b)                    # ผลจริง คิดเป็นสัดส่วน
    ha, hb = a - floor, b - floor
    shown = abs(ha - hb) / min(ha, hb)               # ผลที่ตาเห็นจากความยาวแท่ง
    return real, shown, shown / real

print(f"{'ฐานแกน':>8}{'ผลจริง':>12}{'ผลที่ภาพแสดง':>16}{'ตัวคูณคำโกหก':>16}   คำตัดสิน")
for floor in (0, 90, 95, 98, 99):
    real, shown, lf = lie_factor(102, 100, floor)
    verdict = "ซื่อสัตย์" if 0.95 <= lf <= 1.05 else f"เกินจริง {lf:.0f} เท่า"
    print(f"{floor:>8}{real * 100:>11.2f}%{shown * 100:>15.2f}%{lf:>16.2f}   {verdict}")

print("\nTufte เสนอว่าตัวคูณควรอยู่ราว 1 — ห่างจาก 1 มากเท่าไหร่ ภาพก็โกหกมากเท่านั้น")
print("แต่ 'โกหก' ที่นี่หมายถึงสัดส่วนบิดเบี้ยว ไม่ได้แปลว่าคนทำตั้งใจหลอก")

# --- ความสูงแท่งที่ใช้วาด FIG 9.1 ในบทนี้ ---
H = 110.0
print("\n=== ความสูงแท่งของ FIG 9.1 ===")
for floor in (0, 95, 99):
    ha, hb = 102 - floor, 100 - floor
    low = round(hb / ha * H, 2)
    _, _, lf = lie_factor(102, 100, floor)
    print(f"  ฐานแกน {floor:>3} -> สูง {low:>6} กับ {H} px -> ตัวคูณ {lf:.2f}")

  ฐานแกน      ผลจริง    ผลที่ภาพแสดง    ตัวคูณคำโกหก   คำตัดสิน
       0       2.00%           2.00%            1.00   ซื่อสัตย์
      90       2.00%          20.00%           10.00   เกินจริง 10 เท่า
      95       2.00%          40.00%           20.00   เกินจริง 20 เท่า
      98       2.00%         100.00%           50.00   เกินจริง 50 เท่า
      99       2.00%         200.00%          100.00   เกินจริง 100 เท่า

Tufte เสนอว่าตัวคูณควรอยู่ราว 1 — ห่างจาก 1 มากเท่าไหร่ ภาพก็โกหกมากเท่านั้น
แต่ 'โกหก' ที่นี่หมายถึงสัดส่วนบิดเบี้ยว ไม่ได้แปลว่าคนทำตั้งใจหลอก

=== ความสูงแท่งของ FIG 9.1 ===
  ฐานแกน   0 -> สูง 107.84 กับ 110.0 px -> ตัวคูณ 1.00
  ฐานแกน  95 -> สูง  78.57 กับ 110.0 px -> ตัวคูณ 20.00
  ฐานแกน  99 -> สูง  36.67 กับ 110.0 px -> ตัวคูณ 100.00

"""ชุด Anscombe — ค่าสรุปเท่ากันเกือบทุกตัว แต่ภาพคนละเรื่อง"""
X123 = [10, 8, 13, 9, 11, 14, 6, 4, 12, 7, 5]
SETS = {
    "I":   (X123, [8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68]),
    "II":  (X123, [9.14, 8.14, 8.74, 8.77, 9.26, 8.10, 6.13, 3.10, 9.13, 7.26, 4.74]),
    "III": (X123, [7.46, 6.77, 12.74, 7.11, 7.81, 8.84, 6.08, 5.39, 8.15, 6.42, 5.73]),
    "IV":  ([8, 8, 8, 8, 8, 8, 8, 19, 8, 8, 8],
            [6.58, 5.76, 7.71, 8.84, 8.47, 7.04, 5.25, 12.50, 5.56, 7.91, 6.89]),
}

def mean(v):
    return sum(v) / len(v)

def var(v):                                  # ความแปรปรวนแบบกลุ่มตัวอย่าง (หารด้วย n-1)
    m = mean(v)
    return sum((x - m) ** 2 for x in v) / (len(v) - 1)

def corr(x, y):
    mx, my = mean(x), mean(y)
    sxy = sum((a - mx) * (b - my) for a, b in zip(x, y))
    sxx = sum((a - mx) ** 2 for a in x)
    syy = sum((b - my) ** 2 for b in y)
    return sxy / (sxx * syy) ** 0.5

def fit(x, y):                               # เส้นถดถอยด้วยวิธีกำลังสองน้อยสุด
    mx, my = mean(x), mean(y)
    slope = sum((a - mx) * (b - my) for a, b in zip(x, y)) / sum((a - mx) ** 2 for a in x)
    return my - slope * mx, slope

print(f"{'ชุด':<5}{'x เฉลี่ย':>9}{'y เฉลี่ย':>10}{'var x':>8}{'var y':>8}"
      f"{'สหสัมพันธ์':>12}   เส้นถดถอย")
for name, (x, y) in SETS.items():
    b0, b1 = fit(x, y)
    print(f"{name:<5}{mean(x):>9.2f}{mean(y):>10.2f}{var(x):>8.2f}{var(y):>8.2f}"
          f"{corr(x, y):>12.3f}   y = {b0:.2f} + {b1:.2f}x")

print(f"\nค่าสรุปตรงกันถึงทศนิยมตำแหน่งที่สอง (คลาดกันในหลักสุดท้ายบ้าง) แต่ลองวาดดูสิ")

# --- พิกัดที่ใช้วาด FIG 10.1: x 4-19 -> 0-190 px, y 3-13 -> 150-0 px ---
print("\n=== พิกัดจุดของ FIG 10.1 (px) ===")
for name, (x, y) in SETS.items():
    pts = [(round((a - 4) / 15 * 190, 1), round(150 - (b - 3) / 10 * 150, 1))
           for a, b in zip(x, y)]
    print(f"  {name}: {pts}")

b0, b1 = fit(*SETS["I"])
print(f"\nเส้นถดถอยร่วม y = {b0:.2f} + {b1:.2f}x")
for xv in (4, 19):
    yv = b0 + b1 * xv
    print(f"  x={xv} -> px ({round((xv - 4) / 15 * 190, 1)}, "
          f"{round(150 - (yv - 3) / 10 * 150, 1)})")

ชุด   x เฉลี่ย  y เฉลี่ย   var x   var y  สหสัมพันธ์   เส้นถดถอย
I         9.00      7.50   11.00    4.13       0.816   y = 3.00 + 0.50x
II        9.00      7.50   11.00    4.13       0.816   y = 3.00 + 0.50x
III       9.00      7.50   11.00    4.12       0.816   y = 3.00 + 0.50x
IV        9.00      7.50   11.00    4.12       0.817   y = 3.00 + 0.50x

ค่าสรุปตรงกันถึงทศนิยมตำแหน่งที่สอง (คลาดกันในหลักสุดท้ายบ้าง) แต่ลองวาดดูสิ

=== พิกัดจุดของ FIG 10.1 (px) ===
  I: [(76.0, 74.4), (50.7, 90.8), (114.0, 81.3), (63.3, 62.8), (88.7, 70.0), (126.7, 45.6), (25.3, 86.4), (0.0, 131.1), (101.3, 32.4), (38.0, 122.7), (12.7, 109.8)]
  II: [(76.0, 57.9), (50.7, 72.9), (114.0, 63.9), (63.3, 63.5), (88.7, 56.1), (126.7, 73.5), (25.3, 103.0), (0.0, 148.5), (101.3, 58.0), (38.0, 86.1), (12.7, 123.9)]
  III: [(76.0, 83.1), (50.7, 93.5), (114.0, 3.9), (63.3, 88.3), (88.7, 77.9), (126.7, 62.4), (25.3, 103.8), (0.0, 114.2), (101.3, 72.8), (38.0, 98.7), (12.7, 109.0)]
  IV: [(50.7, 96.3), (50.7, 108.6), (50.7, 79.4), (50.7, 62.4), (50.7, 67.9), (50.7, 89.4), (50.7, 116.2), (190.0, 7.5), (50.7, 111.6), (50.7, 76.3), (50.7, 91.7)]

เส้นถดถอยร่วม y = 3.00 + 0.50x
  x=4 -> px (0.0, 120.0)
  x=19 -> px (190.0, 7.5)

"""ความใกล้ตัดสินการจับกลุ่ม — ข้อมูลชุดเดิม เปลี่ยนแค่ระยะห่าง แล้วกลุ่มที่ตาเห็นเปลี่ยนตาม"""

LABELS = ["ก", "ข", "ค", "ง", "จ", "ฉ", "ช", "ซ"]

def layout(gap_in, gap_between):
    """วาง 8 จุดเป็น 4 คู่ · gap_in = ระยะในคู่ · gap_between = ระยะระหว่างคู่"""
    xs, x = [], 0.0
    for i in range(len(LABELS)):
        xs.append(x)
        x += gap_in if i % 2 == 0 else gap_between
    return xs

def clusters(xs, threshold):
    """จับกลุ่มแบบ single-linkage: ห่างกันไม่เกิน threshold = กลุ่มเดียวกัน"""
    groups, cur = [], [0]
    for i in range(1, len(xs)):
        if xs[i] - xs[i - 1] <= threshold:
            cur.append(i)
        else:
            groups.append(cur)
            cur = [i]
    groups.append(cur)
    return groups

def show(name, gap_in, gap_between, threshold):
    xs = layout(gap_in, gap_between)
    gs = clusters(xs, threshold)
    print(f"=== {name} ===")
    print(f"  ระยะในคู่ {gap_in} px · ระหว่างคู่ {gap_between} px · เกณฑ์สายตา {threshold} px")
    print(f"  ตำแหน่ง: {[round(v) for v in xs]}")
    print(f"  ตาเห็นเป็น {len(gs)} กลุ่ม: "
          + " | ".join("".join(LABELS[i] for i in g) for g in gs))
    return xs

show("จัดชิดเป็นคู่", 26, 74, 40)
print()
show("จัดห่างเท่ากันหมด", 50, 50, 40)
print()
print("ข้อมูลเหมือนกันทั้งสองแบบ — 8 รายการชุดเดิม ไม่มีตัวเลขไหนเปลี่ยน")
print("สิ่งที่เปลี่ยนคือระยะห่าง ซึ่งคนทำภาพเป็นคนกำหนด และตาจับกลุ่มตามนั้นทันที")

=== จัดชิดเป็นคู่ ===
  ระยะในคู่ 26 px · ระหว่างคู่ 74 px · เกณฑ์สายตา 40 px
  ตำแหน่ง: [0, 26, 100, 126, 200, 226, 300, 326]
  ตาเห็นเป็น 4 กลุ่ม: กข | คง | จฉ | ชซ

=== จัดห่างเท่ากันหมด ===
  ระยะในคู่ 50 px · ระหว่างคู่ 50 px · เกณฑ์สายตา 40 px
  ตำแหน่ง: [0, 50, 100, 150, 200, 250, 300, 350]
  ตาเห็นเป็น 8 กลุ่ม: ก | ข | ค | ง | จ | ฉ | ช | ซ

ข้อมูลเหมือนกันทั้งสองแบบ — 8 รายการชุดเดิม ไม่มีตัวเลขไหนเปลี่ยน
สิ่งที่เปลี่ยนคือระยะห่าง ซึ่งคนทำภาพเป็นคนกำหนด และตาจับกลุ่มตามนั้นทันที

"""ตรวจ MECE ด้วยเครื่อง — ซ้ำกันไหม และตกหล่นไหม เป็นคำถามที่โปรแกรมตอบได้"""

ALL = ["ค่าจ้าง", "ค่าล่วงเวลา", "ค่าไฟ", "ค่าน้ำ", "ค่าอินเทอร์เน็ต",
       "ค่าซ่อมลิฟต์", "ค่าซ่อมแอร์", "กระดาษ", "หมึกพิมพ์",
       "ค่าอบรม", "ค่าเดินทางไปอบรม", "ค่าที่ปรึกษา"]

DRAFT = {
    "ค่าคน": ["ค่าจ้าง", "ค่าล่วงเวลา", "ค่าอบรม", "ค่าที่ปรึกษา"],
    "ค่าอาคาร": ["ค่าไฟ", "ค่าน้ำ", "ค่าซ่อมลิฟต์", "ค่าซ่อมแอร์"],
    "ค่าพัฒนาบุคลากร": ["ค่าอบรม", "ค่าเดินทางไปอบรม"],
}

FIXED = {
    "จ่ายให้คนของเรา": ["ค่าจ้าง", "ค่าล่วงเวลา", "ค่าอบรม", "ค่าเดินทางไปอบรม"],
    "จ่ายให้คนนอก": ["ค่าที่ปรึกษา"],
    "จ่ายให้อาคารและระบบ": ["ค่าไฟ", "ค่าน้ำ", "ค่าอินเทอร์เน็ต",
                            "ค่าซ่อมลิฟต์", "ค่าซ่อมแอร์"],
    "ของใช้สิ้นเปลือง": ["กระดาษ", "หมึกพิมพ์"],
}

def check(name, groups, universe):
    print(f"=== {name} ===")
    seen = {}
    for g, items in groups.items():
        for it in items:
            seen.setdefault(it, []).append(g)

    overlap = {k: v for k, v in seen.items() if len(v) > 1}
    missing = [it for it in universe if it not in seen]
    stray = [it for it in seen if it not in universe]

    print(f"  กลุ่ม {len(groups)} กลุ่ม · ครอบคลุม {len(seen)} จาก {len(universe)} รายการ")
    if overlap:
        print("  ไม่ Mutually Exclusive — รายการที่อยู่หลายกลุ่ม:")
        for it, gs in overlap.items():
            print(f"    {it} อยู่ใน {' + '.join(gs)}")
    else:
        print("  Mutually Exclusive: ผ่าน ไม่มีรายการไหนอยู่สองกลุ่ม")
    if missing:
        print(f"  ไม่ Collectively Exhaustive — ตกหล่น {len(missing)} รายการ: {', '.join(missing)}")
    else:
        print("  Collectively Exhaustive: ผ่าน ไม่มีรายการตกหล่น")
    if stray:
        print(f"  มีรายการนอกขอบเขต: {', '.join(stray)}")
    ok = not overlap and not missing and not stray
    print(f"  สรุป: {'MECE' if ok else 'ยังไม่ MECE'}\n")
    return ok

check("ร่างแรก จัดตามสัญชาตญาณ", DRAFT, ALL)
check("ร่างสอง ถามว่าเงินออกไปหาใคร", FIXED, ALL)

print("ร่างแรกไม่ได้ขี้เกียจ มันแค่ใช้เกณฑ์แบ่งสองอันปนกัน")
print("คือ 'ประเภทของต้นทุน' กับ 'วัตถุประสงค์' ซึ่งซ้อนทับกันโดยธรรมชาติ")
print("ร่างสองใช้เกณฑ์เดียวตลอด: เงินก้อนนี้ออกไปหาใคร")

# --- เรขาคณิตของ FIG 12.1: ขอบเขตทั้งหมด = 560 px ---
W = 560.0
unit = W / len(ALL)
print(f"\n=== เรขาคณิตของ FIG 12.1 (1 รายการ = {unit:.2f} px จาก {len(ALL)} รายการ) ===")

print("ร่างแรก — วางให้เห็นการทับซ้อนกับช่องโหว่")
# วางกลุ่มที่ใช้รายการร่วมกันให้ติดกัน ไม่งั้นภาพจะโชว์การทับซ้อนผิดคู่
LAYOUT = ["ค่าคน", "ค่าพัฒนาบุคลากร", "ค่าอาคาร"]
covered = set()
x = 0.0
for g in LAYOUT:
    items = DRAFT[g]
    dup = [it for it in items if it in covered]
    start = x - len(dup) * unit          # ถอยหลังเท่าจำนวนรายการที่ซ้ำ เพื่อให้บล็อกทับกันจริง
    w = len(items) * unit
    print(f"  {g:<16} x={start:6.2f} w={w:6.2f} (ซ้ำ {len(dup)} รายการ)")
    covered.update(items)
    x = start + w
gap_items = len(ALL) - len(covered)
print(f"  ช่องโหว่ท้ายแถบ x={x:.2f} w={gap_items * unit:.2f} ({gap_items} รายการที่ไม่มีกลุ่มไหนรับ)")

print("ร่างสอง — ปูเรียงกันไปโดยไม่ทับ")
x = 0.0
for g, items in FIXED.items():
    w = len(items) * unit
    print(f"  {g:<22} x={x:6.2f} w={w:6.2f}")
    x += w
print(f"  ปลายแถบอยู่ที่ {x:.2f} px = เต็มขอบเขต {W:.0f} px พอดี")

=== ร่างแรก จัดตามสัญชาตญาณ ===
  กลุ่ม 3 กลุ่ม · ครอบคลุม 9 จาก 12 รายการ
  ไม่ Mutually Exclusive — รายการที่อยู่หลายกลุ่ม:
    ค่าอบรม อยู่ใน ค่าคน + ค่าพัฒนาบุคลากร
  ไม่ Collectively Exhaustive — ตกหล่น 3 รายการ: ค่าอินเทอร์เน็ต, กระดาษ, หมึกพิมพ์
  สรุป: ยังไม่ MECE

=== ร่างสอง ถามว่าเงินออกไปหาใคร ===
  กลุ่ม 4 กลุ่ม · ครอบคลุม 12 จาก 12 รายการ
  Mutually Exclusive: ผ่าน ไม่มีรายการไหนอยู่สองกลุ่ม
  Collectively Exhaustive: ผ่าน ไม่มีรายการตกหล่น
  สรุป: MECE

ร่างแรกไม่ได้ขี้เกียจ มันแค่ใช้เกณฑ์แบ่งสองอันปนกัน
คือ 'ประเภทของต้นทุน' กับ 'วัตถุประสงค์' ซึ่งซ้อนทับกันโดยธรรมชาติ
ร่างสองใช้เกณฑ์เดียวตลอด: เงินก้อนนี้ออกไปหาใคร

=== เรขาคณิตของ FIG 12.1 (1 รายการ = 46.67 px จาก 12 รายการ) ===
ร่างแรก — วางให้เห็นการทับซ้อนกับช่องโหว่
  ค่าคน            x=  0.00 w=186.67 (ซ้ำ 0 รายการ)
  ค่าพัฒนาบุคลากร  x=140.00 w= 93.33 (ซ้ำ 1 รายการ)
  ค่าอาคาร         x=233.33 w=186.67 (ซ้ำ 0 รายการ)
  ช่องโหว่ท้ายแถบ x=420.00 w=140.00 (3 รายการที่ไม่มีกลุ่มไหนรับ)
ร่างสอง — ปูเรียงกันไปโดยไม่ทับ
  จ่ายให้คนของเรา        x=  0.00 w=186.67
  จ่ายให้คนนอก           x=186.67 w= 46.67
  จ่ายให้อาคารและระบบ    x=233.33 w=233.33
  ของใช้สิ้นเปลือง       x=466.67 w= 93.33
  ปลายแถบอยู่ที่ 560.00 px = เต็มขอบเขต 560 px พอดี

"""หัวข้อคือที่เก็บของข้อเท็จจริงที่ช่องทางภาพแบกไม่ไหว — และคำนวณได้ว่ามีข้อไหนบ้าง"""

DATA = [("ก", 22), ("ข", 18), ("ค", 25), ("ง", 16), ("จ", 19)]
K = 0.05  # เกณฑ์เดียวกับ channels.py ในบทที่ 5 — ช่องว่างต้องกินกี่ส่วนของช่วง ถึงจะหวังให้ตาแยกออก

vals = [v for _, v in DATA]
hi, total = max(vals), sum(vals)
rank = sorted(DATA, key=lambda kv: -kv[1])


def share_of_range(gap, channel):
    """ช่องว่าง gap หน่วย ได้ส่วนแบ่งเท่าไหร่ของช่วงที่ช่องทางนั้นมีให้ — สูตรเดียวกับบทที่ 5"""
    return gap / hi if channel == "ความยาว" else gap / total


# --- 1. ข้อเท็จจริงของสไลด์ ทุกข้อคือช่องว่างระหว่างค่าสองค่า ---
#     คู่ที่ติดกันในอันดับทุกคู่ บวกคู่หัว-ท้ายซึ่งเป็นช่วงกว้างสุดของชุด
steps = [(rank[i], rank[i + 1]) for i in range(len(rank) - 1)]
FACTS = [(f"อันดับ {i + 1} กับ {i + 2}", a, b) for i, (a, b) in enumerate(steps)]
FACTS.append(("หัวตารางกับท้ายตาราง", rank[0], rank[-1]))

# --- 2. ช่องทางไหนแสดงข้อไหนได้เอง ข้อที่เหลือคือภาระของหัวข้อ ---
CHANNELS = ["ความยาว", "มุม"]
homeless = {ch: [] for ch in CHANNELS}

print("=== ข้อเท็จจริงห้าข้อ ผ่านสองช่องทาง ===")
for label, a, b in FACTS:
    gap = a[1] - b[1]
    cells = []
    for ch in CHANNELS:
        share = share_of_range(gap, ch)
        if share < K:
            homeless[ch].append((a[0], b[0], gap))
        cells.append(f"{ch} {share * 100:5.2f}% {'ภาพแสดงได้' if share >= K else 'ภาพแสดงไม่ได้'}")
    print(f"  {label} (หน่วย {a[0]} {a[1]} กับ หน่วย {b[0]} {b[1]} · ต่าง {gap} จุด)")
    for cell in cells:
        print(f"    {cell}")


# --- 3. ประกอบประโยค: ข้อสรุปขึ้นก่อน แล้วต่อด้วยข้อที่ภาพแบกไม่ไหว ---
def compose(channel):
    parts = [f"หน่วย {rank[0][0]} ใช้มากที่สุด {rank[0][1]} จาก {total}"]
    parts += [f"{a} กับ {b} ต่างกัน {gap} จุด" for a, b, gap in homeless[channel]]
    return " · ".join(parts)


print("\n=== หัวข้อที่ประกอบจากข้อที่เหลือ ===")
for ch in CHANNELS:
    line = compose(ch)
    print(f"  ช่องทาง {ch}: ตกค้าง {len(homeless[ch])} จาก {len(FACTS)} ข้อ "
          f"· หัวข้อยาว {len(line)} ตัวอักษร")
    print(f"    {line}")

extra = len(compose("มุม")) - len(compose("ความยาว"))
print(f"\nย้ายไปช่องทางที่แย่กว่า หัวข้อยาวขึ้น {extra} ตัวอักษร โดยข้อมูลไม่ขยับเลยสักตัว")
print("หัวข้อที่ยาวขึ้นเรื่อย ๆ จึงไม่ใช่ปัญหาการเขียน แต่เป็นใบเสร็จของช่องทางที่เลือก")

# --- 4. ตัวเลขทุกตัวที่ปรากฏใน FIG 13.1 ---
print("\n=== ตัวเลขทุกตัวใน FIG 13.1 ===")
for label, a, b in FACTS:
    gap = a[1] - b[1]
    cells = " | ".join(
        f"{ch} {share_of_range(gap, ch) * 100:.2f}%"
        f"{'' if share_of_range(gap, ch) >= K else ' (ตก)'}"
        for ch in CHANNELS
    )
    print(f"  แถว '{label}' {gap} จุด: {cells}")
for ch in CHANNELS:
    print(f"  หัวข้อของช่องทาง {ch}: ตกค้าง {len(homeless[ch])} ข้อ · {len(compose(ch))} ตัวอักษร")

=== ข้อเท็จจริงห้าข้อ ผ่านสองช่องทาง ===
  อันดับ 1 กับ 2 (หน่วย ค 25 กับ หน่วย ก 22 · ต่าง 3 จุด)
    ความยาว 12.00% ภาพแสดงได้
    มุม  3.00% ภาพแสดงไม่ได้
  อันดับ 2 กับ 3 (หน่วย ก 22 กับ หน่วย จ 19 · ต่าง 3 จุด)
    ความยาว 12.00% ภาพแสดงได้
    มุม  3.00% ภาพแสดงไม่ได้
  อันดับ 3 กับ 4 (หน่วย จ 19 กับ หน่วย ข 18 · ต่าง 1 จุด)
    ความยาว  4.00% ภาพแสดงไม่ได้
    มุม  1.00% ภาพแสดงไม่ได้
  อันดับ 4 กับ 5 (หน่วย ข 18 กับ หน่วย ง 16 · ต่าง 2 จุด)
    ความยาว  8.00% ภาพแสดงได้
    มุม  2.00% ภาพแสดงไม่ได้
  หัวตารางกับท้ายตาราง (หน่วย ค 25 กับ หน่วย ง 16 · ต่าง 9 จุด)
    ความยาว 36.00% ภาพแสดงได้
    มุม  9.00% ภาพแสดงได้

=== หัวข้อที่ประกอบจากข้อที่เหลือ ===
  ช่องทาง ความยาว: ตกค้าง 1 จาก 5 ข้อ · หัวข้อยาว 55 ตัวอักษร
    หน่วย ค ใช้มากที่สุด 25 จาก 100 · จ กับ ข ต่างกัน 1 จุด
  ช่องทาง มุม: ตกค้าง 4 จาก 5 ข้อ · หัวข้อยาว 127 ตัวอักษร
    หน่วย ค ใช้มากที่สุด 25 จาก 100 · ค กับ ก ต่างกัน 3 จุด · ก กับ จ ต่างกัน 3 จุด · จ กับ ข ต่างกัน 1 จุด · ข กับ ง ต่างกัน 2 จุด

ย้ายไปช่องทางที่แย่กว่า หัวข้อยาวขึ้น 72 ตัวอักษร โดยข้อมูลไม่ขยับเลยสักตัว
หัวข้อที่ยาวขึ้นเรื่อย ๆ จึงไม่ใช่ปัญหาการเขียน แต่เป็นใบเสร็จของช่องทางที่เลือก

=== ตัวเลขทุกตัวใน FIG 13.1 ===
  แถว 'อันดับ 1 กับ 2' 3 จุด: ความยาว 12.00% | มุม 3.00% (ตก)
  แถว 'อันดับ 2 กับ 3' 3 จุด: ความยาว 12.00% | มุม 3.00% (ตก)
  แถว 'อันดับ 3 กับ 4' 1 จุด: ความยาว 4.00% (ตก) | มุม 1.00% (ตก)
  แถว 'อันดับ 4 กับ 5' 2 จุด: ความยาว 8.00% | มุม 2.00% (ตก)
  แถว 'หัวตารางกับท้ายตาราง' 9 จุด: ความยาว 36.00% | มุม 9.00%
  หัวข้อของช่องทาง ความยาว: ตกค้าง 1 ข้อ · 55 ตัวอักษร
  หัวข้อของช่องทาง มุม: ตกค้าง 4 ข้อ · 127 ตัวอักษร

"""รื้อสไลด์แล้วประกอบใหม่ — ตัวเลขทุกตัวของบทนี้มาจากสคริปต์เดียวนี้"""
import math

DATA = [("ก", 22), ("ข", 18), ("ค", 25), ("ง", 16), ("จ", 19)]
K = 0.05
vals = [v for _, v in DATA]
hi, total = max(vals), sum(vals)
rank = sorted(DATA, key=lambda kv: -kv[1])

# --- 1. บัญชีหมึกสามช่อง — ต่อยอดจาก dataink.py ในบทที่ 7 ที่มีแค่สองช่อง ---
#     บริบท = หน่วย ที่มา เส้นอ้างอิง ซึ่งบทที่ 7.3 ห้ามลบ · เปล่า = ไม่ตอบคำถามไหนเลย
BEFORE_INK = [
    ("ชิ้นวงกลม 5 ชิ้น", 5, "ข้อมูล"),
    ("คำอธิบายสัญลักษณ์ 5 บรรทัด", 5, "เปล่า"),
    ("วงแหวนเงาใต้วงกลม", 1, "เปล่า"),
    ("กรอบรอบภาพ 4 ด้าน", 4, "เปล่า"),
    ("เส้นคั่นใต้หัวข้อ", 1, "เปล่า"),
    ("หัวข้อที่บอกแค่ชื่อเรื่อง", 1, "บริบท"),
    ("บรรทัดหน่วยและที่มา", 1, "บริบท"),
]
AFTER_INK = [
    ("แท่ง 5 อัน", 5, "ข้อมูล"),
    ("ตัวเลขบนแท่ง", 5, "ข้อมูล"),
    ("ป้ายชื่อใต้แท่ง", 5, "ข้อมูล"),
    ("หัวข้อที่บอกข้อสรุป", 1, "ข้อมูล"),
    ("เส้นฐานเส้นเดียว", 1, "บริบท"),
    ("บรรทัดหน่วยและที่มา", 1, "บริบท"),
]


def ink(name, items):
    kinds = {"ข้อมูล": 0, "บริบท": 0, "เปล่า": 0}
    for _, n, kind in items:
        kinds[kind] += n
    t = sum(kinds.values())
    print(f"=== บัญชีหมึกของ{name} ===")
    for label, n, kind in items:
        print(f"  [{kind}] {label} = {n}")
    print(f"  รวม {t} ชิ้น · ข้อมูล {kinds['ข้อมูล']} · บริบท {kinds['บริบท']} "
          f"· เปล่า {kinds['เปล่า']} · หมึกที่เป็นข้อมูล {kinds['ข้อมูล'] / t * 100:.1f}%\n")
    return kinds, t


b_kind, b_total = ink("สไลด์ตั้งต้น", BEFORE_INK)
a_kind, a_total = ink("สไลด์ที่ประกอบใหม่", AFTER_INK)
print(f"จำนวนชิ้นรวม {b_total} -> {a_total} · หมึกเปล่า {b_kind['เปล่า']} -> {a_kind['เปล่า']}"
      f" · หมึกที่เป็นข้อมูล {b_kind['ข้อมูล']} -> {a_kind['ข้อมูล']}")
print("ที่ว่างที่ได้จากการลบ ไม่ได้กลายเป็นที่ว่าง มันถูกเอาไปใส่ข้อมูลจนเต็ม\n")


# --- 2. งานโหมดไล่ทีละชิ้นที่สไลด์โยนไปให้คนอ่าน (บทที่ 2) ---
def serial_jobs(n, legend, sorted_by_value, values_printed):
    jobs = []
    if legend:
        jobs.append(("จับคู่ชิ้นกับคำอธิบายสัญลักษณ์", n))
    if not sorted_by_value:
        jobs.append(("ไล่เทียบเองเพื่อหาอันดับ", n - 1))
    if not values_printed:
        jobs.append(("กะค่าจากภาพทีละชิ้น", n))
    return jobs


print("=== งานโหมดไล่ทีละชิ้นที่คนอ่านต้องทำ ===")
for name, kw in (("สไลด์ตั้งต้น", dict(legend=True, sorted_by_value=False, values_printed=False)),
                 ("สไลด์ที่ประกอบใหม่", dict(legend=False, sorted_by_value=True, values_printed=True))):
    jobs = serial_jobs(len(DATA), **kw)
    print(f"  {name}: {sum(c for _, c in jobs)} ครั้ง")
    for label, c in jobs:
        print(f"    {label} {c} ครั้ง")
    if not jobs:
        print("    ไม่มีเลย ทุกอย่างอ่านได้ในโหมดขนาน")
print()

# --- 2ก. สีทำหน้าที่อะไร และคนอ่านต้องจำอะไรบ้าง (บทที่ 2, 8) ---
print("=== หน้าที่ของสี ===")
for name, hues, job, must_remember in (
        ("สไลด์ตั้งต้น", 5, "แยกตัวตนของกลุ่ม", 5),
        ("สไลด์ที่ประกอบใหม่", 1, "เน้นข้อสรุปหนึ่งจุด", 0)):
    print(f"  {name}: ใช้ {hues} สี · สีทำหน้าที่{job} "
          f"· คนอ่านต้องจำคู่สี-ชื่อ {must_remember} คู่")
print("  ทั้งสองใบไม่ได้เอาสีไปแบกปริมาณ ข้อผิดพลาดของบทที่ 8 จึงไม่ได้อยู่ที่สไลด์นี้")
print("  สิ่งที่สีทำผิดในใบตั้งต้นคือทำหน้าที่ของป้าย ทั้งที่ป้ายวางติดชิ้นได้เลย\n")


# --- 3. ช่องทางไหนแบกช่องว่างไหนไหว (สูตรจาก channels.py บทที่ 5) ---
def share_of_range(gap, channel):
    return gap / hi if channel == "ความยาว" else gap / total


steps = [(rank[i], rank[i + 1]) for i in range(len(rank) - 1)]
tight = min(steps, key=lambda p: p[0][1] - p[1][1])
FACTS = [(f"อันดับ {i + 1} กับ {i + 2}", a, b) for i, (a, b) in enumerate(steps)]
FACTS.append(("หัวตารางกับท้ายตาราง", rank[0], rank[-1]))

print("=== ย้ายช่องทางจากมุมไปความยาว แล้วช่องว่างได้ส่วนแบ่งเท่าไหร่ ===")
homeless = {"มุม": [], "ความยาว": []}
for label, a, b in FACTS:
    gap = a[1] - b[1]
    cells = []
    for ch in ("มุม", "ความยาว"):
        s = share_of_range(gap, ch)
        if s < K:
            homeless[ch].append((a[0], b[0], gap))
        cells.append(f"{ch} {s * 100:5.2f}% {'ผ่าน' if s >= K else 'ไม่ผ่าน'}")
    print(f"  {label} ({gap} จุด): " + " | ".join(cells))
print(f"  ข้อที่ภาพแบกไม่ไหว: วงกลม {len(homeless['มุม'])} ข้อ · แท่ง {len(homeless['ความยาว'])} ข้อ\n")


# --- 4. ถ้าตัดฐานแกนของแท่ง จะเกิดอะไร (สูตรจาก liefactor.py บทที่ 9) ---
def lie_factor(a, b, floor):
    real = abs(a - b) / min(a, b)
    ha, hb = a - floor, b - floor
    shown = abs(ha - hb) / min(ha, hb)
    return real, shown, shown / real


A, B = tight[0][1], tight[1][1]
print(f"=== คู่ที่สูสีที่สุด ({A} กับ {B}) ถ้าตัดฐานแกนออก ===")
for floor in (0, 10, 15, 17):
    real, shown, lf = lie_factor(A, B, floor)
    print(f"  ฐานแกน {floor:>3} -> ผลจริง {real * 100:6.2f}% "
          f"-> ภาพแสดง {shown * 100:6.2f}% -> ตัวคูณคำโกหก {lf:.2f}")
print("  ศูนย์คือฐานเดียวที่ตัวคูณเท่ากับ 1 และแท่งอ่านค่าจากความยาว จึงไม่มีทางเลือกอื่น\n")


# --- 5. หัวข้อที่ประกอบจากข้อเท็จจริงที่แท่งแบกไม่ไหว (วิธีจาก headline.py บทที่ 13) ---
HEADLINE = " · ".join(
    [f"หน่วย {rank[0][0]} ใช้มากที่สุด {rank[0][1]} จาก {total}"]
    + [f"{a} กับ {b} ต่างกัน {gap} จุด" for a, b, gap in homeless["ความยาว"]]
)
print("=== หัวข้อของสไลด์ที่ประกอบใหม่ ===")
print(f"  {HEADLINE}")
print(f"  แบกข้อเท็จจริง {1 + len(homeless['ความยาว'])} ข้อ · ยาว {len(HEADLINE)} ตัวอักษร\n")


# --- 6. เรขาคณิตของภาพทั้งสามในบทนี้ ---
print("=== เรขาคณิตของ FIG 14.1 (วงกลม รัศมี 72 เรียงตามลำดับในตาราง) ===")
start, R = -90.0, 72.0
for k, v in DATA:
    sweep = v / total * 360.0
    end = start + sweep
    x1, y1 = R * math.cos(math.radians(start)), R * math.sin(math.radians(start))
    x2, y2 = R * math.cos(math.radians(end)), R * math.sin(math.radians(end))
    print(f"  {k}: {v:>3} -> {sweep:6.2f} องศา | "
          f"M 0 0 L {x1:7.2f} {y1:7.2f} A {R} {R} 0 0 1 {x2:7.2f} {y2:7.2f} Z")
    start = end

print("\n=== เรขาคณิตของ FIG 14.2 (แท่งเรียงจากมาก ฐานที่ศูนย์ สูงสุด 110 px) ===")
BAR_MAX = 110.0
for k, v in rank:
    print(f"  {k}: {v:>3} -> สูง {v / hi * BAR_MAX:6.2f} px")

print("\n=== เรขาคณิตของ FIG 14.3 (จุดบนแกนร่วม ซูมช่วง 16-25 กว้าง 480 px) ===")
lo_v, hi_v, AXIS = min(vals), hi, 480.0
for k, v in rank:
    print(f"  {k}: {v:>3} -> x {(v - lo_v) / (hi_v - lo_v) * AXIS:6.2f} px")
gap_tight = A - B
print(f"  ช่องว่าง {gap_tight} จุด บนแกนที่ซูมแล้ว = "
      f"{gap_tight / (hi_v - lo_v) * 100:.2f}% ของช่วงที่วาด "
      f"(บนแท่งฐานศูนย์ได้ {share_of_range(gap_tight, 'ความยาว') * 100:.2f}%)")