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)