cách tính đường trung bình của tam giác

เส้นมัธยฐานของสามเหลี่ยม

เส้นมัธยฐาน Median ลากจากจุดยอดไปจุดกึ่งกลางด้านตรงข้าม สามเหลี่ยมมี 3 เส้น ตัดกันที่ Centroid จุดศูนย์ถ่วง แบ่งอัตราส่วน 2:1

สูตร Apollonius คำนวณความยาวเส้นมัธยฐาน m_a = (1/2)√(2b² + 2c² - a²) ใช้ได้กับสามเหลี่ยมทุกชนิด

คำนวณด้วย Python

# triangle_median.py — คำนวณเส้นมัธยฐานของสามเหลี่ยม
import math
from dataclasses import dataclass
from typing import Tuple

@dataclass
class Point:
    x: float
    y: float

    def distance_to(self, other: 'Point') -> float:
        return math.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)

    def midpoint(self, other: 'Point') -> 'Point':
        return Point((self.x + other.x) / 2, (self.y + other.y) / 2)

@dataclass
class Triangle:
    A: Point
    B: Point
    C: Point

    @property
    def sides(self) -> Tuple[float, float, float]:
        """ความยาวด้าน a, b, c"""
        a = self.B.distance_to(self.C)  # ด้านตรงข้าม A
        b = self.A.distance_to(self.C)  # ด้านตรงข้าม B
        c = self.A.distance_to(self.B)  # ด้านตรงข้าม C
        return a, b, c

    def median_length(self, vertex: str) -> float:
        """คำนวณความยาวเส้นมัธยฐานด้วยสูตร Apollonius"""
        a, b, c = self.sides

        if vertex == 'A':
            # m_a = (1/2) * sqrt(2b^2 + 2c^2 - a^2)
            return 0.5 * math.sqrt(2*b**2 + 2*c**2 - a**2)
        elif vertex == 'B':
            return 0.5 * math.sqrt(2*a**2 + 2*c**2 - b**2)
        else:  # C
            return 0.5 * math.sqrt(2*a**2 + 2*b**2 - c**2)

    def median_endpoint(self, vertex: str) -> Tuple[Point, Point]:
        """จุดเริ่มต้นและจุดสิ้นสุดของเส้นมัธยฐาน"""
        if vertex == 'A':
            return self.A, self.B.midpoint(self.C)
        elif vertex == 'B':
            return self.B, self.A.midpoint(self.C)
        else:
            return self.C, self.A.midpoint(self.B)

    @property
    def centroid(self) -> Point:
        """Centroid = จุดตัดของเส้นมัธยฐานทั้ง 3"""
        return Point(
            (self.A.x + self.B.x + self.C.x) / 3,
            (self.A.y + self.B.y + self.C.y) / 3,
        )

    @property
    def area(self) -> float:
        """พื้นที่สามเหลี่ยม (สูตร Shoelace)"""
        return abs(
            self.A.x * (self.B.y - self.C.y) +
            self.B.x * (self.C.y - self.A.y) +
            self.C.x * (self.A.y - self.B.y)
        ) / 2

    @property
    def perimeter(self) -> float:
        a, b, c = self.sides
        return a + b + c

    def info(self):
        """แสดงข้อมูลสามเหลี่ยม"""
        a, b, c = self.sides
        print(f"\nสามเหลี่ยม ABC:")
        print(f"  A = ({self.A.x}, {self.A.y})")
        print(f"  B = ({self.B.x}, {self.B.y})")
        print(f"  C = ({self.C.x}, {self.C.y})")
        print(f"\n  ด้าน a (BC) = {a:.4f}")
        print(f"  ด้าน b (AC) = {b:.4f}")
        print(f"  ด้าน c (AB) = {c:.4f}")
        print(f"  เส้นรอบรูป = {self.perimeter:.4f}")
        print(f"  พื้นที่ = {self.area:.4f}")

        print(f"\n  เส้นมัธยฐาน:")
        for v in ['A', 'B', 'C']:
            length = self.median_length(v)
            start, end = self.median_endpoint(v)
            print(f"    m_{v} = {length:.4f} "
                  f"({start.x:.1f},{start.y:.1f}) -> ({end.x:.1f},{end.y:.1f})")

        g = self.centroid
        print(f"\n  Centroid G = ({g.x:.4f}, {g.y:.4f})")

        # ตรวจสอบอัตราส่วน 2:1
        print(f"\n  ตรวจสอบอัตราส่วน 2:1:")
        for v in ['A', 'B', 'C']:
            start, end = self.median_endpoint(v)
            d_vertex_centroid = start.distance_to(g)
            d_centroid_midpoint = g.distance_to(end)
            ratio = d_vertex_centroid / d_centroid_midpoint if d_centroid_midpoint > 0 else 0
            print(f"    m_{v}: vertex->G = {d_vertex_centroid:.4f}, "
                  f"G->midpoint = {d_centroid_midpoint:.4f}, "
                  f"ratio = {ratio:.4f}")

# ตัวอย่าง 1: สามเหลี่ยมทั่วไป
t1 = Triangle(Point(0, 0), Point(6, 0), Point(3, 5))
t1.info()

# ตัวอย่าง 2: สามเหลี่ยมด้านเท่า
s = 6
t2 = Triangle(Point(0, 0), Point(s, 0), Point(s/2, s*math.sqrt(3)/2))
print(f"\n\nสามเหลี่ยมด้านเท่า (ด้าน={s}):")
for v in ['A', 'B', 'C']:
    print(f"  m_{v} = {t2.median_length(v):.4f}")
print(f"  Centroid = ({t2.centroid.x:.4f}, {t2.centroid.y:.4f})")

สูตรและคุณสมบัติ

# median_properties.py — คุณสมบัติเส้นมัธยฐาน
import math

def apollonius_median(a, b, c, vertex='A'):
    """สูตร Apollonius คำนวณเส้นมัธยฐาน"""
    if vertex == 'A':
        val = 2*b**2 + 2*c**2 - a**2
    elif vertex == 'B':
        val = 2*a**2 + 2*c**2 - b**2
    else:
        val = 2*a**2 + 2*b**2 - c**2

    if val < 0:
        return None  # ไม่ใช่สามเหลี่ยม
    return 0.5 * math.sqrt(val)

def median_relation(a, b, c):
    """ความสัมพันธ์: m_a² + m_b² + m_c² = (3/4)(a² + b² + c²)"""
    ma = apollonius_median(a, b, c, 'A')
    mb = apollonius_median(a, b, c, 'B')
    mc = apollonius_median(a, b, c, 'C')

    sum_median_sq = ma**2 + mb**2 + mc**2
    three_quarter_sides = 0.75 * (a**2 + b**2 + c**2)

    return sum_median_sq, three_quarter_sides, ma, mb, mc

# ตัวอย่างหลายชนิดสามเหลี่ยม
triangles = {
    "สามเหลี่ยมทั่วไป (3,4,5)": (3, 4, 5),
    "สามเหลี่ยมด้านเท่า (5,5,5)": (5, 5, 5),
    "สามเหลี่ยมหน้าจั่ว (5,5,8)": (5, 5, 8),
    "สามเหลี่ยมมุมฉาก (6,8,10)": (6, 8, 10),
    "สามเหลี่ยมใหญ่ (7,10,12)": (7, 10, 12),
}

print("คำนวณเส้นมัธยฐาน:")
print("=" * 60)

for name, (a, b, c) in triangles.items():
    sum_sq, three_q, ma, mb, mc = median_relation(a, b, c)
    print(f"\n  {name}")
    print(f"    ด้าน: a={a}, b={b}, c={c}")
    print(f"    m_a = {ma:.4f}")
    print(f"    m_b = {mb:.4f}")
    print(f"    m_c = {mc:.4f}")
    print(f"    m²_a + m²_b + m²_c = {sum_sq:.4f}")
    print(f"    (3/4)(a² + b² + c²) = {three_q:.4f}")
    print(f"    เท่ากัน: {abs(sum_sq - three_q) < 0.0001}")

# คุณสมบัติสำคัญ
properties = {
    "คุณสมบัติ 1": "เส้นมัธยฐาน 3 เส้นตัดกันที่จุด Centroid",
    "คุณสมบัติ 2": "Centroid แบ่งเส้นมัธยฐานในอัตราส่วน 2:1 จากจุดยอด",
    "คุณสมบัติ 3": "m²_a + m²_b + m²_c = (3/4)(a² + b² + c²)",
    "คุณสมบัติ 4": "เส้นมัธยฐานแบ่งสามเหลี่ยมเป็น 6 สามเหลี่ยมย่อยพื้นที่เท่ากัน",
    "คุณสมบัติ 5": "Centroid = ((x1+x2+x3)/3, (y1+y2+y3)/3)",
    "คุณสมบัติ 6": "สามเหลี่ยมด้านเท่า เส้นมัธยฐานทั้ง 3 ยาวเท่ากัน",
}

print(f"\n\nคุณสมบัติเส้นมัธยฐาน:")
for prop, desc in properties.items():
    print(f"  {prop}: {desc}")

Visualization

# triangle_visualization.py — แสดงสามเหลี่ยมและเส้นมัธยฐาน
# pip install matplotlib numpy

import numpy as np

def triangle_data(ax, ay, bx, by, cx, cy):
    """สร้างข้อมูลสำหรับ Visualization"""
    # จุดกึ่งกลาง
    mid_bc = ((bx+cx)/2, (by+cy)/2)
    mid_ac = ((ax+cx)/2, (ay+cy)/2)
    mid_ab = ((ax+bx)/2, (ay+by)/2)

    # Centroid
    gx = (ax + bx + cx) / 3
    gy = (ay + by + cy) / 3

    # ความยาวด้าน
    a = np.sqrt((bx-cx)**2 + (by-cy)**2)
    b = np.sqrt((ax-cx)**2 + (ay-cy)**2)
    c = np.sqrt((ax-bx)**2 + (ay-by)**2)

    # เส้นมัธยฐาน
    ma = 0.5 * np.sqrt(2*b**2 + 2*c**2 - a**2)
    mb = 0.5 * np.sqrt(2*a**2 + 2*c**2 - b**2)
    mc = 0.5 * np.sqrt(2*a**2 + 2*b**2 - c**2)

    data = {
        "vertices": {"A": (ax, ay), "B": (bx, by), "C": (cx, cy)},
        "midpoints": {"M_a": mid_bc, "M_b": mid_ac, "M_c": mid_ab},
        "centroid": (gx, gy),
        "sides": {"a": a, "b": b, "c": c},
        "medians": {"m_a": ma, "m_b": mb, "m_c": mc},
        "area": abs(ax*(by-cy) + bx*(cy-ay) + cx*(ay-by)) / 2,
    }

    return data

# Matplotlib code (uncomment to run)
# import matplotlib.pyplot as plt
#
# fig, ax = plt.subplots(1, 1, figsize=(8, 8))
#
# # สามเหลี่ยม
# tri = triangle_data(0, 0, 8, 0, 3, 6)
#
# # วาดด้าน
# verts = list(tri["vertices"].values())
# polygon = plt.Polygon(verts, fill=False, edgecolor='blue', linewidth=2)
# ax.add_patch(polygon)
#
# # วาดเส้นมัธยฐาน
# colors = ['red', 'green', 'purple']
# for i, (v_name, v_pos) in enumerate(tri["vertices"].items()):
#     m_name = list(tri["midpoints"].keys())[i]
#     m_pos = tri["midpoints"][m_name]
#     ax.plot([v_pos[0], m_pos[0]], [v_pos[1], m_pos[1]],
#             color=colors[i], linewidth=1.5, linestyle='--',
#             label=f"m_{v_name}")
#
# # Centroid
# gx, gy = tri["centroid"]
# ax.plot(gx, gy, 'ko', markersize=8)
# ax.annotate('G (Centroid)', (gx, gy), textcoords="offset points",
#             xytext=(10, 10), fontsize=10)
#
# ax.set_aspect('equal')
# ax.grid(True, alpha=0.3)
# ax.legend()
# plt.title('สามเหลี่ยมและเส้นมัธยฐาน')
# plt.savefig('triangle_median.png', dpi=150)
# plt.show()

# ตัวอย่าง
data = triangle_data(0, 0, 8, 0, 3, 6)
print("Triangle Visualization Data:")
print(f"\n  Vertices:")
for name, pos in data["vertices"].items():
    print(f"    {name} = {pos}")
print(f"\n  Midpoints:")
for name, pos in data["midpoints"].items():
    print(f"    {name} = ({pos[0]:.2f}, {pos[1]:.2f})")
print(f"\n  Centroid G = ({data['centroid'][0]:.4f}, {data['centroid'][1]:.4f})")
print(f"\n  Sides: a={data['sides']['a']:.4f}, b={data['sides']['b']:.4f}, c={data['sides']['c']:.4f}")
print(f"  Medians: m_a={data['medians']['m_a']:.4f}, m_b={data['medians']['m_b']:.4f}, m_c={data['medians']['m_c']:.4f}")
print(f"  Area = {data['area']:.4f}")

เคล็ดลับ

• สูตร Apollonius: m_a = (1/2)√(2b²+2c²-a²) ใช้ได้กับสามเหลี่ยมทุกชนิด
• Centroid: ค่าเฉลี่ยพิกัดจุดยอด G = ((x1+x2+x3)/3, (y1+y2+y3)/3)
• อัตราส่วน 2:1: Centroid แบ่งเส้นมัธยฐาน 2 ส่วนจากยอด 1 ส่วนจากด้าน
• พื้นที่เท่ากัน: เส้นมัธยฐาน 3 เส้นแบ่งเป็น 6 สามเหลี่ยมพื้นที่เท่ากัน
• สามเหลี่ยมด้านเท่า: เส้นมัธยฐาน = เส้นสูง = เส้นแบ่งครึ่งมุม
• SymPy: ใช้ SymPy Geometry Module คำนวณอัตโนมัติ

เส้นมัธยฐานของสามเหลี่ยมคืออะไร

เส้นตรงลากจากจุดยอดไปจุดกึ่งกลางด้านตรงข้าม สามเหลี่ยมมี 3 เส้น ตัดกันที่ Centroid จุดศูนย์ถ่วง แบ่งอัตราส่วน 2:1

สรุป

เส้นมัธยฐานลากจากจุดยอดไปกึ่งกลางด้านตรงข้าม สูตร Apollonius m_a = (1/2)√(2b²+2c²-a²) Centroid จุดตัดเส้นมัธยฐาน ค่าเฉลี่ยพิกัด แบ่ง 2:1 แบ่งเป็น 6 สามเหลี่ยมพื้นที่เท่ากัน Python คำนวณอัตโนมัติ