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

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

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

เนื้อหาเกี่ยวข้อง — Image Segmentation Internal Developer Platform

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

เนื้อหาเกี่ยวข้อง — ดูเพิ่มเติมเรื่อง IS-IS Protocol API Gateway Pattern: เข้าใจรูปแบบการสื่อสารขั้นสูงสำหรับระบบเค…

เส้น	สูตร	คำอธิบาย
m_a	(1/2)√(2b²+2c²-a²)	จากจุด A ไปกึ่งกลางด้าน a
m_b	(1/2)√(2a²+2c²-b²)	จากจุด B ไปกึ่งกลางด้าน b
m_c	(1/2)√(2a²+2b²-c²)	จากจุด C ไปกึ่งกลางด้าน c

คำนวณด้วย 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}")