| import numpy as np
|
| import pyvista as pv
|
| from nbtlib import File, Compound, Int, ByteArray, load
|
| import re
|
| import os
|
|
|
|
|
| BLOCK_TYPE_MAP = {
|
| "log": 0,
|
| "planks": 1,
|
| "stairs": 2,
|
| "slab": 3,
|
| "fence": 4,
|
| "glass_pane": 5,
|
| "door": 6,
|
| "functional": 7,
|
| "grass_block": 8,
|
| "air": 9
|
| }
|
|
|
| STAIR_SUBTYPE_MAP = {
|
| "oak_stairs": 0,
|
| "dark_oak_stairs": 1,
|
| "birch_stairs": 2,
|
| "spruce_stairs": 3
|
| }
|
|
|
| def encode_block_data(decoded_data):
|
| """
|
| 编码解码后的 block_data，处理负数和特殊编码的方块 ID，恢复为原始数据格式。
|
| """
|
| encoded_data = []
|
| for value in decoded_data:
|
| if value <= 127:
|
|
|
| encoded_data.append(value)
|
| else:
|
|
|
| negative_value = (value % 128) - 128
|
| next_value = value // 128
|
|
|
|
|
| if negative_value < -128 or negative_value > 127:
|
| raise ValueError(f"编码值 {negative_value} 超出了 ByteArray 可接受范围")
|
| if next_value < -128 or next_value > 127:
|
| raise ValueError(f"增量值 {next_value} 超出了 ByteArray 可接受范围")
|
|
|
| encoded_data.append(negative_value)
|
| encoded_data.append(next_value)
|
|
|
| return encoded_data
|
|
|
| def decode_block_data(block_data):
|
| """
|
| 解码 block_data，把负数和特殊编码的方块 ID 转换为正确的无符号数或计算值。
|
| """
|
| decoded_data = []
|
| i = 0
|
|
|
| while i < len(block_data):
|
| value = block_data[i]
|
|
|
| if value == 127:
|
| decoded_data.append(value)
|
| i += 1
|
| elif value < 0:
|
| negative_value = value
|
| next_value = block_data[i + 1]
|
|
|
|
|
| calculated_value = (next_value + 1) * 128 + negative_value
|
| decoded_data.append(calculated_value)
|
| i += 2
|
| else:
|
| decoded_data.append(value)
|
| i += 1
|
|
|
| return decoded_data
|
|
|
| def build_output_data(block_data, palette, width, height, length):
|
| """
|
| 根据 block_data 和 palette 构建输出数据，包括方块名称和三维坐标。
|
| """
|
|
|
| decoded_block_data = decode_block_data(block_data)
|
|
|
|
|
| id_to_block = {v: k for k, v in palette.items()}
|
|
|
|
|
| output_data = []
|
| index = 0
|
| for y in range(height):
|
| for z in range(length):
|
| for x in range(width):
|
| if index >= len(decoded_block_data):
|
| break
|
| block_id = decoded_block_data[index]
|
| block_name = id_to_block.get(block_id, 'unknown')
|
| output_data.append({
|
| 'block': block_name,
|
| 'coordinates': (x, y, z)
|
| })
|
| index += 1
|
|
|
| print(f"✅ 成功加载 {len(output_data)} 个方块数据！")
|
| print(f"✅ 成功加载 {len(palette)} 个方块 ID！")
|
| print(f"✅ 地图尺寸 (宽度x): {int(width)}，(高度y): {int(height)}，(长度z): {int(length)}")
|
|
|
| return output_data
|
|
|
| def generate_schem(block_array, palette, width, height, length, filename):
|
| """
|
| 将方块数组和 palette 转换为 .schem 文件。
|
|
|
| 参数：
|
| block_array: 3D numpy 数组，表示方块在空间中的排布。
|
| palette: 字典，映射方块名称到方块 ID（如 {'minecraft:air': 0, 'minecraft:gold_block': 1}）。
|
| width: X 轴方向的长度。
|
| height: Y 轴方向的长度。
|
| length: Z 轴方向的长度。
|
| filename: 输出的 .schem 文件名（如 'output.schem'）。
|
| """
|
|
|
|
|
| block_data = []
|
| for y in range(height):
|
| for z in range(length):
|
| for x in range(width):
|
| block_data.append(block_array[y, z, x])
|
|
|
|
|
| encoded_block_data = encode_block_data(block_data)
|
|
|
|
|
| block_data = ByteArray(encoded_block_data)
|
|
|
|
|
| schem_data = File(Compound({
|
| 'Palette': Compound({block: Int(id) for block, id in palette.items()}),
|
| 'PaletteMax': Int(len(palette)),
|
| 'BlockData': block_data,
|
| 'Width': Int(width),
|
| 'Height': Int(height),
|
| 'Length': Int(length),
|
| 'Version': Int(1)
|
| }))
|
|
|
|
|
| with open(filename, 'wb') as f:
|
| schem_data.write(f)
|
|
|
| print(f"✅ 成功生成 '{filename}' 文件！")
|
|
|
| def parse_short(value):
|
| return int(value.split('(')[1].rstrip(')'))
|
|
|
| def preview_point_cloud(output_data, air_block='minecraft:air', point_size=50):
|
| """
|
| 使用 PyVista 可视化 Minecraft 方块数据的点云。
|
| """
|
| points = []
|
| colors = []
|
|
|
| for data in output_data:
|
| x, y, z = data['coordinates']
|
| block_name = data['block']
|
|
|
| if block_name == air_block:
|
| continue
|
|
|
|
|
| points.append([x, z, y])
|
|
|
|
|
| color = hash(block_name) % 0xFFFFFF
|
| r = (color >> 16) & 0xFF
|
| g = (color >> 8) & 0xFF
|
| b = color & 0xFF
|
| colors.append([r, g, b])
|
|
|
|
|
| points = np.array(points)
|
| colors = np.array(colors)
|
|
|
| if len(points) == 0:
|
| print("❌ 没有可视化的方块（可能都是空气方块）")
|
| return
|
|
|
|
|
| cloud = pv.PolyData(points)
|
| cloud['colors'] = colors / 255.0
|
|
|
|
|
| plotter = pv.Plotter()
|
| plotter.add_points(cloud, scalars='colors', rgb=True, point_size=point_size)
|
| plotter.show()
|
|
|
| def preview_cubes_with_colors(output_data, air_block='minecraft:air'):
|
| """
|
| 根据 Minecraft 方块数据生成立方体，并为每个方块设置不同的颜色。
|
| """
|
| plotter = pv.Plotter()
|
|
|
| for data in output_data:
|
| x, y, z = data['coordinates']
|
| block_name = data['block']
|
|
|
| if block_name == air_block:
|
| continue
|
|
|
|
|
| cube = pv.Cube(center=(x, z, y), x_length=1, y_length=1, z_length=1)
|
|
|
|
|
| color = hash(block_name) % 0xFFFFFF
|
| r = (color >> 16) & 0xFF
|
| g = (color >> 8) & 0xFF
|
| b = color & 0xFF
|
| color = [r / 255.0, g / 255.0, b / 255.0]
|
|
|
|
|
| plotter.add_mesh(cube, color=color, show_edges=False)
|
|
|
| plotter.show()
|
|
|
| def preview_slices(output_data, slice_axis='z', air_block='minecraft:air'):
|
| """
|
| 使用 PyVista 可视化 Minecraft 方块数据的切片展示。
|
| """
|
| slices = []
|
| blocks = []
|
|
|
| for data in output_data:
|
| x, y, z = data['coordinates']
|
| block_name = data['block']
|
|
|
| if block_name == air_block:
|
| continue
|
|
|
|
|
| if slice_axis == 'z':
|
| slices.append(z)
|
| elif slice_axis == 'y':
|
| slices.append(y)
|
| else:
|
| slices.append(x)
|
|
|
| blocks.append([x, y, z])
|
|
|
|
|
| slice_layers = list(set(slices))
|
| slice_layers.sort()
|
|
|
|
|
| plotter = pv.Plotter()
|
| for slice_layer in slice_layers:
|
| slice_data = [block for i, block in enumerate(blocks) if blocks[i][2] == slice_layer]
|
| points = np.array(slice_data)
|
|
|
| if len(points) > 0:
|
| cloud = pv.PolyData(points)
|
| plotter.add_points(cloud, color='blue', point_size=5)
|
|
|
| plotter.show()
|
|
|
| def rotate_block(x, y, z, rotation_angle, max_x, max_z):
|
| if rotation_angle == 90:
|
| return z, y, max_x - x
|
| elif rotation_angle == 180:
|
| return max_x - x, y, max_z - z
|
| elif rotation_angle == 270:
|
| return max_z - z, y, x
|
| return x, y, z
|
|
|
| def rotate_attr_vector(block_type, attr_vector, rotation_angle):
|
| if block_type == BLOCK_TYPE_MAP["stairs"] or block_type == BLOCK_TYPE_MAP["door"]:
|
| facing = attr_vector[0]
|
| new_facing = (facing + rotation_angle // 90) % 4
|
| attr_vector[0] = new_facing
|
| elif block_type == BLOCK_TYPE_MAP["log"]:
|
| axis = attr_vector[0]
|
| axis_map = {0: 2, 2: 0} if rotation_angle in [90, 270] else {0: 0, 1: 1, 2: 2}
|
| attr_vector[0] = axis_map.get(axis, axis)
|
| elif block_type in [BLOCK_TYPE_MAP["fence"], BLOCK_TYPE_MAP["glass_pane"]]:
|
| east, north, south, waterlogged, west = attr_vector
|
| if rotation_angle == 90:
|
| attr_vector = [north, west, east, waterlogged, south]
|
| elif rotation_angle == 180:
|
| attr_vector = [west, south, north, waterlogged, east]
|
| elif rotation_angle == 270:
|
| attr_vector = [south, east, west, waterlogged, north]
|
| return attr_vector
|
|
|
| def mirror_block(x, y, z, mirror_direction, max_x, max_z):
|
| if mirror_direction == "north_south":
|
| return max_x - x, y, z
|
| elif mirror_direction == "east_west":
|
| return x, y, max_z - z
|
| return x, y, z
|
|
|
| def mirror_attr_vector(block_type, attr_vector, mirror_direction):
|
| if block_type == BLOCK_TYPE_MAP["stairs"] or block_type == BLOCK_TYPE_MAP["door"]:
|
| facing = attr_vector[0]
|
| if mirror_direction == "north_south":
|
| attr_vector[0] = facing if facing in [0, 2] else 4 - facing
|
| if block_type == BLOCK_TYPE_MAP["door"]:
|
| attr_vector[2] = abs(attr_vector[2] - 1)
|
| elif block_type == BLOCK_TYPE_MAP["stairs"]:
|
| if attr_vector[2] in {1, 2, 3, 4}:
|
| attr_vector[2] = {1: 2, 2: 1, 3: 4, 4: 3}.get(attr_vector[2], attr_vector[2])
|
| elif mirror_direction == "east_west":
|
| attr_vector[0] = facing if facing in [1, 3] else 2 - facing
|
| if block_type == BLOCK_TYPE_MAP["door"]:
|
| attr_vector[2] = abs(attr_vector[2] - 1)
|
| elif block_type == BLOCK_TYPE_MAP["stairs"]:
|
| if attr_vector[2] in {1, 2, 3, 4}:
|
| attr_vector[2] = {1: 2, 2: 1, 3: 4, 4: 3}.get(attr_vector[2], attr_vector[2])
|
| elif block_type in [BLOCK_TYPE_MAP["fence"], BLOCK_TYPE_MAP["glass_pane"]]:
|
| east, north, south, waterlogged, west = attr_vector
|
| if mirror_direction == "north_south":
|
| attr_vector = [east, south, north, waterlogged, west]
|
| elif mirror_direction == "east_west":
|
| attr_vector = [west, north, south, waterlogged, east]
|
| return attr_vector
|
|
|
| def parse_block(block_str):
|
| match = re.match(r"minecraft:(\w+)(?:\[(.*?)\])?", block_str)
|
| if not match:
|
| return None
|
|
|
| block_name, properties = match.groups()
|
| for key in BLOCK_TYPE_MAP:
|
| if key in block_name:
|
| block_type = BLOCK_TYPE_MAP[key]
|
| break
|
| else:
|
| print(f"未知方块类型: {block_name}")
|
| return None
|
|
|
| attr_vector = []
|
| subtype = -1
|
| prop_dict = {}
|
| if properties:
|
| prop_dict = dict(prop.split('=') for prop in properties.split(','))
|
|
|
| if block_type == BLOCK_TYPE_MAP["stairs"]:
|
| subtype = STAIR_SUBTYPE_MAP.get(block_name, -1)
|
| attr_vector = [
|
| ["north", "east", "south", "west"].index(prop_dict.get("facing", "north")),
|
| 0 if prop_dict.get("half", "bottom") == "bottom" else 1,
|
| ["straight","inner_left", "inner_right", "outer_left", "outer_right"].index(prop_dict.get("shape", "straight")),
|
| 0 if prop_dict.get("waterlogged", "false") == "false" else 1
|
| ]
|
| elif block_type == BLOCK_TYPE_MAP["log"]:
|
| axis_map = {'x': 0, 'y': 1, 'z': 2}
|
| attr_vector = [axis_map.get(prop_dict.get('axis', 'y'))]
|
| elif block_type == BLOCK_TYPE_MAP["slab"]:
|
| attr_vector = [
|
| 0 if prop_dict.get("type", "bottom") == "bottom" else 1,
|
| 0 if prop_dict.get("waterlogged", "false") == "false" else 1
|
| ]
|
| elif block_type in (BLOCK_TYPE_MAP["fence"], BLOCK_TYPE_MAP["glass_pane"]):
|
| attr_vector = [
|
| 0 if prop_dict.get("east", "false") == "false" else 1,
|
| 0 if prop_dict.get("north", "false") == "false" else 1,
|
| 0 if prop_dict.get("south", "false") == "false" else 1,
|
| 0 if prop_dict.get("waterlogged", "false") == "false" else 1,
|
| 0 if prop_dict.get("west", "false") == "false" else 1
|
| ]
|
| elif block_type == BLOCK_TYPE_MAP["door"]:
|
| attr_vector = [
|
| ["north", "east", "south", "west"].index(prop_dict.get("facing", "north")),
|
| 0 if prop_dict.get("half", "lower") == "lower" else 1,
|
| 0 if prop_dict.get("hinge", "left") == "left" else 1,
|
| 0 if prop_dict.get("open", "false") == "false" else 1,
|
| 0 if prop_dict.get("powered", "false") == "false" else 1
|
| ]
|
| elif block_type == BLOCK_TYPE_MAP["grass_block"]:
|
| attr_vector = [0 if prop_dict.get("snowy", "false") == "false" else 1]
|
| elif block_type == BLOCK_TYPE_MAP["air"]:
|
| attr_vector = []
|
| while len(attr_vector) < 5:
|
| attr_vector.append(-1)
|
| return (block_type, subtype, attr_vector)
|
|
|
| def process_block_data(schem_file):
|
|
|
| if not os.path.exists("schem"):
|
| os.makedirs("schem")
|
|
|
|
|
| schem_path = os.path.join("schem", schem_file)
|
| schem_data = load(schem_path)
|
| palette = schem_data['Palette']
|
| block_data = schem_data['BlockData']
|
| width = schem_data['Width']
|
| height = schem_data['Height']
|
| length = schem_data['Length']
|
|
|
|
|
| decoded_block_data = decode_block_data(block_data)
|
|
|
|
|
| output_data = build_output_data(decoded_block_data, palette, width, height, length)
|
|
|
|
|
| while True:
|
| user_input = input("请输入要可视化的选项（1: 点云, 2: 切片, 3: 彩色立方体, 13: 点云和彩色立方体, q/Q: 退出）：")
|
|
|
| if user_input.lower() in ['q', 'Q']:
|
| print("退出程序。")
|
| break
|
| else:
|
|
|
| if '1' in user_input:
|
| preview_point_cloud(output_data)
|
| if '2' in user_input:
|
| preview_slices(output_data)
|
| if '3' in user_input:
|
| preview_cubes_with_colors(output_data)
|
| if '1' not in user_input and '2' not in user_input and '3' not in user_input:
|
| print("无效的输入，请重新输入。")
|
|
|
|
|
| with open('block_data.txt', 'w', encoding='utf-8') as f:
|
| for block in output_data:
|
| x, y, z = block['coordinates']
|
| block_name = block['block']
|
| if block_name == 'minecraft:dirt':
|
| block_name = 'minecraft:grass_block[snowy=false]'
|
| if x == 9 and y == 9 and z == 9:
|
| block_name = 'minecraft:air'
|
| elif x == 0 and y == 9 and z == 9:
|
| block_name = 'minecraft:air'
|
| elif x == 0 and y == 9 and z == 0:
|
| block_name = 'minecraft:air'
|
| elif x == 9 and y == 9 and z == 0:
|
| block_name = 'minecraft:air'
|
| f.write(f"{x},{y},{z},{block_name}\n")
|
|
|
|
|
| with open('metadata.txt', 'w', encoding='utf-8') as f:
|
| f.write(f"{width},{height},{length}\n")
|
| for block, block_id in palette.items():
|
| f.write(f"{block},{block_id}\n")
|
| print("✅ 方块数据已成功导出到 block_data.txt！")
|
| print("✅ 元数据已成功导出到 metadata.txt！")
|
|
|
| def parse_and_process_block_data():
|
| input_file = "block_data.txt"
|
| output_file = "parsed_block_data.txt"
|
|
|
| with open(input_file, "r", encoding="utf-8") as f:
|
| block_data = f.readlines()
|
|
|
| with open(output_file, "w", encoding="utf-8") as f:
|
| for line in block_data:
|
| parts = line.strip().split(',', 3)
|
| x, y, z, block_name = parts
|
| result = int(x), int(y), int(z), parse_block(block_name)
|
| if result:
|
| f.write(f"{result}\n")
|
| print(f"✅ 解析完成，结果已保存到 {output_file}")
|
|
|
| def get_unique_arrays(arrays):
|
| """返回独特数组的数组（使用哈希表优化）"""
|
| seen = set()
|
| unique_arrays = []
|
| for arr in arrays:
|
| arr_hashable = tuple(map(tuple, arr))
|
| if arr_hashable not in seen:
|
| unique_arrays.append(arr)
|
| seen.add(arr_hashable)
|
| return unique_arrays
|
|
|
| def generate_rotated_and_mirrored_data():
|
| input_file = "parsed_block_data.txt"
|
| output_file = "block_data_"
|
|
|
| blocks_original, blocks_90, blocks_180, blocks_270, blocks_mirror_north_south, blocks_mirror_east_west = [], [], [], [], [], []
|
|
|
| with open('metadata.txt', 'r', encoding='utf-8') as f:
|
| lines = f.readlines()
|
| width, height, length = map(parse_short, lines[0].strip().split(','))
|
|
|
| with open(input_file, "r", encoding="utf-8") as f:
|
| for line in f:
|
| line = line.strip()
|
| if not line:
|
| continue
|
| parts = eval(line)
|
| x, y, z, (block_type, subtype, attr_vector) = parts
|
|
|
| blocks_original.append([x, y, z, block_type, subtype] + attr_vector)
|
|
|
| for angle in [90, 180, 270]:
|
| new_x, new_y, new_z = rotate_block(x, y, z, angle, width-1, length-1)
|
| new_attr_vector = rotate_attr_vector(block_type, attr_vector.copy(), angle)
|
| locals()[f"blocks_{angle}"].append([new_x, new_y, new_z, block_type, subtype] + new_attr_vector)
|
|
|
| for direction in ["north_south", "east_west"]:
|
| new_x, new_y, new_z = mirror_block(x, y, z, direction, width-1, length-1)
|
| new_attr_vector = mirror_attr_vector(block_type, attr_vector.copy(), direction)
|
| locals()[f"blocks_mirror_{direction}"].append([new_x, new_y, new_z, block_type, subtype] + new_attr_vector)
|
|
|
| arrays = [blocks_original, blocks_90, blocks_180, blocks_270, blocks_mirror_north_south, blocks_mirror_east_west]
|
| for i in range(len(arrays)):
|
| arrays[i] = sorted(arrays[i], key=lambda block: (block[0], block[1], block[2]))
|
|
|
| original_array = np.array(blocks_original, dtype=np.int32)
|
| mirror_north_south_array = np.array(blocks_mirror_north_south, dtype=np.int32)
|
| mirror_east_west_array = np.array(blocks_mirror_east_west, dtype=np.int32)
|
|
|
| original_array = original_array[np.lexsort(original_array[:, :3].T)]
|
| mirror_north_south_array = mirror_north_south_array[np.lexsort(mirror_north_south_array[:, :3].T)]
|
| mirror_east_west_array = mirror_east_west_array[np.lexsort(mirror_east_west_array[:, :3].T)]
|
|
|
| if not np.array_equal(original_array, mirror_north_south_array):
|
| for i in range(len(original_array)):
|
| if not np.array_equal(original_array[i], mirror_north_south_array[i]):
|
| print(f"原数组: {original_array[i]}")
|
| print(f"南北镜像后: {mirror_north_south_array[i]}")
|
| else:
|
| print("原数组与南北镜像后的数组完全一致！")
|
|
|
| unique_arrays = get_unique_arrays(arrays)
|
| for i, array in enumerate(unique_arrays):
|
| array = np.array(array, dtype=np.int32)
|
| max_x, max_y, max_z = array[:, 0].max(), array[:, 1].max(), array[:, 2].max()
|
| structure = np.full((max_x + 1, max_y + 1, max_z + 1, 7), -1, dtype=np.int32)
|
|
|
| for x, y, z, block_type, subtype, *attr_vector in array:
|
| structure[x, y, z] = [block_type, subtype] + attr_vector
|
|
|
|
|
| if not os.path.exists("npy"):
|
| os.makedirs("npy")
|
|
|
|
|
| np.save(os.path.join("npy", output_file + str(i)), structure)
|
| print(f"✅ 数据成功保存到 npy/{output_file + str(i)}.npy，形状为 {structure.shape}")
|
|
|
| def compare_npy_and_txt(npy_file, input_txt, check_file):
|
| """
|
| 比较 .npy 文件和解析后的文本文件，检查两者是否一致。
|
|
|
| 参数：
|
| npy_file: .npy 文件路径。
|
| input_txt: 解析后的文本文件路径。
|
| check_file: 保存比对结果的文本文件路径。
|
| """
|
|
|
| structure = np.load(npy_file)
|
|
|
|
|
| W, H, D, _ = structure.shape
|
|
|
|
|
| reconstructed_lines = []
|
|
|
|
|
| for y in range(H):
|
| for z in range(D):
|
| for x in range(W):
|
| block_data = structure[x, y, z]
|
|
|
|
|
| block_type, subtype, *attr_vector = block_data
|
| block_type = int(block_type)
|
| subtype = int(subtype)
|
| attr_vector = [int(v) for v in attr_vector]
|
|
|
|
|
| reconstructed_line = f"({x}, {y}, {z}, ({block_type}, {subtype}, {attr_vector}))"
|
| reconstructed_lines.append(reconstructed_line)
|
|
|
|
|
| with open(input_txt, "r", encoding="utf-8") as f:
|
| original_lines = [line.strip() for line in f.readlines()]
|
|
|
|
|
| with open(check_file, "w", encoding="utf-8") as f:
|
| max_len = max(len(original_lines), len(reconstructed_lines))
|
|
|
| for i in range(max_len):
|
| orig = original_lines[i] if i < len(original_lines) else "[原文件缺失行]"
|
| recon = reconstructed_lines[i] if i < len(reconstructed_lines) else "[还原文件缺失行]"
|
|
|
| if orig != recon:
|
| f.write(f"❌ 差异行:\n原始: {orig}\n还原: {recon}\n\n")
|
| else:
|
| f.write(f"✅ 一致行:\n{orig}\n\n")
|
|
|
| print(f"检查完成，结果保存到 {check_file}")
|
|
|
| def check_accuracy_of_txt2npy():
|
|
|
| npy_file = "npy/block_data_0.npy"
|
| input_txt = "parsed_block_data.txt"
|
| check_file = "check_txt2npy.txt"
|
| compare_npy_and_txt(npy_file, input_txt, check_file)
|
|
|
| def main():
|
| schem_file = "WoodHouse_3.schem"
|
| process_block_data(schem_file)
|
| parse_and_process_block_data()
|
| generate_rotated_and_mirrored_data()
|
|
|
|
|
| check_accuracy_of_txt2npy()
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
