code/cube3d/training/process_single_ldr.py

import numpy as np
import os
import json
from scipy.spatial.transform import Rotation as R

import numpy as np
from scipy.spatial.transform import Rotation as R

# Import centralized configuration for path management
try:
    from cube3d.config import get_mapping_paths
    print("Successfully imported config from cube3d.config")
except ImportError as e:
    print(f"Import from cube3d.config failed: {e}")
    try:
        from config import get_mapping_paths
        print("Successfully imported config from config")
    except ImportError as e:
        print(f"Failed to import config: {e}")
        raise ImportError("Failed to import get_mapping_paths from cube3d.config or config")

# from cube3d.training.check_rotation_onehot import rot_to_onehot24, onehot24_to_rot
# #from check_rotation_onehot import rot_to_onehot24, onehot24_to_rot
try:
    from cube3d.training.check_rotation_onehot import (
        rot_to_onehot24,
        onehot24_to_rot,
        signed_perm_mats_det_plus_1
    )
    print("Successfully imported from cube3d.training.check_rotation_onehot")
except ImportError as e:
    print(f"Import from cube3d.training.check_rotation_onehot failed: {e}")
    try:
        from check_rotation_onehot import (
            rot_to_onehot24,
            onehot24_to_rot,
            signed_perm_mats_det_plus_1
        )
        print("Successfully imported from check_rotation_onehot")
    except ImportError as e:
        print(f"Import from check_rotation_onehot failed: {e}")
        raise ImportError(
            "Failed to import rot_to_onehot24, onehot24_to_rot, "
            "and signed_perm_mats_det_plus_1 from both "
            "cube3d.training.check_rotation_onehot and check_rotation_onehot"
        )

def rotation_to_onehot(rotation_matrix):
    possible_angles = [0, 90, 180, 270]

    # 初始化一个64维的one-hot编码
    one_hot = np.zeros(64)
    #import ipdb; ipdb.set_trace() 
    try:
        #import ipdb; ipdb.set_trace()  
        x_angle = possible_angles.index(round(np.arctan2(np.round(rotation_matrix[2, 1], 1), np.round(rotation_matrix[2, 2],1)) * 180 / np.pi) % 360)
        y_angle = possible_angles.index(round(np.arctan2(np.round(rotation_matrix[2, 0], 1), np.round(rotation_matrix[2, 2],1)) * 180 / np.pi) % 360)
        z_angle = possible_angles.index(round(np.arctan2(np.round(rotation_matrix[1, 0], 1), np.round(rotation_matrix[0, 0],1)) * 180 / np.pi) % 360)

        # 根据x, y, z的旋转角度组合确定one-hot的索引
        index = x_angle * 16 + y_angle * 4 + z_angle

    except Exception as e:
        

        modified_matrix = rotation_matrix.copy()
        max_vals = np.max(np.abs(modified_matrix), axis=1)  # 每行最大绝对值
        sign_matrix = np.sign(modified_matrix)
        
        modified_matrix = sign_matrix * (np.abs(modified_matrix) == max_vals[:, None])

        x_angle = possible_angles.index(round(np.arctan2(np.round(modified_matrix[2, 1], 1), np.round(modified_matrix[2, 2],1)) * 180 / np.pi) % 360)
        y_angle = possible_angles.index(round(np.arctan2(np.round(modified_matrix[2, 0], 1), np.round(modified_matrix[2, 2],1)) * 180 / np.pi) % 360)
        z_angle = possible_angles.index(round(np.arctan2(np.round(modified_matrix[1, 0], 1), np.round(modified_matrix[0, 0],1)) * 180 / np.pi) % 360)
        index = x_angle * 16 + y_angle * 4 + z_angle  
        if index >= 64:
            print(f"Error occurred: {e}")

        with open("rotation_matrix_300_afterroundafter1_error_log.txt", "a") as file:  # 使用 "a" 模式追加内容
            file.write(f"Error with rotation matrix:\n{np.round(modified_matrix, 1)}\n")
            file.write("-" * 50 + "\n")  # 可选：添加分隔符，帮助区分不同错误


    one_hot[index] = 1

    return one_hot

import numpy as np

def onehot_to_rotation(one_hot):
    # 定义可能的角度
    possible_angles = [0, 90, 180, 270]

    # 获取one-hot编码中的索引位置
    index = one_hot.argmax()  # 找到值为1的那个位置，即索引

    # 根据索引推导出x、y、z的角度
    x_angle = possible_angles[(index // 16) % 4]  # x轴旋转角度
    y_angle = possible_angles[(index // 4) % 4]   # y轴旋转角度
    z_angle = possible_angles[index % 4]           # z轴旋转角度

    # 根据这些角度构建旋转矩阵
    # 构建绕X轴旋转矩阵
    Rx = np.array([[1, 0, 0],
                   [0, np.cos(np.radians(x_angle)), -np.sin(np.radians(x_angle))],
                   [0, np.sin(np.radians(x_angle)), np.cos(np.radians(x_angle))]])

    # 构建绕Y轴旋转矩阵
    Ry = np.array([[np.cos(np.radians(y_angle)), 0, np.sin(np.radians(y_angle))],
                   [0, 1, 0],
                   [-np.sin(np.radians(y_angle)), 0, np.cos(np.radians(y_angle))]])

    # 构建绕Z轴旋转矩阵
    Rz = np.array([[np.cos(np.radians(z_angle)), -np.sin(np.radians(z_angle)), 0],
                   [np.sin(np.radians(z_angle)), np.cos(np.radians(z_angle)), 0],
                   [0, 0, 1]])

    # 将这三个矩阵相乘得到总的旋转矩阵
    rotation_matrix = np.dot(Rz, np.dot(Ry, Rx))

    return rotation_matrix

def load_mappings(label_mapping_file, label_inverse_mapping_file):
    print(f"🔍 [DEBUG] load_mappings() called")
    print(f"   Forward file: {label_mapping_file}")
    print(f"   Inverse file: {label_inverse_mapping_file}")

    try:
        with open(label_mapping_file, 'r') as f:
            label_mapping = json.load(f)
        print(f"   ✅ Forward mapping loaded: {len(label_mapping)} entries")
    except Exception as e:
        print(f"   ❌ Failed to load forward mapping: {e}")
        raise

    try:
        with open(label_inverse_mapping_file, 'r') as f:
            label_inverse_mapping = json.load(f)
        print(f"   ✅ Inverse mapping loaded: {len(label_inverse_mapping)} entries")
    except Exception as e:
        print(f"   ❌ Failed to load inverse mapping: {e}")
        raise

    return label_mapping, label_inverse_mapping

# 读取LDR文件，逐行读取
def read_ldr_file(file_path):
    with open(file_path, 'r') as f:
        return f.readlines()

# 处理LDR文件并提取数据
def process_ldr_data(lines):
    data = []
    filenames = []

    all_coords = []
    all_colors = []
    all_labels = []
    label_mapping = {}
    label_inverse_mapping = {}

    # Use config-based paths (works in both local and HF Space environments)
    forward_path, inverse_path = get_mapping_paths("subset_self")
    label_mapping, label_inverse_mapping = load_mappings(forward_path, inverse_path)
    label_counter = 0


    max_x = 212
    max_y = 216
    max_z = 528

    for line in lines:
        if line.startswith('1'):  # 只处理零件数据行
            parts = line.split()  # 按空格分割每一列数据
            # if len(parts) != 15:  # 检查是否每行都有15个部分 #这里也有问题
            #     print(f"Skipping line due to unexpected length: {line.strip()}")
            #     continue  # 如果数据不完整，则跳过该行

            color = int(parts[1])  # 颜色
            x, y, z = round(float(parts[2])), round(float(parts[3])), round(float(parts[4]))
            rx = list(map(float, parts[5:8]))  # 旋转矩阵第一行
            ry = list(map(float, parts[8:11]))  # 旋转矩阵第二行
            rz = list(map(float, parts[11:14]))  # 旋转矩阵第三行
            filename = parts[14]  # 文件名

            all_coords.append([x, y, z])
            all_colors.append(color)

            if ".DAT" in filename:
                filename = filename.replace(".DAT", ".dat")
            if filename not in label_mapping:
#                 import ipdb; ipdb.set_trace()
                label_mapping[filename] = label_counter
                label_inverse_mapping[label_counter] = filename
                label_counter += 1
            all_labels.append(label_mapping[filename])

            rotation_matrix = np.array([rx + ry + rz]).reshape(3, 3)
            # r = R.from_matrix(rotation_matrix)
            # quaternion = r.as_quat()

            rotation_onehot, _ = rot_to_onehot24(rotation_matrix)
            #data.append([color, x, y, z] + rotation_onehot.tolist())
            #data.append([x, y, z] + rotation_onehot.tolist())
            data.append(rotation_onehot.tolist())
            #data.append([x, y, z] + quaternion.tolist())
            filenames.append(filename)

    all_coords = np.array(all_coords)

    # min_vals = np.min(all_coords, axis=0)  # 每个坐标轴的最小值
    # max_vals = np.max(all_coords, axis=0)  # 每个坐标轴的最大值

    # print(max_vals, min_vals)
    # normalized_coords = (all_coords - min_vals) / (max_vals - min_vals)
    
    # normalized_coords = 2 * normalized_coords - 1
    # for i, entry in enumerate(data):
    #     entry[0:3] = normalized_coords[i]  # 更新 x, y, z 坐标

    one_hot_x = np.eye(max_x+1)[all_coords[:, 0].astype(int)]
    one_hot_y = np.eye(max_y+1)[all_coords[:, 1].astype(int)]
    one_hot_z = np.eye(max_z+1)[all_coords[:, 2].astype(int)]

    for i, entry in enumerate(data):
        #entry.append(normalized_labels[i])  # 添加标准化标签到数据中
        entry.extend(np.concatenate([one_hot_x[i], one_hot_y[i], one_hot_z[i]]))  # Using numpy to concatenate
    # color_min = np.min(all_colors)
    # color_max = np.max(all_colors)
    # normalized_colors = (np.array(all_colors) - color_min) / (color_max - color_min)

    # 更新数据：将每个零件的颜色替换为标准化后的颜色
    # for i, entry in enumerate(data):
    #     entry[0] = normalized_colors[i]  # 更新颜色

    if label_mapping is None:
        label_mapping = {filename: idx for idx, filename in enumerate(sorted(set(all_labels)))}
    else:
        label_mapping = label_mapping

    #all_labels = [label_mapping[label] for label in all_labels]
    #label_min = np.min(all_labels)  # 获取标签的最小值
    #label_max = np.max(all_labels)  # 获取标签的最大值
    label_max = len(label_mapping)   # 获取标签的最大值

    # 将标签标准化到 [0, 1] 范围
    #normalized_labels = (all_labels - label_min) / (label_max - label_min)
    one_hot_labels = np.eye(label_max)[all_labels]


    # 更新数据：将每个零件的标签替换为标准化后的标签
    for i, entry in enumerate(data):
        #entry.append(normalized_labels[i])  # 添加标准化标签到数据中
        entry.extend(one_hot_labels[i])  # 添加one-hot编码标签到数据中
    
    for i, entry in enumerate(data):
        #entry.append(normalized_labels[i])  # 添加标准化标签到数据中
        entry.extend([1,0])  # 
    #import ipdb; ipdb.set_trace()  
    return np.array(data), label_inverse_mapping  # 将数据转换为NumPy数组

def process_ldr_flatten(lines):
    data = []
    filenames = []

    all_coords = []
    all_colors = []
    all_labels = []
    label_mapping = {}
    label_inverse_mapping = {}

    # Use config-based paths (works in both local and HF Space environments)
    forward_path, inverse_path = get_mapping_paths("subset_1k")
    label_mapping, label_inverse_mapping = load_mappings(forward_path, inverse_path)
    label_counter = 0


    max_x = 250
    max_y = 214
    max_z = 524

    #print(lines)
    for line in lines:
        if line.startswith('1'):  
            parts = line.split()  
            #if len(parts) != 15:  
            # if len(parts) < 15:  
            #     print(f"Skipping line due to unexpected length: {line.strip()}")
            #     continue  
            #print(parts)
            color = int(parts[1])  
            x, y, z = round(float(parts[2])), round(float(parts[3])), round(float(parts[4]))
            rx = list(map(float, parts[5:8]))  
            ry = list(map(float, parts[8:11])) 
            rz = list(map(float, parts[11:14]))  
            filename = parts[14].lower()  

            all_coords.append([x, y, z])
            all_colors.append(color)

            if ".DAT" in filename:
                filename = filename.replace(".DAT", ".dat")
            if filename not in label_mapping:
#                 import ipdb; ipdb.set_trace()
                label_mapping[filename] = label_counter
                label_inverse_mapping[label_counter] = filename
                label_counter += 1
            all_labels.append(label_mapping[filename])

            rotation_matrix = np.array([rx + ry + rz]).reshape(3, 3)
            # r = R.from_matrix(rotation_matrix)
            # quaternion = r.as_quat()

            rotation_onehot, _ = rot_to_onehot24(rotation_matrix)
            rotation_id = rotation_onehot.argmax()
            #data.append([color, x, y, z] + rotation_onehot.tolist())
            #data.append([x, y, z] + rotation_onehot.tolist())
            #data.append(rotation_onehot.tolist())
            data.append([rotation_id])
            #data.append([x, y, z] + quaternion.tolist())
            filenames.append(filename)

    all_coords = np.array(all_coords)

    # min_vals = np.min(all_coords, axis=0)  
    # max_vals = np.max(all_coords, axis=0)  

    # print(max_vals, min_vals)
    # normalized_coords = (all_coords - min_vals) / (max_vals - min_vals)
    
    # normalized_coords = 2 * normalized_coords - 1
    # for i, entry in enumerate(data):
    #     entry[0:3] = normalized_coords[i]  

    #print(all_coords)
    one_hot_x = np.eye(max_x+1)[all_coords[:, 0].astype(int)]
    one_hot_y = np.eye(max_y+1)[all_coords[:, 1].astype(int)]
    one_hot_z = np.eye(max_z+1)[all_coords[:, 2].astype(int)]

    # for i, entry in enumerate(data):
    #     #entry.append(normalized_labels[i])  
    #     entry.extend(np.concatenate([one_hot_x[i], one_hot_y[i], one_hot_z[i]]))  # Using numpy to concatenate
    # color_min = np.min(all_colors)
    # color_max = np.max(all_colors)
    # normalized_colors = (np.array(all_colors) - color_min) / (color_max - color_min)

    # for i, entry in enumerate(data):
    #     entry[0] = normalized_colors[i]  

    if label_mapping is None:
        label_mapping = {filename: idx for idx, filename in enumerate(sorted(set(all_labels)))}
    else:
        label_mapping = label_mapping

    #all_labels = [label_mapping[label] for label in all_labels]
    #label_min = np.min(all_labels)  
    #label_max = np.max(all_labels)  
    label_max = len(label_mapping)   

    # 将标签标准化到 [0, 1] 范围
    #normalized_labels = (all_labels - label_min) / (label_max - label_min)
    one_hot_labels = np.eye(label_max)[all_labels]

    for i, entry in enumerate(data):
        #entry.append(normalized_labels[i])  # 
        #entry.extend(one_hot_labels[i])  # 

        entry.extend([all_labels[i]])  #
        entry.extend(np.concatenate([
            np.array([all_coords[i, 0].astype(int)]),
            np.array([all_coords[i, 1].astype(int)]),
            np.array([all_coords[i, 2].astype(int)])
        ]))
    
    for i, entry in enumerate(data):
        #entry.append(normalized_labels[i])  
        entry.extend([1,0])  # 
    #import ipdb; ipdb.set_trace()  
    return np.array(data), label_inverse_mapping  

def process_ldr_flatten_bottom(lines):
    data = []
    filenames = []

    all_coords = []
    all_colors = []
    all_labels = []
    label_mapping = {}
    label_inverse_mapping = {}  

    label_mapping, label_inverse_mapping = load_mappings('/public/home/wangshuo/gap/assembly/data/car_1k/subset_bottom_300/label_mapping.json', '/public/home/wangshuo/gap/assembly/data/car_1k/subset_bottom_300/label_inverse_mapping.json')
    label_counter = 0


    max_x = 212
    max_y = 72
    max_z = 410

    for line in lines:
        if line.startswith('1'):  
            parts = line.split()  
            # if len(parts) != 15:  
            #     print(f"Skipping line due to unexpected length: {line.strip()}")
            #     continue  

            color = int(parts[1])  
            x, y, z = round(float(parts[2])), round(float(parts[3])), round(float(parts[4]))
            rx = list(map(float, parts[5:8]))  
            ry = list(map(float, parts[8:11])) 
            rz = list(map(float, parts[11:14]))  
            filename = parts[14].lower()  

            all_coords.append([x, y, z])
            all_colors.append(color)

            if ".DAT" in filename:
                filename = filename.replace(".DAT", ".dat")
            if filename not in label_mapping:
#                 import ipdb; ipdb.set_trace()
                label_mapping[filename] = label_counter
                label_inverse_mapping[label_counter] = filename
                label_counter += 1
            all_labels.append(label_mapping[filename])

            rotation_matrix = np.array([rx + ry + rz]).reshape(3, 3)
            # r = R.from_matrix(rotation_matrix)
            # quaternion = r.as_quat()

            rotation_onehot, _ = rot_to_onehot24(rotation_matrix)
            rotation_id = rotation_onehot.argmax()
            #data.append([color, x, y, z] + rotation_onehot.tolist())
            #data.append([x, y, z] + rotation_onehot.tolist())
            #data.append(rotation_onehot.tolist())
            data.append([rotation_id])
            #data.append([x, y, z] + quaternion.tolist())
            filenames.append(filename)

    all_coords = np.array(all_coords)

    # min_vals = np.min(all_coords, axis=0)  
    # max_vals = np.max(all_coords, axis=0)  

    # print(max_vals, min_vals)
    # normalized_coords = (all_coords - min_vals) / (max_vals - min_vals)
    
    # normalized_coords = 2 * normalized_coords - 1
    # for i, entry in enumerate(data):
    #     entry[0:3] = normalized_coords[i]  

    one_hot_x = np.eye(max_x+1)[all_coords[:, 0].astype(int)]
    one_hot_y = np.eye(max_y+1)[all_coords[:, 1].astype(int)]
    one_hot_z = np.eye(max_z+1)[all_coords[:, 2].astype(int)]

    # for i, entry in enumerate(data):
    #     #entry.append(normalized_labels[i])  
    #     entry.extend(np.concatenate([one_hot_x[i], one_hot_y[i], one_hot_z[i]]))  # Using numpy to concatenate
    # color_min = np.min(all_colors)
    # color_max = np.max(all_colors)
    # normalized_colors = (np.array(all_colors) - color_min) / (color_max - color_min)

    # for i, entry in enumerate(data):
    #     entry[0] = normalized_colors[i]  

    if label_mapping is None:
        label_mapping = {filename: idx for idx, filename in enumerate(sorted(set(all_labels)))}
    else:
        label_mapping = label_mapping

    #all_labels = [label_mapping[label] for label in all_labels]
    #label_min = np.min(all_labels)  
    #label_max = np.max(all_labels)  
    label_max = len(label_mapping)   

    # 将标签标准化到 [0, 1] 范围
    #normalized_labels = (all_labels - label_min) / (label_max - label_min)
    one_hot_labels = np.eye(label_max)[all_labels]

    for i, entry in enumerate(data):
        #entry.append(normalized_labels[i])  # 
        #entry.extend(one_hot_labels[i])  # 

        entry.extend([all_labels[i]])  #
        entry.extend(np.concatenate([
            np.array([all_coords[i, 0].astype(int)]),
            np.array([all_coords[i, 1].astype(int)]),
            np.array([all_coords[i, 2].astype(int)])
        ]))
    
    for i, entry in enumerate(data):
        #entry.append(normalized_labels[i])  
        entry.extend([1,0])  # 
    #import ipdb; ipdb.set_trace()  
    return np.array(data), label_inverse_mapping  


def save_data_as_npy(data, output_file):
    np.save(output_file, data)


def logits2ldr(normalized_data, label_inverse_mapping=None, max_vals=None, min_vals=None, label_max=None, label_min=None, max_color=None, min_color=None, output_file='restored_data.ldr'):
    dat_num = 604
    x_num = 213
    y_num = 217
    z_num = 529
    rot_num = 24

    x = x_num
    xy = x_num + y_num + rot_num
    xyz = x_num + y_num + z_num + rot_num
    
    # Use config-based paths (works in both local and HF Space environments)
    forward_path, inverse_path = get_mapping_paths("subset_self")
    label_mapping, label_inverse_mapping = load_mappings(forward_path, inverse_path)

    if label_inverse_mapping is None:
#         import ipdb; ipdb.set_trace()
    #     #label_inverse_mapping = {0: '98281.dat', 1: '3005.dat', 2: '3004.dat', 3: '3795.dat', 4: '3020.dat', 5: '3710.dat', 6: '3666.dat', 7: '3021.dat', 8: '2431.dat', 9: '4488.dat', 10: '3829a.dat', 11: '3829b.dat', 12: '43723.dat', 13: '3068b.dat', 14: '43722.dat', 15: '3832.dat', 16: '2432.dat', 17: '2437.dat', 18: '6231.dat', 19: '3040b.dat', 20: '3024.dat', 21: '11211.dat', 22: '2540.dat', 23: '61678.dat', 24: '3665.dat', 25: '11477.dat', 26: '93594.dat', 27: '50951.dat', 28: '4073.dat', 29: '6019.dat', 30: '6091.dat', 31: '3821.dat', 32: '3822.dat', 33: '98138.dat', 34: '3794a.dat', 35: '4081b.dat', 36: '3022.dat', 37: '30039.dat', 38: '50946.dat', 39: '4095.dat'} #blue_classic_car
        label_inverse_mapping = {0: '24308b.dat', 1: '3031.dat', 2: '4079.dat', 3: '3021.dat', 4: '3024.dat', 5: '3020.dat', 6: '29120.dat', 7: '71076a.dat', 8: '3023.dat', 9: '29119.dat', 10: '2412b.dat', 11: '86876.dat', 12: '11211.dat', 13: '87087.dat', 14: '3004.dat', 15: '15068.dat', 16: '3829c01.dat', 17: '11477.dat', 18: '79393.dat', 19: '63864.dat', 20: '3710.dat', 21: 'm17f5892b_2023521_010804.dat', 22: '6141.dat', 23: '85984pc2.dat', 24: '3010.dat', 25: '30414.dat', 26: '2431pt0.dat'}
    

    normalized_labels = normalized_data[:, xyz:xyz+dat_num].argmax(1)
    #normalized_colors = normalized_data[:, 0]  # 颜色列

    normalized_coords_x = normalized_data[:, rot_num:rot_num+x].argmax(1)
    normalized_coords_y = normalized_data[:, rot_num+x:xy].argmax(1)  
    normalized_coords_z = normalized_data[:, xy:xyz].argmax(1)  

    restored_coords = np.stack((normalized_coords_x, normalized_coords_y, normalized_coords_z), axis=-1)
    #import ipdb; ipdb.set_trace()
    #restored_coords = ((normalized_coords + 1) / 2) * (max_vals - min_vals) + min_vals  

    #restored_labels = (normalized_labels * (label_max - label_min)) + label_min  

    #restored_colors = normalized_colors * (max_color - min_color) + min_color
    flag = normalized_data[:, xyz+dat_num:xyz+dat_num+2].argmax(1)
    ldr_lines = []

    for i, entry in enumerate(normalized_data):
        color = 0 #int(restored_colors[i])
        x, y, z = restored_coords[i]
        label = label_inverse_mapping[str(np.clip(np.round(normalized_labels[i]), 0, dat_num).astype(int))]

        # quaternion = entry[4:8]  #
        # quaternion = quaternion / np.linalg.norm(quaternion)  # 
        # r = R.from_quat(quaternion)
        rotation_matrix = onehot24_to_rot(entry[:rot_num])#r.as_matrix()
        f = 1 - flag[i]
        ldr_line = f"{f} {color} {x:.6f} {y:.6f} {z:.6f} " \
                   f"{rotation_matrix[0, 0]:.6f} {rotation_matrix[0, 1]:.6f} {rotation_matrix[0, 2]:.6f} " \
                   f"{rotation_matrix[1, 0]:.6f} {rotation_matrix[1, 1]:.6f} {rotation_matrix[1, 2]:.6f} " \
                   f"{rotation_matrix[2, 0]:.6f} {rotation_matrix[2, 1]:.6f} {rotation_matrix[2, 2]:.6f} " \
                   f"{label}\n"

        ldr_lines.append(ldr_line)

    with open(output_file, 'w') as f:
        f.writelines(ldr_lines)
    print(f"Restored LDR data saved to {output_file}")

    return ldr_lines

def logits2ldrot(normalized_data, input_data, label_inverse_mapping='', max_vals='', min_vals='', label_max='', label_min='', max_color='', min_color='', output_file='restored_data_rot_wop.ldr'):
    dat_num = 604
    x_num = 213
    y_num = 217
    z_num = 529
    rot_num = 24

    x = x_num
    xy = x_num + y_num + rot_num
    xyz = x_num + y_num + z_num + rot_num
    
    # Use config-based paths (works in both local and HF Space environments)
    forward_path, inverse_path = get_mapping_paths("subset_self")
    label_mapping, label_inverse_mapping = load_mappings(forward_path, inverse_path)

    if label_inverse_mapping is None:
#         import ipdb; ipdb.set_trace()
    #     #label_inverse_mapping = {0: '98281.dat', 1: '3005.dat', 2: '3004.dat', 3: '3795.dat', 4: '3020.dat', 5: '3710.dat', 6: '3666.dat', 7: '3021.dat', 8: '2431.dat', 9: '4488.dat', 10: '3829a.dat', 11: '3829b.dat', 12: '43723.dat', 13: '3068b.dat', 14: '43722.dat', 15: '3832.dat', 16: '2432.dat', 17: '2437.dat', 18: '6231.dat', 19: '3040b.dat', 20: '3024.dat', 21: '11211.dat', 22: '2540.dat', 23: '61678.dat', 24: '3665.dat', 25: '11477.dat', 26: '93594.dat', 27: '50951.dat', 28: '4073.dat', 29: '6019.dat', 30: '6091.dat', 31: '3821.dat', 32: '3822.dat', 33: '98138.dat', 34: '3794a.dat', 35: '4081b.dat', 36: '3022.dat', 37: '30039.dat', 38: '50946.dat', 39: '4095.dat'} #blue_classic_car
        label_inverse_mapping = {0: '24308b.dat', 1: '3031.dat', 2: '4079.dat', 3: '3021.dat', 4: '3024.dat', 5: '3020.dat', 6: '29120.dat', 7: '71076a.dat', 8: '3023.dat', 9: '29119.dat', 10: '2412b.dat', 11: '86876.dat', 12: '11211.dat', 13: '87087.dat', 14: '3004.dat', 15: '15068.dat', 16: '3829c01.dat', 17: '11477.dat', 18: '79393.dat', 19: '63864.dat', 20: '3710.dat', 21: 'm17f5892b_2023521_010804.dat', 22: '6141.dat', 23: '85984pc2.dat', 24: '3010.dat', 25: '30414.dat', 26: '2431pt0.dat'}
    

    input_labels = input_data[:, xyz:xyz+dat_num].argmax(1)

    input_coords_x = input_data[:, rot_num:rot_num+x].argmax(1)
    input_coords_y = input_data[:, rot_num+x:xy].argmax(1)  
    input_coords_z = input_data[:, xy:xyz].argmax(1)  

    restored_coords = np.stack((input_coords_x, input_coords_y, input_coords_z), axis=-1)
    #flag = normalized_data[:, xyz+dat_num:xyz+dat_num+2].argmax(1)
    flag = normalized_data[:, -2:].argmax(1)
    ldr_lines = []

    for i, entry in enumerate(normalized_data[:-1]):
        color = 0 #int(restored_colors[i])
        x, y, z = restored_coords[i]
        label = label_inverse_mapping[str(np.clip(np.round(input_labels[i]), 0, dat_num).astype(int))]

        # quaternion = entry[4:8]  #
        # quaternion = quaternion / np.linalg.norm(quaternion)  # 
        # r = R.from_quat(quaternion)
        rotation_matrix = onehot24_to_rot(entry[:rot_num])#r.as_matrix()
        f = 1 - flag[i]
        ldr_line = f"{f} {color} {x:.6f} {y:.6f} {z:.6f} " \
                   f"{rotation_matrix[0, 0]:.6f} {rotation_matrix[0, 1]:.6f} {rotation_matrix[0, 2]:.6f} " \
                   f"{rotation_matrix[1, 0]:.6f} {rotation_matrix[1, 1]:.6f} {rotation_matrix[1, 2]:.6f} " \
                   f"{rotation_matrix[2, 0]:.6f} {rotation_matrix[2, 1]:.6f} {rotation_matrix[2, 2]:.6f} " \
                   f"{label}\n"

        ldr_lines.append(ldr_line)

    with open(output_file, 'w') as f:
        f.writelines(ldr_lines)
    print(f"Restored LDR data saved to {output_file}")

    return ldr_lines

def logits2ldrp(normalized_data, input_data, label_inverse_mapping='', max_vals='', min_vals='', label_max='', label_min='', max_color='', min_color='', output_file='restored_data_rot_wop.ldr'):
    dat_num = 604
    x_num = 213
    y_num = 217
    z_num = 529
    rot_num = 24

    x = x_num
    xy = x_num + y_num + rot_num
    xyz = x_num + y_num + z_num + rot_num
    
    # Use config-based paths (works in both local and HF Space environments)
    forward_path, inverse_path = get_mapping_paths("subset_self")
    label_mapping, label_inverse_mapping = load_mappings(forward_path, inverse_path)

    if label_inverse_mapping is None:
#         import ipdb; ipdb.set_trace()
    #     #label_inverse_mapping = {0: '98281.dat', 1: '3005.dat', 2: '3004.dat', 3: '3795.dat', 4: '3020.dat', 5: '3710.dat', 6: '3666.dat', 7: '3021.dat', 8: '2431.dat', 9: '4488.dat', 10: '3829a.dat', 11: '3829b.dat', 12: '43723.dat', 13: '3068b.dat', 14: '43722.dat', 15: '3832.dat', 16: '2432.dat', 17: '2437.dat', 18: '6231.dat', 19: '3040b.dat', 20: '3024.dat', 21: '11211.dat', 22: '2540.dat', 23: '61678.dat', 24: '3665.dat', 25: '11477.dat', 26: '93594.dat', 27: '50951.dat', 28: '4073.dat', 29: '6019.dat', 30: '6091.dat', 31: '3821.dat', 32: '3822.dat', 33: '98138.dat', 34: '3794a.dat', 35: '4081b.dat', 36: '3022.dat', 37: '30039.dat', 38: '50946.dat', 39: '4095.dat'} #blue_classic_car
        label_inverse_mapping = {0: '24308b.dat', 1: '3031.dat', 2: '4079.dat', 3: '3021.dat', 4: '3024.dat', 5: '3020.dat', 6: '29120.dat', 7: '71076a.dat', 8: '3023.dat', 9: '29119.dat', 10: '2412b.dat', 11: '86876.dat', 12: '11211.dat', 13: '87087.dat', 14: '3004.dat', 15: '15068.dat', 16: '3829c01.dat', 17: '11477.dat', 18: '79393.dat', 19: '63864.dat', 20: '3710.dat', 21: 'm17f5892b_2023521_010804.dat', 22: '6141.dat', 23: '85984pc2.dat', 24: '3010.dat', 25: '30414.dat', 26: '2431pt0.dat'}
    

    input_labels = input_data[:, xyz:xyz+dat_num].argmax(1)

    # input_coords_x = input_data[:, rot_num:rot_num+x].argmax(1)
    # input_coords_y = input_data[:, rot_num+x:xy].argmax(1)  
    # input_coords_z = input_data[:, xy:xyz].argmax(1)  

    input_coords_x = normalized_data[:, rot_num:rot_num+x].argmax(1)
    input_coords_y = normalized_data[:, rot_num+x:xy].argmax(1)  
    input_coords_z = normalized_data[:, xy:xyz].argmax(1)  

    restored_coords = np.stack((input_coords_x, input_coords_y, input_coords_z), axis=-1)
    #flag = normalized_data[:, xyz+dat_num:xyz+dat_num+2].argmax(1)
    flag = normalized_data[:, -2:].argmax(1)
    ldr_lines = []
    #for i, entry in enumerate(normalized_data[:-1]):
    for i, entry in enumerate(input_data[:-1]):
        color = 0 #int(restored_colors[i])
        x, y, z = restored_coords[i]
        label = label_inverse_mapping[str(np.clip(np.round(input_labels[i]), 0, dat_num).astype(int))]

        # quaternion = entry[4:8]  #
        # quaternion = quaternion / np.linalg.norm(quaternion)  # 
        # r = R.from_quat(quaternion)
        rotation_matrix = onehot24_to_rot(entry[:rot_num])#r.as_matrix()
        f = 1# - flag[i]
        ldr_line = f"{f} {color} {x:.6f} {y:.6f} {z:.6f} " \
                   f"{rotation_matrix[0, 0]:.6f} {rotation_matrix[0, 1]:.6f} {rotation_matrix[0, 2]:.6f} " \
                   f"{rotation_matrix[1, 0]:.6f} {rotation_matrix[1, 1]:.6f} {rotation_matrix[1, 2]:.6f} " \
                   f"{rotation_matrix[2, 0]:.6f} {rotation_matrix[2, 1]:.6f} {rotation_matrix[2, 2]:.6f} " \
                   f"{label}\n"

        ldr_lines.append(ldr_line)

    with open(output_file, 'w') as f:
        f.writelines(ldr_lines)
    print(f"Restored LDR data saved to {output_file}")

    return ldr_lines

def logits2flatldrp(normalized_data, input_data, label_inverse_mapping='', max_vals='', min_vals='', label_max='', label_min='', max_color='', min_color='', output_file='restored_data_rot_wop.ldr'):
    dat_num = 604
    x_num = 213
    y_num = 217
    z_num = 529
    rot_num = 24

    R24 = signed_perm_mats_det_plus_1()

    x = x_num
    xy = x_num + y_num + rot_num
    xyz = x_num + y_num + z_num + rot_num
    
    stride = 3  
    # Use config-based paths (works in both local and HF Space environments)
    forward_path, inverse_path = get_mapping_paths("subset_self")
    label_mapping, label_inverse_mapping = load_mappings(forward_path, inverse_path)

    if label_inverse_mapping is None:
#         import ipdb; ipdb.set_trace()
    #     #label_inverse_mapping = {0: '98281.dat', 1: '3005.dat', 2: '3004.dat', 3: '3795.dat', 4: '3020.dat', 5: '3710.dat', 6: '3666.dat', 7: '3021.dat', 8: '2431.dat', 9: '4488.dat', 10: '3829a.dat', 11: '3829b.dat', 12: '43723.dat', 13: '3068b.dat', 14: '43722.dat', 15: '3832.dat', 16: '2432.dat', 17: '2437.dat', 18: '6231.dat', 19: '3040b.dat', 20: '3024.dat', 21: '11211.dat', 22: '2540.dat', 23: '61678.dat', 24: '3665.dat', 25: '11477.dat', 26: '93594.dat', 27: '50951.dat', 28: '4073.dat', 29: '6019.dat', 30: '6091.dat', 31: '3821.dat', 32: '3822.dat', 33: '98138.dat', 34: '3794a.dat', 35: '4081b.dat', 36: '3022.dat', 37: '30039.dat', 38: '50946.dat', 39: '4095.dat'} #blue_classic_car
        label_inverse_mapping = {0: '24308b.dat', 1: '3031.dat', 2: '4079.dat', 3: '3021.dat', 4: '3024.dat', 5: '3020.dat', 6: '29120.dat', 7: '71076a.dat', 8: '3023.dat', 9: '29119.dat', 10: '2412b.dat', 11: '86876.dat', 12: '11211.dat', 13: '87087.dat', 14: '3004.dat', 15: '15068.dat', 16: '3829c01.dat', 17: '11477.dat', 18: '79393.dat', 19: '63864.dat', 20: '3710.dat', 21: 'm17f5892b_2023521_010804.dat', 22: '6141.dat', 23: '85984pc2.dat', 24: '3010.dat', 25: '30414.dat', 26: '2431pt0.dat'}
    

    input_labels = input_data[:, -6] 

    input_coords_x = input_data[:, -5]  #normalized_data[1:-2:stride, :x_num+1].argmax(1)
    input_coords_y = input_data[:, -4] #normalized_data[0:-3:stride, :y_num+1].argmax(1)  
    input_coords_z = input_data[:, -3] #normalized_data[2:-1:stride, :z_num+1].argmax(1)  

    restored_coords = np.stack((input_coords_x, input_coords_y, input_coords_z), axis=-1)
    #flag = normalized_data[:, xyz+dat_num:xyz+dat_num+2].argmax(1)
    #flag = normalized_data[:, -2:].argmax(1)
    ldr_lines = []
    #for i, entry in enumerate(normalized_data[:-1]):
    for i, entry in enumerate(input_data[:-1]):
        color = 0 #int(restored_colors[i])
        x, y, z = restored_coords[i]
        label = label_inverse_mapping[str(np.clip(np.round(input_labels[i]), 0, dat_num).astype(int))]

        # quaternion = entry[4:8]  #
        # quaternion = quaternion / np.linalg.norm(quaternion)  # 
        # r = R.from_quat(quaternion)
        #import ipdb; ipdb.set_trace()
        rotation_matrix = R24[entry[-7]]#r.as_matrix()
        f = 1# - flag[i]
        ldr_line = f"{f} {color} {x:.6f} {y:.6f} {z:.6f} " \
                   f"{rotation_matrix[0, 0]:.6f} {rotation_matrix[0, 1]:.6f} {rotation_matrix[0, 2]:.6f} " \
                   f"{rotation_matrix[1, 0]:.6f} {rotation_matrix[1, 1]:.6f} {rotation_matrix[1, 2]:.6f} " \
                   f"{rotation_matrix[2, 0]:.6f} {rotation_matrix[2, 1]:.6f} {rotation_matrix[2, 2]:.6f} " \
                   f"{label}\n"

        ldr_lines.append(ldr_line)

    with open(output_file, 'w') as f:
        f.writelines(ldr_lines)
    print(f"Restored LDR data saved to {output_file}")

    return ldr_lines

def logits2flatldrpr(normalized_data, input_data, stride, given, label_inverse_mapping='', max_vals='', min_vals='', label_max='', label_min='', max_color='', min_color='', output_file='restored_data_rot_wop.ldr'):
    dat_num = 604
    x_num = 213
    y_num = 217
    z_num = 529
    rot_num = 24

    R24 = signed_perm_mats_det_plus_1()

    x = x_num
    xy = x_num + y_num + rot_num
    xyz = x_num + y_num + z_num + rot_num
    
    stride = stride  
    attr_shift = stride-3 #+1 for bert
    bert_shift = 1
    # Use config-based paths (works in both local and HF Space environments)
    forward_path, inverse_path = get_mapping_paths("subset_self")
    label_mapping, label_inverse_mapping = load_mappings(forward_path, inverse_path)

    if label_inverse_mapping is None:
#         import ipdb; ipdb.set_trace()
    #     #label_inverse_mapping = {0: '98281.dat', 1: '3005.dat', 2: '3004.dat', 3: '3795.dat', 4: '3020.dat', 5: '3710.dat', 6: '3666.dat', 7: '3021.dat', 8: '2431.dat', 9: '4488.dat', 10: '3829a.dat', 11: '3829b.dat', 12: '43723.dat', 13: '3068b.dat', 14: '43722.dat', 15: '3832.dat', 16: '2432.dat', 17: '2437.dat', 18: '6231.dat', 19: '3040b.dat', 20: '3024.dat', 21: '11211.dat', 22: '2540.dat', 23: '61678.dat', 24: '3665.dat', 25: '11477.dat', 26: '93594.dat', 27: '50951.dat', 28: '4073.dat', 29: '6019.dat', 30: '6091.dat', 31: '3821.dat', 32: '3822.dat', 33: '98138.dat', 34: '3794a.dat', 35: '4081b.dat', 36: '3022.dat', 37: '30039.dat', 38: '50946.dat', 39: '4095.dat'} #blue_classic_car
        label_inverse_mapping = {0: '24308b.dat', 1: '3031.dat', 2: '4079.dat', 3: '3021.dat', 4: '3024.dat', 5: '3020.dat', 6: '29120.dat', 7: '71076a.dat', 8: '3023.dat', 9: '29119.dat', 10: '2412b.dat', 11: '86876.dat', 12: '11211.dat', 13: '87087.dat', 14: '3004.dat', 15: '15068.dat', 16: '3829c01.dat', 17: '11477.dat', 18: '79393.dat', 19: '63864.dat', 20: '3710.dat', 21: 'm17f5892b_2023521_010804.dat', 22: '6141.dat', 23: '85984pc2.dat', 24: '3010.dat', 25: '30414.dat', 26: '2431pt0.dat'}
    

    #input_labels = normalized_data[0:-4:stride, :dat_num+1].argmax(1) # 
    input_labels = input_data[:, -6]   
    #input_labels[:given] =  input_data[:given, -6] #normalized_data[0:-4:stride, :dat_num+1].argmax(1)
    
    input_rot = normalized_data[1+bert_shift:-3:stride, :rot_num+1].argmax(1)  # #normalized_data[1:-3:stride, :rot_num+1].argmax(1) 
    #input_rot = input_data[:, 0]


    input_coords_x = normalized_data[1+attr_shift+bert_shift:-1:stride, rot_num+1:x+rot_num+1+1].argmax(1)
    input_coords_y = normalized_data[0+attr_shift+bert_shift:-2:stride, x+rot_num+2:xy+3].argmax(1)  
    input_coords_z = normalized_data[2+attr_shift+bert_shift::stride, xy+3:xyz+4].argmax(1)  
    
    # input_coords_x[:given] = input_data[:given, -5]
    # input_coords_y[:given] = input_data[:given, -4]
    # input_coords_z[:given] = input_data[:given, -3]

    restored_coords = np.stack((input_coords_x, input_coords_y, input_coords_z), axis=-1)
    #flag = normalized_data[:, xyz+dat_num:xyz+dat_num+2].argmax(1)
    #flag = normalized_data[:, -2:].argmax(1) 

    input_colors = np.zeros_like(input_data[:, 0])
    #input_colors[:given] = (input_colors[:given] + 4)
    ldr_lines = []
    #for i, entry in enumerate(normalized_data[:-1]):
    for i, entry in enumerate(input_data[:-1]):
        color = int(input_colors[i])
        x, y, z = restored_coords[i]
        label = label_inverse_mapping[str(np.clip(np.round(input_labels[i]), 0, dat_num-1).astype(int))]

        # quaternion = entry[4:8]  #
        # quaternion = quaternion / np.linalg.norm(quaternion)  # 
        # r = R.from_quat(quaternion)

        rotation_matrix = R24[np.clip(input_rot[i], 0, rot_num-1)] #R24[entry[-7]]#r.as_matrix()
        if x>212:
            f = 0# - flag[i]
        else:
            f = 1
        ldr_line = f"{f} {color} {x:.6f} {y:.6f} {z:.6f} " \
                   f"{rotation_matrix[0, 0]:.6f} {rotation_matrix[0, 1]:.6f} {rotation_matrix[0, 2]:.6f} " \
                   f"{rotation_matrix[1, 0]:.6f} {rotation_matrix[1, 1]:.6f} {rotation_matrix[1, 2]:.6f} " \
                   f"{rotation_matrix[2, 0]:.6f} {rotation_matrix[2, 1]:.6f} {rotation_matrix[2, 2]:.6f} " \
                   f"{label}\n"

        ldr_lines.append(ldr_line)

    with open(output_file, 'w') as f:
        f.writelines(ldr_lines)
    print(f"Restored LDR data saved to {output_file}")

    return ldr_lines

# def logits2botldrpr(normalized_data, input_data, stride, given, label_inverse_mapping='', max_vals='', min_vals='', label_max='', label_min='', max_color='', min_color='', output_file='restored_data_rot_wop.ldr'):
#     dat_num = 286
#     x_num = 213
#     y_num = 73
#     z_num = 411
#     rot_num = 24

#     R24 = signed_perm_mats_det_plus_1()

#     x = x_num
#     xy = x_num + y_num + rot_num
#     xyz = x_num + y_num + z_num + rot_num
    
#     stride = stride  
#     attr_shift = stride-3 #+1 for bert
#     bert_shift = 1
#     label_mapping, label_inverse_mapping = load_mappings('../data/car_1k/subset_bottom_300/label_mapping.json', '../data/car_1k/subset_bottom_300/label_inverse_mapping.json')

#     if label_inverse_mapping is None:
#         import ipdb; ipdb.set_trace()
#     #     #label_inverse_mapping = {0: '98281.dat', 1: '3005.dat', 2: '3004.dat', 3: '3795.dat', 4: '3020.dat', 5: '3710.dat', 6: '3666.dat', 7: '3021.dat', 8: '2431.dat', 9: '4488.dat', 10: '3829a.dat', 11: '3829b.dat', 12: '43723.dat', 13: '3068b.dat', 14: '43722.dat', 15: '3832.dat', 16: '2432.dat', 17: '2437.dat', 18: '6231.dat', 19: '3040b.dat', 20: '3024.dat', 21: '11211.dat', 22: '2540.dat', 23: '61678.dat', 24: '3665.dat', 25: '11477.dat', 26: '93594.dat', 27: '50951.dat', 28: '4073.dat', 29: '6019.dat', 30: '6091.dat', 31: '3821.dat', 32: '3822.dat', 33: '98138.dat', 34: '3794a.dat', 35: '4081b.dat', 36: '3022.dat', 37: '30039.dat', 38: '50946.dat', 39: '4095.dat'} #blue_classic_car
#         label_inverse_mapping = {0: '24308b.dat', 1: '3031.dat', 2: '4079.dat', 3: '3021.dat', 4: '3024.dat', 5: '3020.dat', 6: '29120.dat', 7: '71076a.dat', 8: '3023.dat', 9: '29119.dat', 10: '2412b.dat', 11: '86876.dat', 12: '11211.dat', 13: '87087.dat', 14: '3004.dat', 15: '15068.dat', 16: '3829c01.dat', 17: '11477.dat', 18: '79393.dat', 19: '63864.dat', 20: '3710.dat', 21: 'm17f5892b_2023521_010804.dat', 22: '6141.dat', 23: '85984pc2.dat', 24: '3010.dat', 25: '30414.dat', 26: '2431pt0.dat'}
    

#     #input_labels = normalized_data[0:-4:stride, :dat_num+1].argmax(1) # 
#     input_labels = input_data[:, -6]   
#     #input_labels[:given] =  input_data[:given, -6] #normalized_data[0:-4:stride, :dat_num+1].argmax(1)
    

#     input_rot = normalized_data[1+bert_shift:-3:stride, :rot_num+1].argmax(1)  # #normalized_data[1:-3:stride, :rot_num+1].argmax(1) 
#     #input_rot = input_data[:, 0]


#     input_coords_x = normalized_data[1+attr_shift+bert_shift:-1:stride, rot_num+1:x+rot_num+1+1].argmax(1)
#     input_coords_y = normalized_data[0+attr_shift+bert_shift:-2:stride, x+rot_num+2:xy+3].argmax(1)  
#     input_coords_z = normalized_data[2+attr_shift+bert_shift::stride, xy+3:xyz+4].argmax(1)  
    
#     # input_coords_x[:given] = input_data[:given, -5]
#     # input_coords_y[:given] = input_data[:given, -4]
#     # input_coords_z[:given] = input_data[:given, -3]

#     restored_coords = np.stack((input_coords_x, input_coords_y, input_coords_z), axis=-1)
#     #flag = normalized_data[:, xyz+dat_num:xyz+dat_num+2].argmax(1)
#     #flag = normalized_data[:, -2:].argmax(1) 

#     input_colors = np.zeros_like(input_data[:, 0])
#     #input_colors[:given] = (input_colors[:given] + 4)
#     ldr_lines = []
#     #for i, entry in enumerate(normalized_data[:-1]):
#     for i, entry in enumerate(input_data[:-1]):
#         color = int(input_colors[i])
#         x, y, z = restored_coords[i]
#         label = label_inverse_mapping[str(np.clip(np.round(input_labels[i]), 0, dat_num-1).astype(int))]

#         # quaternion = entry[4:8]  #
#         # quaternion = quaternion / np.linalg.norm(quaternion)  # 
#         # r = R.from_quat(quaternion)

#         rotation_matrix = R24[np.clip(input_rot[i], 0, rot_num-1)] #R24[entry[-7]]#r.as_matrix()
#         if x>212:
#             f = 0# - flag[i]
#         else:
#             f = 1
#         ldr_line = f"{f} {color} {x:.6f} {y:.6f} {z:.6f} " \
#                    f"{rotation_matrix[0, 0]:.6f} {rotation_matrix[0, 1]:.6f} {rotation_matrix[0, 2]:.6f} " \
#                    f"{rotation_matrix[1, 0]:.6f} {rotation_matrix[1, 1]:.6f} {rotation_matrix[1, 2]:.6f} " \
#                    f"{rotation_matrix[2, 0]:.6f} {rotation_matrix[2, 1]:.6f} {rotation_matrix[2, 2]:.6f} " \
#                    f"{label}\n"

#         ldr_lines.append(ldr_line)

#     with open(output_file, 'w') as f:
#         f.writelines(ldr_lines)
#     print(f"Restored LDR data saved to {output_file}")

#     return ldr_lines

def logits2botldrpr(normalized_data, input_data, stride, given, label_inverse_mapping='', max_vals='', min_vals='', label_max='', label_min='', max_color='', min_color='', output_file='restored_data_rot_wop.ldr'):
    dat_num = 1217 #286
    x_num = 251 #213
    y_num = 215 #73
    z_num = 525 #411
    rot_num = 24

    R24 = signed_perm_mats_det_plus_1()

    x = x_num
    xy = x_num + y_num + rot_num
    xyz = x_num + y_num + z_num + rot_num
    
    stride = stride
    attr_shift = stride-3 #+1 for bert
    bert_shift = 1

    # Use config-based paths (works in both local and HF Space environments)
    forward_path, inverse_path = get_mapping_paths("subset_1k")
    label_mapping, label_inverse_mapping = load_mappings(forward_path, inverse_path)

    if label_inverse_mapping is None:
#         import ipdb; ipdb.set_trace()
    #     #label_inverse_mapping = {0: '98281.dat', 1: '3005.dat', 2: '3004.dat', 3: '3795.dat', 4: '3020.dat', 5: '3710.dat', 6: '3666.dat', 7: '3021.dat', 8: '2431.dat', 9: '4488.dat', 10: '3829a.dat', 11: '3829b.dat', 12: '43723.dat', 13: '3068b.dat', 14: '43722.dat', 15: '3832.dat', 16: '2432.dat', 17: '2437.dat', 18: '6231.dat', 19: '3040b.dat', 20: '3024.dat', 21: '11211.dat', 22: '2540.dat', 23: '61678.dat', 24: '3665.dat', 25: '11477.dat', 26: '93594.dat', 27: '50951.dat', 28: '4073.dat', 29: '6019.dat', 30: '6091.dat', 31: '3821.dat', 32: '3822.dat', 33: '98138.dat', 34: '3794a.dat', 35: '4081b.dat', 36: '3022.dat', 37: '30039.dat', 38: '50946.dat', 39: '4095.dat'} #blue_classic_car
        label_inverse_mapping = {0: '24308b.dat', 1: '3031.dat', 2: '4079.dat', 3: '3021.dat', 4: '3024.dat', 5: '3020.dat', 6: '29120.dat', 7: '71076a.dat', 8: '3023.dat', 9: '29119.dat', 10: '2412b.dat', 11: '86876.dat', 12: '11211.dat', 13: '87087.dat', 14: '3004.dat', 15: '15068.dat', 16: '3829c01.dat', 17: '11477.dat', 18: '79393.dat', 19: '63864.dat', 20: '3710.dat', 21: 'm17f5892b_2023521_010804.dat', 22: '6141.dat', 23: '85984pc2.dat', 24: '3010.dat', 25: '30414.dat', 26: '2431pt0.dat'}
    

    #input_labels = normalized_data[0:-4:stride, :dat_num+1].argmax(1) # 
    input_labels = input_data[:, -6]   
    #input_labels[:given] =  input_data[:given, -6] #normalized_data[0:-4:stride, :dat_num+1].argmax(1)
    

    input_rot = normalized_data[1+bert_shift:-3:stride, :rot_num+1].argmax(1)  # #normalized_data[1:-3:stride, :rot_num+1].argmax(1) 
    #input_rot = input_data[:, 0]


    input_coords_x = normalized_data[1+attr_shift+bert_shift:-1:stride, rot_num+1:x+rot_num+1+1].argmax(1)
    input_coords_y = normalized_data[0+attr_shift+bert_shift:-2:stride, x+rot_num+2:xy+3].argmax(1)  
    input_coords_z = normalized_data[2+attr_shift+bert_shift::stride, xy+3:xyz+4].argmax(1)  
    
    # input_coords_x[:given] = input_data[:given, -5]
    # input_coords_y[:given] = input_data[:given, -4]
    # input_coords_z[:given] = input_data[:given, -3]

    restored_coords = np.stack((input_coords_x, input_coords_y, input_coords_z), axis=-1)
    #flag = normalized_data[:, xyz+dat_num:xyz+dat_num+2].argmax(1)
    #flag = normalized_data[:, -2:].argmax(1) 

    input_colors = np.zeros_like(input_data[:, 0])
    #input_colors[:given] = (input_colors[:given] + 4)
    ldr_lines = []
    #for i, entry in enumerate(normalized_data[:-1]):
    for i, entry in enumerate(input_data[:-1]):
        color = int(input_colors[i])
        x, y, z = restored_coords[i]
        label = label_inverse_mapping[str(np.clip(np.round(input_labels[i]), 0, dat_num-1).astype(int))]

        # quaternion = entry[4:8]  #
        # quaternion = quaternion / np.linalg.norm(quaternion)  # 
        # r = R.from_quat(quaternion)

        rotation_matrix = R24[np.clip(input_rot[i], 0, rot_num-1)] #R24[entry[-7]]#r.as_matrix()
        if x>(x_num-1):
            f = 0# - flag[i]
        else:
            f = 1
        ldr_line = f"{f} {color} {x:.6f} {y:.6f} {z:.6f} " \
                   f"{rotation_matrix[0, 0]:.6f} {rotation_matrix[0, 1]:.6f} {rotation_matrix[0, 2]:.6f} " \
                   f"{rotation_matrix[1, 0]:.6f} {rotation_matrix[1, 1]:.6f} {rotation_matrix[1, 2]:.6f} " \
                   f"{rotation_matrix[2, 0]:.6f} {rotation_matrix[2, 1]:.6f} {rotation_matrix[2, 2]:.6f} " \
                   f"{label}\n"

        ldr_lines.append(ldr_line)

    with open(output_file, 'w') as f:
        f.writelines(ldr_lines)
    print(f"Restored LDR data saved to {output_file}")

    return ldr_lines

def ids2flatldrpr(normalized_data, input_data, stride, given, label_inverse_mapping='', max_vals='', min_vals='', label_max='', label_min='', max_color='', min_color='', output_file='restored_data_rot_wop.ldr'):
    dat_num = 604
    x_num = 213
    y_num = 217
    z_num = 529
    rot_num = 24

    R24 = signed_perm_mats_det_plus_1()

    x = x_num
    xy = x_num + y_num + rot_num
    xyz = x_num + y_num + z_num + rot_num
    
    stride = stride  
    attr_shift = stride-3
    # Use config-based paths (works in both local and HF Space environments)
    forward_path, inverse_path = get_mapping_paths("subset_self")
    label_mapping, label_inverse_mapping = load_mappings(forward_path, inverse_path)

    if label_inverse_mapping is None:
#         import ipdb; ipdb.set_trace()
    #     #label_inverse_mapping = {0: '98281.dat', 1: '3005.dat', 2: '3004.dat', 3: '3795.dat', 4: '3020.dat', 5: '3710.dat', 6: '3666.dat', 7: '3021.dat', 8: '2431.dat', 9: '4488.dat', 10: '3829a.dat', 11: '3829b.dat', 12: '43723.dat', 13: '3068b.dat', 14: '43722.dat', 15: '3832.dat', 16: '2432.dat', 17: '2437.dat', 18: '6231.dat', 19: '3040b.dat', 20: '3024.dat', 21: '11211.dat', 22: '2540.dat', 23: '61678.dat', 24: '3665.dat', 25: '11477.dat', 26: '93594.dat', 27: '50951.dat', 28: '4073.dat', 29: '6019.dat', 30: '6091.dat', 31: '3821.dat', 32: '3822.dat', 33: '98138.dat', 34: '3794a.dat', 35: '4081b.dat', 36: '3022.dat', 37: '30039.dat', 38: '50946.dat', 39: '4095.dat'} #blue_classic_car
        label_inverse_mapping = {0: '24308b.dat', 1: '3031.dat', 2: '4079.dat', 3: '3021.dat', 4: '3024.dat', 5: '3020.dat', 6: '29120.dat', 7: '71076a.dat', 8: '3023.dat', 9: '29119.dat', 10: '2412b.dat', 11: '86876.dat', 12: '11211.dat', 13: '87087.dat', 14: '3004.dat', 15: '15068.dat', 16: '3829c01.dat', 17: '11477.dat', 18: '79393.dat', 19: '63864.dat', 20: '3710.dat', 21: 'm17f5892b_2023521_010804.dat', 22: '6141.dat', 23: '85984pc2.dat', 24: '3010.dat', 25: '30414.dat', 26: '2431pt0.dat'}
    

    input_labels = normalized_data[0:-4:stride, :dat_num+1] # 
    #input_labels[:given] =  input_data[:given, -6] #normalized_data[0:-4:stride, :dat_num+1].argmax(1)
    
    input_rot = normalized_data[1:-3:stride, :rot_num+1]  #input_data[:, 0] #normalized_data[1:-3:stride, :rot_num+1].argmax(1) 
    #input_rot[:given] = input_data[:given, 0]

    input_coords_x = normalized_data[1+attr_shift:-1:stride, :x_num+1]
    input_coords_y = normalized_data[0+attr_shift:-2:stride, :y_num+1]
    input_coords_z = normalized_data[2+attr_shift::stride, :z_num+1]
    
    # input_coords_x[:given] = input_data[:given, -5]
    # input_coords_y[:given] = input_data[:given, -4]
    # input_coords_z[:given] = input_data[:given, -3]

    restored_coords = np.stack((input_coords_x, input_coords_y, input_coords_z), axis=-1)
    #flag = normalized_data[:, xyz+dat_num:xyz+dat_num+2].argmax(1)
    #flag = normalized_data[:, -2:].argmax(1) 
    
    input_colors = np.zeros_like(input_data[:, 0])
    #input_colors[:given] = (input_colors[:given] + 4)
    ldr_lines = []
    #for i, entry in enumerate(normalized_data[:-1]):
    for i, entry in enumerate(input_data[:-1]):
        color = int(input_colors[i])
        x, y, z = np.squeeze(restored_coords, axis=1)[i]
        label = label_inverse_mapping[str(np.clip(np.round(input_labels[i].item()), 0, dat_num-1).astype(int))]

        # quaternion = entry[4:8]  #
        # quaternion = quaternion / np.linalg.norm(quaternion)  # 
        # r = R.from_quat(quaternion)

        rotation_matrix = R24[int(np.clip(input_rot[i].item(), 0, rot_num-1))] #R24[entry[-7]]#r.as_matrix()
        if x>212:
            f = 0# - flag[i]
        else:
            f = 1
        ldr_line = f"{f} {color} {x:.6f} {y:.6f} {z:.6f} " \
                   f"{rotation_matrix[0, 0]:.6f} {rotation_matrix[0, 1]:.6f} {rotation_matrix[0, 2]:.6f} " \
                   f"{rotation_matrix[1, 0]:.6f} {rotation_matrix[1, 1]:.6f} {rotation_matrix[1, 2]:.6f} " \
                   f"{rotation_matrix[2, 0]:.6f} {rotation_matrix[2, 1]:.6f} {rotation_matrix[2, 2]:.6f} " \
                   f"{label}\n"

        ldr_lines.append(ldr_line)

    with open(output_file, 'w') as f:
        f.writelines(ldr_lines)
    print(f"Restored LDR data saved to {output_file}")

    return ldr_lines

def main(input_file):
    lines = read_ldr_file(input_file)
    processed_data, label_inverse_mapping = process_ldr_data(lines)  # 处理LDR数据
    
    inverted_data = logits2ldr(processed_data, label_inverse_mapping)  # 将标准化数据转换回原始数据格式

#     import ipdb; ipdb.set_trace()
    # output_file = os.path.splitext(input_file)[0] + '_wrdhot' + '.npy'
    
    # save_data_as_npy(processed_data, output_file)  # 保存为.npy文件
    # print(f"Processed data has been saved to {output_file}")

# 示例
input_file = '/public/home/wangshuo/gap/assembly/data/blue classic car/modified_blue classic car.ldr'  # 输入LDR文件路径


#main(input_file)