import os import json from copy import deepcopy import re import ast import numpy as np from scipy.spatial.transform import Rotation as R import uuid import xml.etree.ElementTree as ET BLOCKPROPERTYPATH=R"Besiege_blocks_markov.json" FLIP_SENSITIVE_BLOCKS = ["2","46"] def are_quaternions_similar(q1, angle_threshold=1e-3): q2 = np.array([0, -0.7071068, 0, 0.7071068]) # 将四元数转换为旋转对象 r1 = R.from_quat(q1) r2 = R.from_quat(q2) # 计算两个旋转之间的夹角差异 relative_rotation = r1.inv() * r2 angle = relative_rotation.magnitude() # 如果角度差异小于阈值，则认为两个四元数大致相同 return angle < angle_threshold def generate_guid(): """生成一个唯一的GUID""" return str(uuid.uuid4()) def add_rotations(q1, q2): """叠加两个旋转四元数""" r1 = R.from_quat(q1) # 从四元数创建旋转对象 r2 = R.from_quat(q2) # 从四元数创建旋转对象 r_combined = r1 * r2 # 叠加旋转 return r_combined.as_quat() # 返回四元数 (xyzw 格式) def read_txt(path): """读取文本文件内容""" with open(path, "r", encoding="utf-8") as file: return file.read() def write_file(path, content): """将内容写入文本文件""" with open(path, 'w', encoding='utf-8') as file: file.write(content) def extract_json_from_string(input_string: str,return_raw_str=False): if isinstance(input_string,list): return input_string if os.path.exists(input_string): input_content = read_txt(input_string) else: input_content = deepcopy(input_string) match = re.search(r"```json(.*?)```", input_content, re.DOTALL) if match: json_content = match.group(1).strip() try: if return_raw_str: return json.loads(json_content),json_content return json.loads(json_content) except json.JSONDecodeError: pass try: if return_raw_str: return json.loads(input_content),input_content return json.loads(input_content) except json.JSONDecodeError: try: if return_raw_str: return json.loads(input_content),input_content return ast.literal_eval(input_content) except (ValueError, SyntaxError): if return_raw_str: return None,"" return None def get_relative_pos_list(bp_oldpos,ref_p,ref_r,scale=1,decimals=None): bp_newpos = [] if ref_r.shape[0] != 3 or ref_r.shape[1] != 3: ref_r = R.from_quat(ref_r).as_matrix() # 如果是四元数，转换为旋转矩阵 for point in bp_oldpos: point_lp = ref_p+np.dot(ref_r, point*scale) bp_newpos.append(tuple(point_lp)) bp_newpos = np.array(bp_newpos)#可建造点局部位置 if decimals!=None: bp_newpos = np.round(bp_newpos,decimals=decimals) return bp_newpos def get_bbox(manu_lp,manu_lr,scale,bc_gc,bbox_size,gp,gr): if manu_lr.shape[0] != 3 or manu_lr.shape[1] != 3: manu_lr = R.from_quat(manu_lr).as_matrix() if gr.shape[0] != 3 or gr.shape[1] != 3: gr = R.from_quat(gr).as_matrix() half_bbox_size = np.array(bbox_size) / 2.0 bbox_lp = [] for z in [-1, 1]: for x in [-1, 1]: for y in [-1, 1]: point = (manu_lp+bc_gc) + (x * half_bbox_size[0], y * half_bbox_size[1], z * half_bbox_size[2]) bc_point = point-manu_lp point_lp = manu_lp+np.dot(manu_lr, bc_point*scale) bbox_lp.append(tuple(point_lp)) bbox_lp = np.array(bbox_lp)#碰撞盒顶点相对位置 bbox_gp = get_relative_pos_list(bbox_lp,gp,gr,decimals=2) return bbox_lp,bbox_gp def compute_normal_vector(vertices, bp): bp = np.round(bp, decimals=3) # 计算每个维度的最小和最大坐标值 min_coords = np.min(vertices, axis=0) max_coords = np.max(vertices, axis=0) # 初始化法向量 normal = np.zeros(3) # epsilon = 5e-4 # 容差范围，还算严格 epsilon = 0.005 # 容差范围 # 检查点是否在x方向的面上 if abs(bp[0] - min_coords[0]) < epsilon: normal = np.array([-1, 0, 0]) # 左面法向量 elif abs(bp[0] - max_coords[0]) < epsilon: normal = np.array([1, 0, 0]) # 右面法向量 # 检查y方向 elif abs(bp[1] - min_coords[1]) < epsilon: normal = np.array([0, -1, 0]) # 下面法向量 elif abs(bp[1] - max_coords[1]) < epsilon: normal = np.array([0, 1, 0]) # 上面法向量 # 检查z方向 elif abs(bp[2] - min_coords[2]) < epsilon: normal = np.array([0, 0, -1]) # 后面法向量 elif abs(bp[2] - max_coords[2]) < epsilon: normal = np.array([0, 0, 1]) # 前面法向量 else: raise ValueError("点不在长方体的任何一个面上") return normal def get_mybuildingpoints(bc_bp,manu_lp,manu_lr,gp,gr,bc_gc,bbox_size,scale=1): bp_ori = np.array(bc_bp) bp_lp = get_relative_pos_list(bp_ori,manu_lp,manu_lr,scale=scale) bp_gp = get_relative_pos_list(bp_lp,gp,gr,decimals=2) bbox_lp,bbox_gp = get_bbox(manu_lp,manu_lr,scale,bc_gc,bbox_size,gp,gr) my_building_points = bp_gp.copy() my_building_points_buildrotation=[] # print(f"bp_gp:{bp_gp}") for i in range(len(my_building_points)): # print(f"bp_lp:{bp_lp[i]}") # print(f"bbox_lp:{bbox_lp}") normal_vector_l = compute_normal_vector(bbox_lp,bp_lp[i]) rotated_initvec = np.array([0,0,1]) building_points_rot_quat = rotation_quaternion(rotated_initvec,normal_vector_l) my_building_points_buildrotation.append(building_points_rot_quat) #这个是对的 my_building_points_buildrotation = np.array(my_building_points_buildrotation) return my_building_points,my_building_points_buildrotation def rotation_quaternion(v_from, v_to): """计算从 v_from 到 v_to 的旋转四元数 (xyzw 格式)""" v_from = v_from / np.linalg.norm(v_from) # 单位化 v_to = v_to / np.linalg.norm(v_to) # 单位化 # 计算旋转轴和旋转角 cross = np.cross(v_from, v_to) dot = np.dot(v_from, v_to) if np.allclose(cross, 0) and np.allclose(dot, 1): return np.array([0, 0, 0, 1]) # 无需旋转 elif np.allclose(cross, 0) and np.allclose(dot, -1): # 特殊情况：v_from 和 v_to 反方向 # 选择一个垂直于 v_from 的轴作为旋转轴 if np.isclose(v_from[0], 0) and np.isclose(v_from[1], 0): axis = np.array([0, 1, 0]) # 如果 v_from 在 z 轴上，选择 y 轴作为旋转轴 else: axis = np.cross(v_from, np.array([0, 1, 0])) # 选择垂直于 v_from 和 y 轴的向量 axis = axis / np.linalg.norm(axis) angle = np.pi else: angle = np.arccos(dot) axis = cross / np.linalg.norm(cross) # 生成四元数 q = R.from_rotvec(axis * angle).as_quat() # xyzw格式 return q def format_json(input_json): try: new_clean_json=[] for json_info in input_json: new_clean_dict={} if int(json_info["id"]) not in [7,9]: new_clean_dict["id"]=str(json_info["id"]) new_clean_dict["order_id"]=int(json_info["order_id"]) new_clean_dict["parent"]=int(json_info["parent"]) new_clean_dict["bp_id"]=int(json_info["bp_id"]) else: new_clean_dict["id"]=str(json_info["id"]) new_clean_dict["order_id"]=int(json_info["order_id"]) new_clean_dict["parent_a"]=int(json_info["parent_a"]) new_clean_dict["bp_id_a"]=int(json_info["bp_id_a"]) new_clean_dict["parent_b"]=int(json_info["parent_b"]) new_clean_dict["bp_id_b"]=int(json_info["bp_id_b"]) new_clean_json.append(new_clean_dict) return new_clean_json except: return input_json def convert_to_numpy(data): no_globalrt = True for info in data: if "GlobalPosition" in info: info["GlobalPosition"] = np.array(info["GlobalPosition"]) info["GlobalRotation"] = np.array(info["GlobalRotation"]) no_globalrt = False else: keys_to_convert = ["corners", "building_center", "scale","manu_lr","manu_lp","bp_lr"] for key in keys_to_convert: if key in info: info[key] = np.array(info[key]) new_data = [{"GlobalPosition":np.array([0,5.05,0]),"GlobalRotation":np.array([0,0,0,1])}] if no_globalrt: new_data.extend(data) return new_data return data # 返回原始数据 def get_3d_from_llm(block_sizes, input_info, gp, gr, log=False): info = deepcopy(input_info) for block in info: order_id = int(block["order_id"]) block_id = str(block["id"]) # Handle scale if "scale" not in block: block["scale"] = np.array([1,1,1]) else: print(f"警告！{order_id}改变了scale！使用初始值") block["scale"] = np.array([1,1,1]) # Handle rotations if "bp_lr" not in block: if "manu_lr" not in block: block["bp_lr"] = np.array([0,0,0,1]) elif "manu_lr" in block and str(block.get("parent", "")) not in ("-1", ""): print(f"警告！{order_id}有manu_lr但不是根节点！旋转使用初始值") block["bp_lr"] = np.array([0,0,0,1]) block.pop("manu_lr", None) block_info = block_sizes[block_id] parent = int(block.get("parent", -1)) # Handle parent cases if parent == -1: if block_id not in ("0","7", "9"): print("警告！发现了非起始方块的无父节点块") if block_id in ("7", "9"): parent_a, parent_b = int(block["parent_a"]), int(block["parent_b"]) bp_id_a, bp_id_b = int(block["bp_id_a"]), int(block["bp_id_b"]) block["bp_lr"] = np.array([0,0,0,1]) block["manu_lr"] = add_rotations( info[parent_a]["my_building_points_buildrotation"][bp_id_a], block["bp_lr"] ) block["manu_lp_a"] = info[parent_a]["my_building_points"][bp_id_a] - gp block["manu_lp_b"] = info[parent_b]["my_building_points"][bp_id_b] - gp else: if "manu_lr" not in block: block["manu_lr"] = np.array([0,0,0,1]) block["manu_lp"] = np.array([0,0,0]) else: print("警告！发现了某个方块的manu_lr和manu_lp") if block["manu_lr"].shape != (3, 3): block["manu_lr"] = R.from_matrix(block["manu_lr"]).as_quat() else: try: bp_id = int(block["bp_id"]) parent_rot = info[parent]["my_building_points_buildrotation"][bp_id] block["manu_lr"] = add_rotations(parent_rot, block["bp_lr"]) block["manu_lp"] = info[parent]["my_building_points"][bp_id] - gp except Exception: print(f"警告！parent:{parent},order_id{order_id}的my_building_points或my_building_points_buildrotation不存在") # print(info[parent]) pass if block_id not in ("7", "9"): if block_id in FLIP_SENSITIVE_BLOCKS: block["flip"] = are_quaternions_similar(block["manu_lr"]) bc_bp = block_info['bc_bp'] bc_gc = block_info['bc_gc'] bbox_size = block_info['bbox_size'] if block_id == "30": bc_gc = [0,0,0.5] bbox_size = [1,1,1] building_points, build_rotation = get_mybuildingpoints( bc_bp, block["manu_lp"], block["manu_lr"], gp, gr, bc_gc, bbox_size, scale=block["scale"] ) block["my_building_points"] = building_points block["my_building_points_buildrotation"] = build_rotation if log: print(f"block_id:{block_id}\nscale:{block['scale']}\nbc_gc:{bc_gc}\n" f"bbox_size:{bbox_size}\nmanu_lp:{block['manu_lp']}\n" f"manu_lr:{block['manu_lr']}\nmy_building_points:{building_points}\n" f"my_building_points_buildrotation:{build_rotation}") return info def llm2xml_filetree(block_details, block_sizes_path, selected_menu=None): with open(block_sizes_path, 'r', encoding='utf-8') as file: block_sizes = json.load(file) global_rt = block_details.pop(0) gp, gr_quat = global_rt["GlobalPosition"], global_rt["GlobalRotation"] gr_matrix = R.from_quat(gr_quat).as_matrix() blocks_to_delete = set() # 使用集合以避免重复添加和快速查找 blocks_to_delete_feedback = [] #先对block_details做一个整体格式检查 linear = {"id","order_id","parent_a", "bp_id_a", "parent_b", "bp_id_b"} non_linear = {"id","order_id", "parent", "bp_id"} for i, block in enumerate(block_details): if not (set(block.keys()) == linear or set(block.keys()) == non_linear): blocks_to_delete.add(i) blocks_to_delete_feedback.append( f"警告：块(orderID {i})结构非法" ) order_id_map = {int(b["order_id"]): b for b in block_details} # 方便快速查找父块 for i,block in enumerate(block_details): is_linear = False parent_order_a=-1 parent_order_b=-1 #检查一下value的格式 format_error = False for k,v in block.items(): if k =="id": if not isinstance(v,str): if isinstance(v,int): v = str(v) else: format_error = True if k in["order_id","parent_a", "bp_id_a", "parent_b", "bp_id_b", "parent", "bp_id"]: if not isinstance(v,int): if isinstance(v,str): try: v = int(v) except: format_error = True if format_error: blocks_to_delete.add(i) blocks_to_delete_feedback.append(f"警告：order{i}json格式非法") continue #先检查起始方块： if i==0: block_type = str(block["id"]) order_id = int(block["order_id"]) parent_order = int(block.get("parent", -2)) bp_id = int(block.get("bp_id", -2)) if any([block_type!="0",order_id!=0]): blocks_to_delete.add(i) blocks_to_delete_feedback.append(f"警告：起始方块非法") continue if any([parent_order!=-1,bp_id!=-1]): #起始方块不规范，parent bpid改成-1 -1 block["parent"]=-1 block["bp_id"]=-1 order_id = int(block["order_id"]) parent_order = int(block.get("parent", -1)) if parent_order==-1 and order_id!=0: is_linear = True parent_order_a = int(block.get("parent_a", -1)) parent_order_b = int(block.get("parent_b", -1)) parents = [parent_order_a,parent_order_b] else: parents = [parent_order] # 检查1: 父块是否已被标记为非法 if any(order in blocks_to_delete for order in parents): blocks_to_delete.add(order_id) blocks_to_delete_feedback.append(f"警告：块(orderID {order_id})的父块(orderID {parent_order})非法，因此也被标记为非法。") continue # 检查2: 父块的连接点(bp_id)是否有效 for i_th_parent,parent_order in enumerate(parents): parent_block = order_id_map.get(parent_order) if parent_block: parent_block_id = str(parent_block["id"]) if i_th_parent==0: bp_id = int(block.get("bp_id",block.get("bp_id_a",-1))) elif i_th_parent==1: bp_id = int(block.get("bp_id_b",-1)) else: bp_id=-1 if parent_block_id in block_sizes and bp_id >= len(block_sizes[parent_block_id]["bc_bp"]): blocks_to_delete.add(order_id) blocks_to_delete_feedback.append(f"警告：块(orderID {order_id})的父块(ID {parent_block_id})不存在可建造点{bp_id}。") continue # 检查3: 双父块（线性块）的特殊处理 if (not is_linear) and str(block.get("id")) in ["7", "9"]: blocks_to_delete.add(order_id) blocks_to_delete_feedback.append(f"警告：块(orderID {order_id})是线性块但不存在双parent属性。") continue elif is_linear and (str(block.get("id")) not in ["7", "9"]): blocks_to_delete.add(order_id) blocks_to_delete_feedback.append(f"警告：块(orderID {order_id})存在双parent属性但不是线性块。") continue # print(blocks_to_delete_feedback) if blocks_to_delete: # 从 block_details 中过滤掉要删除的块 block_details = [b for b in block_details if int(b["order_id"]) not in blocks_to_delete] # --- 计算 3D 位置并构建 XML 风格列表 --- processed_details = get_3d_from_llm(block_sizes, block_details, gp, gr_matrix, log=False) # print(block_details) xml_block_details = [{"GlobalPosition": gp, "GlobalRotation": gr_quat}] for block in processed_details: xml_info = { "id": block["id"], "order_id": block["order_id"], "guid": generate_guid() } if str(block["id"]) in ["7", "9"]: # 线性块 xml_info["Transform"] = {"Position": block["manu_lp_a"], "Rotation": np.array([0,0,0,1]), "Scale": block["scale"]} xml_info["end-position"] = block["manu_lp_b"] - block["manu_lp_a"] else: # 普通块 manu_lr = R.from_matrix(block["manu_lr"]).as_quat() if block["manu_lr"].shape == (3, 3) else block["manu_lr"] xml_info["Transform"] = {"Position": block["manu_lp"], "Rotation": manu_lr, "Scale": block["scale"]} if "flip" in block: # 轮子属性 xml_info.update({"flip": block["flip"], "auto": True, "autobrake": False}) if selected_menu and "special_props" in selected_menu: xml_info["WheelDoubleSpeed"] = "WheelDoubleSpeed" in selected_menu["special_props"] xml_block_details.append(xml_info) # print("\n".join(blocks_to_delete_feedback)) return xml_block_details, processed_details, "\n".join(blocks_to_delete_feedback) def facing(q_in): q_z_pos = np.array([0, 0, 0, 1]) q_z_neg = np.array([0, 1, 0, 0]) q_x_neg = np.array([0, -0.7071068, 0, 0.7071068]) q_x_pos = np.array([0, 0.7071068, 0, 0.7071068]) q_y_pos = np.array([-0.7071068,0, 0,0.7071068]) q_y_neg = np.array([0.7071068,0, 0,0.7071068]) angle_threshold = 1e-3 rots = [q_z_pos,q_z_neg,q_x_neg,q_x_pos,q_y_pos,q_y_neg] facing = ["z+","z-","x-","x+","y+","y-"] # 将四元数转换为旋转对象 r1 = R.from_quat(q_in) for q2 in range(len(rots)): r2 = R.from_quat(rots[q2]) # 计算两个旋转之间的夹角差异 relative_rotation = r1.inv() * r2 angle = relative_rotation.magnitude() # 如果角度差异小于阈值，则认为两个四元数大致相同 if(angle < angle_threshold): return facing[q2] return "Error!未找到正确方向" def check_overlap_or_connection(cube1, cube2): def get_bounds(vertices): x_min = min(v[0] for v in vertices) x_max = max(v[0] for v in vertices) y_min = min(v[1] for v in vertices) y_max = max(v[1] for v in vertices) z_min = min(v[2] for v in vertices) z_max = max(v[2] for v in vertices) return x_min, x_max, y_min, y_max, z_min, z_max x1_min, x1_max, y1_min, y1_max, z1_min, z1_max = get_bounds(cube1) x2_min, x2_max, y2_min, y2_max, z2_min, z2_max = get_bounds(cube2) if x1_max <= x2_min or x2_max <= x1_min: return False if y1_max <= y2_min or y2_max <= y1_min: return False if z1_max <= z2_min or z2_max <= z1_min: return False x_overlap = x1_min < x2_max and x2_min < x1_max y_overlap = y1_min < y2_max and y2_min < y1_max z_overlap = z1_min < z2_max and z2_min < z1_max return x_overlap and y_overlap and z_overlap def check_overlap(block_details,vis=True,corners_parent_llm_parent=None, language="zh"): def overlap_log(id1,id2): head1 = "方块order_id" head2 = "和方块order_id" overlap_head = "重叠" return f"{head1} {id1} {head2} {id2} {overlap_head}\n" overlaps = [] connections = [] # 检查每对方块是否重叠 overlaps_info="" # print(len(block_details)) # print(len(corners_parent_llm_parent)) for i in range(len(block_details)): # print(block_details[i]) for j in range(i + 1, len(block_details)): if "GlobalPosition" in block_details[i] or "GlobalPosition" in block_details[j]:continue # if np.all(block_details[i] == 0) or np.all(block_details[j] == 0): continue if "corners" in block_details[i] and "corners" in block_details[j]: corners1, id1 = (block_details[i]["corners"],i) corners2, id2 = (block_details[j]["corners"],j) else: corners1 = block_details[i] id1 = i corners2 = block_details[j] id2 = j #print(f"方块order_id {id1} 和方块order_id {id2}") results = check_overlap_or_connection(corners1, corners2) if results=="connected": #print(f"方块order_id {id1} 和方块order_id {id2} 相交") connections.append((id1, id2, corners1, corners2)) elif results: if corners_parent_llm_parent !=None: id1_type = str(corners_parent_llm_parent[id1][0]) id1_order = str(corners_parent_llm_parent[id1][1]) id1_parent_order = str(corners_parent_llm_parent[id1][2]) id2_type = str(corners_parent_llm_parent[id2][0]) id2_order = str(corners_parent_llm_parent[id2][1]) id2_parent_order = str(corners_parent_llm_parent[id2][2]) if id1_order==id2_parent_order: if str(id1_type)=="30":#如果1是2的父节点，并且1是容器 pass else: overlaps_info+=overlap_log(id1,id2) overlaps.append((id1, id2, corners1, corners2)) elif id2_order==id1_parent_order: if str(id2_type)=="30":#如果2是1的父节点，并且2是容器 pass else: overlaps_info+=overlap_log(id1,id2) overlaps.append((id1, id2, corners1, corners2)) else: overlaps_info+=overlap_log(id1,id2) overlaps.append((id1, id2, corners1, corners2)) else: overlaps_info+=overlap_log(id1,id2) overlaps.append((id1, id2, corners1, corners2)) if overlaps: # print(f"共发现 {len(overlaps)} 处重叠。") found_head = "共发现" overlaps_head="处重叠" overlaps_info+=f"{found_head} {len(overlaps)} {overlaps_head}\n" else: # print("没有重叠的方块。") overlaps_info+="没有错误" if vis: # 可视化结果 pass #print(overlaps_info) return overlaps_info def llm_feedback_3d(block_sizes, xml_block_details, block_details, autofit_gt=True, overlap_feedback=True, language="zh"): with open(block_sizes, 'r', encoding='utf-8') as file: block_sizes_content = json.load(file) gp, gr = xml_block_details[0]["GlobalPosition"], xml_block_details[0]["GlobalRotation"] corners_feedback_forquizzer = "块的3D信息:\n" corners_feedback_forbuilder = "块的朝向信息:\n" corners_parent_llm, corners_parent_llm_parent = [], [] for i, xml_block in enumerate(xml_block_details): if "GlobalPosition" in xml_block: continue block_id, order_id = xml_block["id"], xml_block["order_id"] if str(block_id) in ("7", "9"): corners_parent_llm_parent.append([block_id, order_id, -1]) corners_parent_llm.append(np.zeros((8,3))) continue x_transform = xml_block["Transform"] pos, rot, scale = x_transform["Position"], x_transform["Rotation"], x_transform["Scale"] # print(pos,rot,scale) block_info = block_sizes_content[str(block_id)] bbox_lp, bbox_gp = get_bbox(pos, rot, scale, block_info['bc_gc'], block_info['bbox_size'], gp, gr) corners_parent_llm.append(bbox_gp) corners_parent_llm_parent.append([block_id, order_id, block_details[i-1]["parent"]]) facing_dir = facing(rot) corners_feedback_forquizzer += f"order_id:{order_id}\n朝向:{facing_dir}\n块近似长方体顶点位置:{bbox_gp.tolist()}\n" corners_feedback_forbuilder += f"order_id:{order_id}\n朝向:{facing_dir}" # Calculate machine dimensions corners_arr = np.vstack([c for c in corners_parent_llm if c.size > 0]) min_vals, max_vals = corners_arr.min(axis=0), corners_arr.max(axis=0) lowest_y, highest_y = min_vals[1], max_vals[1] left_x, right_x = min_vals[0], max_vals[0] back_z, forward_z = min_vals[2], max_vals[2] geo_center = np.array([(right_x + left_x)/2, (highest_y + lowest_y)/2, (forward_z + back_z)/2]) if autofit_gt: xml_block_details[0]["GlobalPosition"][1] -= (lowest_y - 0.5) xml_block_details[0]["GlobalPosition"][0] -= geo_center[0] xml_block_details[0]["GlobalPosition"][2] -= geo_center[2] env_fail = (highest_y - lowest_y > 9.5) or (right_x - left_x > 17) or (forward_z - back_z > 17) height, wide, long = round(highest_y - lowest_y, 2), round(right_x - left_x, 2), round(forward_z - back_z, 2) # Validate machine structure machine_structure_error = "" if "corners" in block_details[1]: for i, block in enumerate(block_details): if "GlobalPosition" in block or str(block.get("id")) in ("7", "9"): continue if not np.allclose(block["corners"], corners_parent_llm[i], atol=1e-2): machine_structure_error += (f"order_id为{i}的方块的顶点信息不一致！\n" f"顶点信息：{block['corners']}\n" f"建造点相对信息反推的顶点信息：{corners_parent_llm[i]}\n") overlap_infos = check_overlap(corners_parent_llm, vis=False, corners_parent_llm_parent=corners_parent_llm_parent, language=language) if overlap_feedback else "重叠检查被屏蔽" return (corners_feedback_forquizzer, corners_feedback_forbuilder, env_fail, long, wide, height, machine_structure_error, overlap_infos) def create_xml(data): """要加很多功能，因为加入了大量的新块""" machine = ET.Element("Machine", version="1", bsgVersion="1.3", name="gpt") # 创建 Global 元素 global_elem = ET.SubElement(machine, "Global") global_infos = data.pop(0) gp = global_infos["GlobalPosition"] gr = global_infos["GlobalRotation"] # if gp[1]<1.5: # print("警告，全局高度过低，小于1.5,调整到1.5") # gp[1]=1.5 position = ET.SubElement(global_elem, "Position", x=str(gp[0]), y=str(gp[1]), z=str(gp[2])) rotation = ET.SubElement(global_elem, "Rotation", x=str(gr[0]), y=str(gr[1]), z=str(gr[2]), w=str(gr[3])) # 创建 Data 元素 data_elem = ET.SubElement(machine, "Data") string_array = ET.SubElement(data_elem, "StringArray", key="requiredMods") # 创建 Blocks 元素 blocks_elem = ET.SubElement(machine, "Blocks") # 遍历 corners 数据并创建 Block 元素 for info in data: block_id = info['id'] if info['id']=='18_1': block_id ='18' block = ET.SubElement(blocks_elem, "Block", id=str(block_id), guid=info['guid']) transform = ET.SubElement(block, "Transform") info_p = info['Transform']['Position'] position = ET.SubElement(transform, "Position", x=str(info_p[0]), y=str(info_p[1]), z=str(info_p[2])) info_r = info['Transform']['Rotation'] rotation = ET.SubElement(transform, "Rotation", x=str(info_r[0]), y=str(info_r[1]), z=str(info_r[2]), w=str(info_r[3])) info_s = info['Transform']['Scale'] scale = ET.SubElement(transform, "Scale", x=str(info_s[0]), y=str(info_s[1]), z=str(info_s[2])) block_data = ET.SubElement(block, "Data") if str(info['id'])=="0": bmt = ET.SubElement(block_data, "Integer", key="bmt-version") bmt.text = "1" #线性块设置坐标 if str(info['id'])=="9": bmt = ET.SubElement(block_data,"Single",key = "bmt-slider") bmt.text = "10" bmt = ET.SubElement(block_data,"StringArray",key = "bmt-contract") bmt.text = "L" bmt = ET.SubElement(block_data,"Boolean",key = "bmt-toggle") bmt.text = "False" if str(info['id'])=="7" or str(info['id'])=="9": start_position = ET.SubElement(block_data,"Vector3",key = "start-position") ET.SubElement(start_position, "X").text = str(0) ET.SubElement(start_position, "Y").text = str(0) ET.SubElement(start_position, "Z").text = str(0) end_position = ET.SubElement(block_data,"Vector3",key = "end-position") ET.SubElement(end_position, "X").text = str(info['end-position'][0]) ET.SubElement(end_position, "Y").text = str(info['end-position'][1]) ET.SubElement(end_position, "Z").text = str(info['end-position'][2]) if str(info['id'])=="22": bmt = ET.SubElement(block_data, "Integer", key="bmt-version") bmt.text = "1" bmt = ET.SubElement(block_data,"Single",key = "bmt-speed") bmt.text = "1" bmt = ET.SubElement(block_data,"Single",key = "bmt-acceleration") bmt.text = "Infinity" bmt = ET.SubElement(block_data, "Boolean", key="bmt-auto-brake") bmt.text = "True" bmt = ET.SubElement(block_data, "Boolean", key="flipped") bmt.text = "False" if str(info['id'])=="35": bmt = ET.SubElement(block_data,"Single",key = "bmt-mass") bmt.text = "3" #轮子镜像处理 if "auto" in info: bmt = ET.SubElement(block_data, "Boolean", key="bmt-automatic") bmt.text = "True" bmt = ET.SubElement(block_data, "Boolean", key="bmt-auto-brake") bmt.text = "False" if "flip" in info and info["flip"]: bmt = ET.SubElement(block_data, "Boolean", key="flipped") bmt.text = "True" if "WheelDoubleSpeed" in info and info["WheelDoubleSpeed"]: bmt = ET.SubElement(block_data, "Single", key="bmt-speed") bmt.text = "2" # 将 ElementTree 转换为字符串 tree = ET.ElementTree(machine) ET.indent(tree, space="\t", level=0) xml_str = ET.tostring(machine, encoding="utf-8", method="xml", xml_declaration=True).decode("utf-8") return xml_str def json_to_xml(input_obj): if isinstance(input_obj,str): content = extract_json_from_string(input_obj) elif isinstance(input_obj,list): content = input_obj else: raise TypeError('Please make sure input type') block_details = content block_details = convert_to_numpy(block_details) xml_block_details,block_details,_ = llm2xml_filetree(block_details, BLOCKPROPERTYPATH, selected_menu=None) _,_,_,_,_,_,_,_ = llm_feedback_3d(block_sizes=BLOCKPROPERTYPATH, xml_block_details=xml_block_details, block_details = block_details) xml_string = create_xml(xml_block_details) return xml_string