Datasets:
Download mc_voxel_texture_resolver.py from ramuuuo/Sking: direct link, hf CLI and curl.
- Browser
- Download file 6.92 kB
-
https://huggingface.co/datasets/ramuuuo/Sking/resolve/main/mc_voxel_texture_resolver.py
- Command line
-
hf download hf://datasets/ramuuuo/Sking/mc_voxel_texture_resolver.py
-
curl -L -o mc_voxel_texture_resolver.py https://huggingface.co/datasets/ramuuuo/Sking/resolve/main/mc_voxel_texture_resolver.py
6.92 kB
| from PIL import Image, ImageChops | |
| import numpy as np | |
| # Compensate when decor texture is missing. When any two faces are inconsistent, follow the priority order: front, back, left, right, top, bottom | |
| def resolve_voxel_consistency(img): | |
| is_slim = img.getpixel((47,52))[3] == 0 | |
| print('is_slim', is_slim) | |
| for part_idx, part in enumerate([ | |
| # head | |
| [ | |
| [ | |
| [(8,8,8),(8,8)],#front | |
| [(8,8,8),(24,8)],#back | |
| [(8,8,8),(16,8)],#left | |
| [(8,8,8),(0,8)],#right | |
| [(8,8,8),(8,0)],#top | |
| [(8,8,8),(16,0)],#bottom | |
| ],(32,0) | |
| ], | |
| #body | |
| [ | |
| [ | |
| [(8,12,4),(20,20)],#front | |
| [(8,12,4),(20+12,20)],#back | |
| [(4,12,8),(28,20)],#left | |
| [(4,12,8),(16,20)],#right | |
| [(8,4,12),(20,16)],#top | |
| [(8,4,12),(20+8,16)],#bottom | |
| ],(0,16) | |
| ], | |
| #left arm | |
| [ | |
| [ | |
| [((3 if is_slim else 4),12,4),(32+4,52)],#front | |
| [((3 if is_slim else 4),12,4),(32+12-(1 if is_slim else 0),52)],#back | |
| [(4,12,4),(32+8-(1 if is_slim else 0),52)],#left | |
| [(4,12,4),(32,52)],#right | |
| [((3 if is_slim else 4),4,12),(32+4,48)],#top | |
| [((3 if is_slim else 4),4,12),(32+8-(1 if is_slim else 0),48)],#bottom | |
| ],(16,0) | |
| ], | |
| #right arm | |
| [ | |
| [ | |
| [((3 if is_slim else 4),12,4),(40+4,20)],#front | |
| [((3 if is_slim else 4),12,4),(40+12-(1 if is_slim else 0),20)],#back | |
| [(4,12,4),(40+8-(1 if is_slim else 0),20)],#left | |
| [(4,12,4),(40,20)],#right | |
| [((3 if is_slim else 4),4,12),(40+4,16)],#top | |
| [((3 if is_slim else 4),4,12),(40+8-(1 if is_slim else 0),16)],#bottom | |
| ],(0,16) | |
| ], | |
| #left leg | |
| [ | |
| [ | |
| [(4,12,4),(16+4,52)],#front | |
| [(4,12,4),(16+12,52)],#back | |
| [(4,12,4),(16+8,52)],#left | |
| [(4,12,4),(16,52)],#right | |
| [(4,4,12),(16+4,48)],#top | |
| [(4,4,12),(16+8,48)],#bottom | |
| ],(-16,0) | |
| ], | |
| #right leg | |
| [ | |
| [ | |
| [(4,12,4),(0+4,20)],#front | |
| [(4,12,4),(0+12,20)],#back | |
| [(4,12,4),(0+8,20)],#left | |
| [(4,12,4),(0,20)],#right | |
| [(4,4,12),(0+4,16)],#top | |
| [(4,4,12),(0+8,16)],#bottom | |
| ],(0,16) | |
| ], | |
| ]): | |
| decor_offset = part[1] | |
| (x,y,z) = part[0][4][0] | |
| # map x,y,z -> colors | |
| # map x,y,z -> colors | |
| #colors = np.full((x, y, z, 4), -1) | |
| colors = np.zeros((x, y, z, 4)) | |
| priorities = np.full((x, y, z), 99) | |
| # Initialize decor layer voxels | |
| # map x,y,z -> img x,y arr | |
| inverse = {} | |
| for idx,(size, offset) in enumerate(part[0]): | |
| for dx in range(size[0]): | |
| for dy in range(size[1]): | |
| img_x = offset[0]+dx+decor_offset[0] | |
| img_y = offset[1]+dy+decor_offset[1] | |
| c = img.getpixel((img_x, img_y)) | |
| new_x = None | |
| new_y = None | |
| new_z = None | |
| if idx == 4: # top | |
| new_x, new_y, new_z = (dx, y-1-dy, z-1) | |
| elif idx == 5: # bottom | |
| new_x, new_y, new_z = (dx, y-1-dy, 0) | |
| elif idx == 0: # front | |
| new_x, new_y, new_z = (dx, 0, z-1-dy) | |
| elif idx == 1: # back | |
| new_x, new_y, new_z = (x-1-dx, y-1, z-1-dy) | |
| elif idx == 2: # left | |
| new_x, new_y, new_z = (x-1, dx, z-1-dy) | |
| elif idx == 3: # right | |
| new_x, new_y, new_z = (0, y-1-dx, z-1-dy) | |
| if (new_x,new_y,new_z) not in inverse: | |
| inverse[(new_x,new_y,new_z)] = [] | |
| inverse[(new_x,new_y,new_z)].append((img_x,img_y)) | |
| if c[3] == 0: | |
| continue | |
| prio = 99 | |
| if idx == 0: prio = 0 # front | |
| elif idx == 1: prio = 1 # back | |
| elif idx == 4: prio = 2 # top | |
| elif idx == 5: prio = 3 # bottom | |
| elif idx == 2: prio = 4 # left | |
| elif idx == 3: prio = 5 # right | |
| if priorities[new_x, new_y, new_z] > prio: | |
| colors[new_x, new_y, new_z] = c | |
| priorities[new_x, new_y, new_z] = prio | |
| for dx in range(size[0]): | |
| for dy in range(size[1]): | |
| for dz in range(size[2]): | |
| if (dx,dy,dz) in inverse: | |
| if priorities[dx, dy, dz] == 99: | |
| continue | |
| for i in inverse[(dx,dy,dz)]: | |
| existing_c = img.getpixel(i) | |
| if existing_c[3] == 0: | |
| img.putpixel(i, tuple(colors[dx,dy,dz].astype(int))) | |
| return img | |
| def highlight_diff(img1_path, img2_path, output_path): | |
| # 1. Open and ensure consistent mode (usually RGB) | |
| img1 = Image.open(img1_path).convert('RGBA') | |
| img2 = Image.open(img2_path).convert('RGBA') | |
| arr1 = np.array(img1) | |
| arr2 = np.array(img2) | |
| # 4. Create an all-zero array to store results (fully transparent) | |
| height, width, _ = arr1.shape | |
| result_arr = np.zeros((height, width, 4), dtype=np.uint8) | |
| # 5. Calculate difference mask | |
| # This step is key. We compare if arr1 and arr2 are not equal. | |
| # The resulting diff_mask is a boolean array, | |
| # where True means at least one of the four RGBA values at the corresponding position is different. | |
| diff_mask = np.any(arr1 != arr2, axis=-1) | |
| # 6. Set result pixels | |
| # Where differences exist (diff_mask is True), | |
| # set the pixels in the result array to pure red: (R=255, G=0, B=0, A=255) | |
| result_arr[diff_mask] = [255, 0, 0, 255] | |
| # 7. Where pixels match (~diff_mask is True), | |
| # maintain the state when created in step 4: (0, 0, 0, 0) which is fully transparent. | |
| # No extra operation is needed here since result_arr is initialized to all zeros. | |
| # 8. Convert the NumPy array back to Pillow Image | |
| result_img = Image.fromarray(result_arr, mode='RGBA') | |
| # 9. Save result | |
| result_img.save(output_path) | |