XeNTaX

Code: Select all

"""
What:
    Reassemble indexed/palettized graphics.

Usage:
    python ReassembleGraphics.py block.png index.png palette.png output.png

Requirements:
    Python 3.9.17+
    pip install:
        numpy==1.25.0
        Pillow==10.0.0
"""

import sys
import numpy
from PIL import Image

tileHeight   = 8  # Height of a single graphic tile
tileWidth    = 8  # Width of a single graphic tile
indicesScale = 17

def ReassembleGraphics(filenames):
    if len(filenames) != 4:
        raise ValueError("Pass 4 filenames: graphic tiles, indices, color palette, output image")
    #endif

    # Open all 3 images
    graphicsImage = Image.open(filenames[0])
    indexImage = Image.open(filenames[1])
    paletteImage = Image.open(filenames[2])
    outputFilename = filenames[3]

    indices = numpy.asarray(indexImage)
    graphics = numpy.asarray(graphicsImage)
    palette = numpy.asarray(paletteImage)
    palette = numpy.flip(palette, 0).reshape(-1)   # Palette is a 2D image stored upside down. So restore it to 1D.
    print(f"Indices:  {indices.dtype} {indices.shape}")
    print(f"Graphics: {graphics.dtype} {graphics.shape}")
    print(f"Palette:  {palette.dtype} {palette.shape}")

    # The graphics are actually grayscale (not full color, despite the original file storing them so)
    # The palette index 0 through 255 is stored in the alpha channel.
    graphics = graphics[:, :, 3]

    indicesWidth      = indices.shape[1] # [height, width, channel]
    indicesHeight     = indices.shape[0] # [height, width, channel]
    graphicTilesWide  = graphics.shape[1] // tileWidth
    graphicTilesHigh  = graphics.shape[0] // tileHeight
    reassembledHeight = indicesHeight * tileHeight
    reassembledWidth  = indicesWidth  * tileWidth
    pixelCountPerTile = tileWidth     * tileHeight

    reassembledGraphics = numpy.zeros(shape=[reassembledHeight, reassembledWidth], dtype=numpy.uint8)
    print(f"Reassembled graphics shape: {reassembledGraphics.dtype} {reassembledGraphics.shape}")

    # Remap the tile indices back to tile indices from their awkwardly split
    # pixel values. Each color channel stores 16 distinct values, multiplied
    # by 17 to span 0 through 255. So divide it back to 0 through 15.
    indices = indices // indicesScale

    for outputTileY in range(indicesHeight):
        for outputTileX in range(indicesWidth):
            indicesPixel = indices[outputTileY, outputTileX]
            # PIL loads the image as 0=B, 1=G, 2=R, 3=A
            inputTileX   = indicesPixel[0] * 16 + indicesPixel[3]
            inputTileY   = indicesPixel[2] * 16 + indicesPixel[1]
            inputTileY   = graphicTilesHigh - 1 - inputTileY  # The graphic tiles are stored upside down
            inputPixelX  = inputTileX * tileWidth
            inputPixelY  = inputTileY * tileHeight
            outputPixelX = outputTileX * tileWidth
            outputPixelY = outputTileY * tileHeight

            # Copy the 8x8 pixel tile from input to output.
            inputView = graphics[inputPixelY:(inputPixelY+8), inputPixelX:(inputPixelX+8)]
            if inputView.size == pixelCountPerTile: # Skip if somehow degenerate (shouldn't be, but in case data is bad)
                outputView = reassembledGraphics[outputPixelY:(outputPixelY+8), outputPixelX:(outputPixelX+8)]
                outputView[:] = inputView
            #endif
        #endfor outputTileX
    #endfor outputTileY

    # Convert back to image, and save the file.
    reassembledGraphicsImage = Image.fromarray(reassembledGraphics, mode="P")
    reassembledGraphicsImage.putpalette(palette, rawmode="RGBA")
    reassembledGraphicsImage.save(outputFilename)

#enddef ReassembleGraphics

ReassembleGraphics(sys.argv[1:]) # Ignore the script name, passing all the filenames.