Ước tính độ dày thành tối thiểu giữa các cặp mặt phẳng song song để cảnh báo thành mỏng

Thành quá mỏng gây khó gia công hoặc ép nhựa không đầy. Với chi tiết toàn mặt phẳng, độ dày thành chính là khoảng cách giữa hai mặt song song đối diện; có thể ước tính bằng cách ghép các cặp mặt có pháp tuyến ngược nhau.

Ước tính độ dày thành tối thiểu giữa các…

Các bước thực hiện

1. Lấy mặt phẳng. Kèm điểm đại diện và pháp tuyến.
2. Ghép cặp song song ngược chiều. Pháp tuyến đối nhau.
3. Tính khoảng cách. Chiếu lên pháp tuyến.
4. Lọc cặp có vùng chồng nhau. Hộp bao giao nhau.
5. Cảnh báo. Dưới ngưỡng độ dày tối thiểu.

Code tham khảo (Python)

import NXOpen

def thong_tin_mat(face):
    diem = []
    for e in face.GetEdges():
        for p in e.GetVertices():
            diem.append((p.X, p.Y, p.Z))
    if len(diem) < 3:
        return None
    # tìm ba điểm không thẳng hàng
    a = diem[0]
    b = next((p for p in diem if sum(abs(p[i] - a[i]) for i in range(3)) > 1e-6), None)
    if b is None:
        return None
    u = tuple(b[i] - a[i] for i in range(3))
    c = next((p for p in diem if cross(u, tuple(p[i] - a[i] for i in range(3))) != (0.0, 0.0, 0.0)
              and sum(x * x for x in cross(u, tuple(p[i] - a[i] for i in range(3)))) > 1e-9), None)
    if c is None:
        return None
    n = cross(u, tuple(c[i] - a[i] for i in range(3)))
    d = sum(x * x for x in n) ** 0.5
    n = tuple(x / d for x in n)
    lo = tuple(min(p[i] for p in diem) for i in range(3))
    hi = tuple(max(p[i] for p in diem) for i in range(3))
    return {"diem": a, "n": n, "lo": lo, "hi": hi}

def cross(u, v):
    return (u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0])

def chong_nhau(m1, m2, dung_sai=1e-6):
    return all(min(m1["hi"][i], m2["hi"][i]) - max(m1["lo"][i], m2["lo"][i]) >= -dung_sai for i in range(3))

def do_day_thanh(mat_phang, nguong):
    canh_bao = []
    for i in range(len(mat_phang)):
        for j in range(i + 1, len(mat_phang)):
            m1, m2 = mat_phang[i], mat_phang[j]
            dot = sum(m1["n"][k] * m2["n"][k] for k in range(3))
            if dot > -0.999:
                continue                           # không song song ngược chiều
            khoang = abs(sum((m2["diem"][k] - m1["diem"][k]) * m1["n"][k] for k in range(3)))
            if 1e-6 < khoang < nguong and chong_nhau_theo_phang(m1, m2):
                canh_bao.append(khoang)
    return sorted(canh_bao)

def chong_nhau_theo_phang(m1, m2):
    # bỏ qua trục gần song song với pháp tuyến: so sánh vùng chiếu trên hai trục còn lại
    truc = max(range(3), key=lambda k: abs(m1["n"][k]))
    con_lai = [k for k in range(3) if k != truc]
    return all(min(m1["hi"][k], m2["hi"][k]) - max(m1["lo"][k], m2["lo"][k]) > 1e-6 for k in con_lai)

def main():
    session = NXOpen.Session.GetSession()
    lw = session.ListingWindow
    lw.Open()
    part = session.Parts.Work
    solids = [b for b in part.Bodies if b.IsSolidBody] if part else []
    if not solids:
        return
    mat = [t for t in (thong_tin_mat(f) for f in solids[0].GetFaces()
                       if f.SolidFaceType == NXOpen.Face.FaceType.Planar) if t]
    mong = do_day_thanh(mat, nguong=2.0)
    lw.WriteLine("Số cặp mặt có khoảng cách < 2.0 mm: %d" % len(mong))
    for k in mong[:20]:
        lw.WriteLine("  khoảng cách %.3f mm" % k)

if __name__ == "__main__":
    main()

Giải thích code

• Hai mặt phẳng song song ngược chiều (tích vô hướng pháp tuyến gần -1) và có vùng chiếu chồng nhau là hai mặt của cùng một thành.
• Khoảng cách tính bằng hình chiếu vectơ nối hai điểm lên pháp tuyến.
• Phương pháp chỉ áp dụng được cho mặt phẳng; thành cong cần công cụ phân tích độ dày của NX (Wall Thickness).

Lỗi thường gặp

• Độ phức tạp bình phương theo số mặt; chi tiết hàng nghìn mặt cần cấu trúc tìm kiếm không gian.
• Kết quả chỉ là cảnh báo sơ bộ; kiểm tra lại bằng phân tích độ dày chính thức trước khi kết luận.

Code mang tính tham khảo, viết cho NX 12 trở lên (Python journal). Tên menu và một số lớp có thể khác theo phiên bản NX; hãy chạy thử trên bản sao của chi tiết trước khi dùng cho dữ liệu thật.