Add code/cube3d/training/process_single_ldr.py

code/cube3d/training/process_single_ldr.py

@@ -0,0 +1,1050 @@
+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):
+    with open(label_mapping_file, 'r') as f:
+        label_mapping = json.load(f)
+    
+    with open(label_inverse_mapping_file, 'r') as f:
+        label_inverse_mapping = json.load(f)
+    
+    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)