code/cube3d/training/check_rotation_onehot.py

import numpy as np
import itertools

def signed_perm_mats_det_plus_1():
    """生成所有 3x3 的 ±1 置换矩阵，且 det=+1（24 个）"""
    mats = []
    for perm in itertools.permutations(range(3)):  # 6 种列置换
        P = np.zeros((3,3), int)
        for r, c in enumerate(perm):
            P[r, c] = 1
        for signs in itertools.product([1, -1], repeat=3):  # 行符号
            R = P * np.array(signs)[:, None]               # 每行乘 ±1
            if int(round(np.linalg.det(R))) == 1:
                mats.append(R)
    # 去重（以 tuple 做 key）
    uniq = {}
    for R in mats:
        key = tuple(R.reshape(-1))
        uniq[key] = R  # 同一个 key 只保留一个
    return list(uniq.values())  # 24 个

R24 = signed_perm_mats_det_plus_1()  # len(R24) == 24

#import ipdb; ipdb.set_trace()

def rot_to_onehot24(R):
    Rr = np.round(R).astype(int)         # 去毛刺到 {-1,0,1}
    # 直接精确匹配；如果有极少量数值误差，也可以用 L1/L2 最近邻
    keys = [tuple(M.reshape(-1)) for M in R24]
    kR = tuple(Rr.reshape(-1))
    if kR in keys:
        idx = keys.index(kR)
    else:
        # 兜底最近邻（谨慎使用）
        diffs = [np.sum(np.abs(M - Rr)) for M in R24]
        idx = int(np.argmin(diffs))
    one_hot = np.zeros(24, dtype=int)
    one_hot[idx] = 1
    return one_hot, idx

def onehot24_to_rot(one_hot):
    idx = int(np.asarray(one_hot).argmax())
    #import ipdb; ipdb.set_trace()
    return R24[idx]

# # 从索引出发：idx -> R -> onehot -> idx_back
# for i in range(24):
#     R = R24[i]
#     oh, j = rot_to_onehot24(R)
#     assert j == i
#     Rb = onehot24_to_rot(oh)
#     assert np.array_equal(R, Rb)
# print("24类旋转：往返一致 ✅")

import os
import numpy as np
from itertools import product, permutations

def generate_24_rotations():
    """生成 24 个 det=+1 的 ±1 置换矩阵（立方体的旋转群）。"""
    rots = []
    for p in permutations(range(3)):               # 轴置换
        P = np.zeros((3,3), dtype=int)
        for i, j in enumerate(p):
            P[i, j] = 1
        for signs in product([-1, 1], repeat=3):   # 各轴符号
            S = np.diag(signs)
            R = S @ P
            if round(np.linalg.det(R)) == 1:       # 只要 det=+1
                rots.append(R.astype(int))
    # 去重并固定顺序
    unique = []
    for R in rots:
        if not any(np.array_equal(R, U) for U in unique):
            unique.append(R)
    return unique  # 长度应为 24

ROTATIONS_24 = generate_24_rotations()

def is_signed_perm_det1(R_int):
    """R_int 是否为 entries∈{-1,0,1} 的 3x3 矩阵，且每行/列唯一一个非零，det=+1。"""
    if R_int.shape != (3,3): return False
    if not np.all(np.isin(R_int, [-1, 0, 1])): return False
    # 每行/列恰好一个非零
    if not np.all(np.sum(R_int != 0, axis=1) == 1): return False
    if not np.all(np.sum(R_int != 0, axis=0) == 1): return False
    # det=+1
    return round(np.linalg.det(R_int)) == 1

def snap_to_signed_perm(R, tol=1e-3):
    """
    仅将非常接近 -1/0/+1 的元素吸附到 -1/0/+1；若存在明显偏离（例如 0.57、0.82），保持原值——最终判定会失败。
    """
    R = np.asarray(R, dtype=float)
    R_snap = R.copy()

    # 接近 1 -> 1；接近 -1 -> -1；接近 0 -> 0
    R_snap[np.isclose(R, 1.0, atol=tol)]  = 1.0
    R_snap[np.isclose(R, -1.0, atol=tol)] = -1.0
    R_snap[np.isclose(R, 0.0, atol=tol)]  = 0.0

    # 其余保持原值（不是 24 旋转就会在后续判定中失败）
    return R_snap

def match_in_24(R, tol=1e-3):
    """
    返回 (matched, index, R_int)
      - matched: 是否匹配 24 旋转
      - index: 若匹配，给出在 ROTATIONS_24 中的索引，否则为 None
      - R_int: 吸附后的整数矩阵（或原矩阵的近似整数版，便于调试）
    """
    R_snap = snap_to_signed_perm(R, tol=tol)
    # 尝试转成 int（吸附后如果仍有非 -1/0/1 的值，astype 后会引发误判，先检查）
    if not np.all(np.isin(R_snap, [-1.0, 0.0, 1.0])):
        return False, None, R_snap  # 明显不在 24 旋转里

    R_int = R_snap.astype(int)
    if not is_signed_perm_det1(R_int):
        return False, None, R_int

    # 找索引
    for idx, R0 in enumerate(ROTATIONS_24):
        if np.array_equal(R_int, R0):
            return True, idx, R_int

    return False, None, R_int

def parse_rotation_from_parts(parts):
    """
    parts 是一行 LDR 的分割结果。旋转矩阵是 parts[5:14]（9 个数，按行展开）。
    返回 3x3 numpy 数组。
    """
    vals = list(map(float, parts[5:14]))
    R = np.array(vals, dtype=float).reshape(3,3)
    return R

def check_ldr_file(ldr_path, tol=1e-3, verbose=True):
    """
    逐行读取 LDR 文件，遇到以 '1 ' 开头且列数>=15 的零件行，抽取旋转矩阵并与 24 旋转比对。
    """
    total = 0
    matched = 0
    not_matched = 0
    mismatches = []  # (lineno, R, R_int/snap)

    with open(ldr_path, 'r', encoding='utf-8', errors='ignore') as f:
        lines = f.readlines()
        if len(lines)>310:
            print(f"Skipping {ldr_path}: too many lines ({len(lines)}).")
            return
        for ln, line in enumerate(lines, start=1):
            line_strip = line.strip()
            if not line_strip.startswith('1 '):
                continue
            parts = line_strip.split()
            if len(parts) < 15:
                continue

            total += 1
            R = parse_rotation_from_parts(parts)
            ok, idx, R_int = match_in_24(R, tol=tol)
            if ok:
                matched += 1
            #     if verbose:
            #         print(f"[OK] line {ln}: matched rot index={idx}  matrix=\n{R_int}")
            else:
                not_matched += 1
                mismatches.append((ln, R, R_int))
                if verbose:
                    print(f"[NO] line {ln}: not in 24 rotations. snapped=\n{R_int}\norig=\n{R}")

    print("\n===== SUMMARY =====")
    print(f"file: {ldr_path}")
    print(f"total part-lines: {total}")
    print(f"matched in 24:   {matched}")
    print(f"not matched:     {not_matched}")

    if not_matched and verbose:
        print("\nExamples of not-matched (up to 5):")
        for ln, R, R_int in mismatches[:5]:
            print(f"- line {ln}: snapped=\n{R_int}\n  orig=\n{R}\n")

    return {
        "total": total,
        "matched": matched,
        "not_matched": not_matched,
        "mismatches": mismatches,
    }

if __name__ == "__main__":
    folder_path = '/public/home/wangshuo/gap/assembly/data'  # 替换为你的文件夹路径
    for root, dirs, files in os.walk(folder_path):
        for file in files:
            if file.endswith('.ldr') and file.startswith('modified'):  # 只处理ldr文件
                file_path = os.path.join(root, file)
                    
                # 用法示例：替换为你的 LDR 文件路径
                #ldr_file = "/public/home/wangshuo/gap/assembly/data/blue classic car/modified_blue classic car.ldr"
                check_ldr_file(file_path, tol=1e-3, verbose=True)


# import numpy as np
# from itertools import product, permutations

# def generate_24_rotations():
#     mats = []
#     for p in permutations(range(3)):
#         P = np.zeros((3,3), dtype=int)
#         for i,j in enumerate(p): P[i,j] = 1
#         for s in product([-1,1], repeat=3):
#             S = np.diag(s)
#             R = S @ P
#             if round(np.linalg.det(R)) == 1:
#                 mats.append(R.astype(float))
#     # 去重
#     uniq = []
#     for R in mats:
#         if not any(np.array_equal(R, U) for U in uniq):
#             uniq.append(R)
#     assert len(uniq) == 24
#     return uniq

# ROT24 = generate_24_rotations()

# def rotation_distance_deg(R1, R2):
#     """
#     计算 R2 到 R1 的相对旋转角度（度数）。
#     Δ = R2^T R1； angle = arccos((trace(Δ)-1)/2)
#     数值上做夹取，避免浮点误差。
#     """
#     Delta = R2.T @ R1
#     c = (np.trace(Delta) - 1.0) / 2.0
#     c = np.clip(c, -1.0, 1.0)
#     return float(np.degrees(np.arccos(c)))

# def nearest_in_24(R):
#     best_idx, best_R, best_deg = None, None, 1e9
#     for i, Q in enumerate(ROT24):
#         deg = rotation_distance_deg(R, Q)
#         if deg < best_deg:
#             best_idx, best_R, best_deg = i, Q, deg
#     return best_idx, best_R, best_deg

# # —— 示例：对你给出的矩阵做最近邻 —— 
# R1 = np.array([
#     [ 0.      ,  0.      , -1.      ],
#     [-0.707107, -0.707107,  0.      ],
#     [-0.707107,  0.707106,  0.      ],
# ], dtype=float)

# idx, Q, deg = nearest_in_24(R1)
# print("nearest idx:", idx)
# print("nearest R:\n", Q)
# print("angle error (deg):", deg)