Downloading way too many pixels/chunks despite correct X/Y

[EpicLPer]

Heya,

I'd love to use this tool to make a timelapse of an area, however no matter what start and end x/y I type in it always seems to download way too many pixels or chunks in general.

As example: python wplace-export.py 44 50 172 114
Those are the top right and bottom left coordinates of the following artwork: https://wplace.live/?lat=48.21547910825858&lng=16.36672818427732&zoom=15.395050957159055

This should only export a roughly 128x64 image, however it seems to download a lot more than that, I think it's saying 8000 chunks? Thus rate limiting harshly by Cloudflare.

Output:

(45, 56) Rate limited. Waiting 5 seconds
(45, 55) Rate limited. Waiting 5 seconds
(45, 57) Rate limited. Waiting 5 seconds
(45, 58) Rate limited. Waiting 5 seconds
(45, 59) Rate limited. Waiting 5 seconds
Obtaining chunks:   1%|▌                                                             | 70/8385 [00:15<25:01,  5.54it/s]
Stopping
Obtaining chunks:   1%|▌                                                             | 70/8385 [00:18<36:14,  3.82it/s]

Is it possible wplace changed something in the meantime and this script needs to be updated? Thanks a lot!

[EpicLPer]

Oh wow... I fed the script through Claude and asked it to specifically only export the pixels I want in the given chunks and it actually worked. I'm not a big fan of AI personally however... but this kind of is impressive.

I'll post the script here in case it helps anyone else.
You can use a tool like Blue Marble to get the specific chunks x/y and pixel x/y for this to work.

Example: wplace-export-claude.py 1116 709 1117 710 --start-pixel-x 858 --start-pixel-y 925 --end-pixel-x 386 --end-pixel-y 209
1116 and 709 are the first_chunk_x and first_chunk_y respectively
1117 and 710 are the last_chunk_x and last_chunk_y respectively
858 and 925 are, like the parameter says, first pixel x/y in the first chunk given above
172 and 114 are the last pixel x/y in the last chunk given above

import argparse
import asyncio
import io
import os
import re
import sys
from datetime import datetime

import aiohttp
from PIL import Image
from tqdm import tqdm

MAX_CONCURRENT_REQUESTS = 3
RATE_LIMIT_SLEEP_TIME = 10
RETRY_BACKOFF_BASE = 2
MAX_RETRIES = 5
TILE_URL = lambda x, y: "https://backend.wplace.live/files/s0/tiles/" + str(x) + "/" + str(y) + ".png"
TILE_W, TILE_H = 1000, 1000

parser = argparse.ArgumentParser(
    prog='WPlace Export Tool',
    description='Exports a designated area of wplace into an image')

# Modified arguments to support multi-chunk exports
parser.add_argument('start_chunk_x', help='Starting chunk X coordinate')
parser.add_argument('start_chunk_y', help='Starting chunk Y coordinate')
parser.add_argument('end_chunk_x', help='Ending chunk X coordinate (inclusive)')
parser.add_argument('end_chunk_y', help='Ending chunk Y coordinate (inclusive)')

# Optional pixel-level cropping within the chunk area
parser.add_argument('--start-pixel-x', type=int, default=0, help='Starting pixel X within the first chunk (0-999, default: 0)')
parser.add_argument('--start-pixel-y', type=int, default=0, help='Starting pixel Y within the first chunk (0-999, default: 0)')
parser.add_argument('--end-pixel-x', type=int, default=999, help='Ending pixel X within the last chunk (0-999, default: 999)')
parser.add_argument('--end-pixel-y', type=int, default=999, help='Ending pixel Y within the last chunk (0-999, default: 999)')

parser.add_argument('-s', '--save-chunks',
                    action='store_true',
                    help="Also save an image of each chunk")
parser.add_argument('-w', '--watch',
                    metavar="SECONDS",
                    help="Exports the area every X seconds")
parser.add_argument('-f', '--fill',
                    metavar="COLOR (#RRGGBBAA)",
                    help="Specify color to use as background (Defaults to transparent)")
parser.add_argument('--delay',
                    metavar="SECONDS", 
                    type=float,
                    default=1.5,
                    help="Delay between requests in seconds (default: 1.5)")

args = parser.parse_args()

def create_directories():
    if not os.path.exists("chunks"):
        os.makedirs("chunks")

    if not os.path.exists("exports"):
        os.makedirs("exports")

def parse_coordinates():
    try:
        start_chunk_x = int(args.start_chunk_x)
        start_chunk_y = int(args.start_chunk_y)
        end_chunk_x = int(args.end_chunk_x)
        end_chunk_y = int(args.end_chunk_y)
        
        # Validate pixel coordinates
        if not (0 <= args.start_pixel_x <= 999 and 0 <= args.start_pixel_y <= 999 and 
                0 <= args.end_pixel_x <= 999 and 0 <= args.end_pixel_y <= 999):
            print("Error: Pixel coordinates must be between 0-999")
            exit(1)
        
        # Ensure start coordinates are not greater than end coordinates
        if start_chunk_x > end_chunk_x or start_chunk_y > end_chunk_y:
            print("Error: Start chunk coordinates must be less than or equal to end chunk coordinates")
            exit(1)
        
        # Generate list of all chunks to download
        chunks = []
        for x in range(start_chunk_x, end_chunk_x + 1):
            for y in range(start_chunk_y, end_chunk_y + 1):
                chunks.append((x, y))
        
        # Determine if this is a single chunk or multi-chunk export
        is_single_chunk = (start_chunk_x == end_chunk_x and start_chunk_y == end_chunk_y)
        
        if is_single_chunk:
            print(f"Single chunk export: chunk ({start_chunk_x}, {start_chunk_y})")
            print(f"Pixel area: ({args.start_pixel_x}, {args.start_pixel_y}) to ({args.end_pixel_x}, {args.end_pixel_y})")
        else:
            print(f"Multi-chunk export: chunks ({start_chunk_x}, {start_chunk_y}) to ({end_chunk_x}, {end_chunk_y})")
            print(f"Total chunks: {len(chunks)} ({end_chunk_x - start_chunk_x + 1} x {end_chunk_y - start_chunk_y + 1})")
            if (args.start_pixel_x != 0 or args.start_pixel_y != 0 or 
                args.end_pixel_x != 999 or args.end_pixel_y != 999):
                print(f"With pixel cropping: start ({args.start_pixel_x}, {args.start_pixel_y}) end ({args.end_pixel_x}, {args.end_pixel_y})")
        
        return {
            'chunks': chunks,
            'start_chunk': (start_chunk_x, start_chunk_y),
            'end_chunk': (end_chunk_x, end_chunk_y),
            'start_pixel': (args.start_pixel_x, args.start_pixel_y),
            'end_pixel': (args.end_pixel_x, args.end_pixel_y),
            'is_single_chunk': is_single_chunk
        }
        
    except ValueError:
        print("Invalid coordinates (Use -h for help)")
        print("Usage: python script.py <start_chunk_x> <start_chunk_y> <end_chunk_x> <end_chunk_y>")
        print("Optional: --start-pixel-x X --start-pixel-y Y --end-pixel-x X --end-pixel-y Y")
        exit(1)

def create_and_save_final_image(tiles, fill, coord_data):
    time = datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
    
    # Get coordinate information
    start_chunk = coord_data['start_chunk']
    end_chunk = coord_data['end_chunk']
    start_pixel = coord_data['start_pixel']
    end_pixel = coord_data['end_pixel']
    is_single_chunk = coord_data['is_single_chunk']
    
    if is_single_chunk:
        # Single chunk with pixel cropping
        chunk_coords = start_chunk
        chunk_image = tiles[chunk_coords]
        
        # Crop to the specific pixel area (PIL crop uses exclusive end coordinates)
        crop_box = (start_pixel[0], start_pixel[1], end_pixel[0] + 1, end_pixel[1] + 1)
        cropped_image = chunk_image.crop(crop_box)
        
        cropped_image.save(f"exports/export_{time}.png")
        print(f"Exported area: {cropped_image.width}x{cropped_image.height} pixels")
        
    else:
        # Multiple chunks - stitch them together first
        xs = [coord[0] for coord in tiles.keys()]
        ys = [coord[1] for coord in tiles.keys()]
        min_x, max_x = min(xs), max(xs)
        min_y, max_y = min(ys), max(ys)

        # Create the full stitched image
        width = (max_x - min_x + 1) * TILE_W
        height = (max_y - min_y + 1) * TILE_H
        full_img = Image.new("RGBA", (width, height), fill)

        # Paste each chunk into the full image
        for (x, y), img in tiles.items():
            px = (x - min_x) * TILE_W
            py = (y - min_y) * TILE_H
            full_img.paste(img, (px, py))

        # Apply pixel-level cropping if specified
        if (start_pixel[0] != 0 or start_pixel[1] != 0 or 
            end_pixel[0] != 999 or end_pixel[1] != 999):
            
            # Calculate absolute pixel coordinates in the stitched image
            start_abs_x = (start_chunk[0] - min_x) * TILE_W + start_pixel[0]
            start_abs_y = (start_chunk[1] - min_y) * TILE_H + start_pixel[1]
            end_abs_x = (end_chunk[0] - min_x) * TILE_W + end_pixel[0] + 1  # +1 for exclusive end
            end_abs_y = (end_chunk[1] - min_y) * TILE_H + end_pixel[1] + 1  # +1 for exclusive end
            
            # Crop the stitched image
            final_img = full_img.crop((start_abs_x, start_abs_y, end_abs_x, end_abs_y))
        else:
            final_img = full_img

        final_img.save(f"exports/export_{time}.png")
        print(f"Exported area: {final_img.width}x{final_img.height} pixels from {len(tiles)} chunks")

def parse_color(val):
    if not re.fullmatch(r"#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})", val):
        raise ValueError(f"Invalid hex color format: {val}")

    hex_color = val.lstrip("#")

    if len(hex_color) in (3, 4):
        hex_color = "".join(c * 2 for c in hex_color)

    if len(hex_color) == 6:
        hex_color += "FF"

    r = int(hex_color[0:2], 16)
    g = int(hex_color[2:4], 16)
    b = int(hex_color[4:6], 16)
    a = int(hex_color[6:8], 16)

    return r, g, b, a

def parse_watch(val):
    try:
        return int(val)
    except ValueError:
        print("Invalid watch value (Use -h for help)")
        exit(1)

async def get_chunk(x, y, session, sem, fill, bar):
    time = datetime.now().strftime("%Y_%m_%d_%H_%M_%S")

    async with sem:
        for attempt in range(MAX_RETRIES):
            try:
                async with session.get(TILE_URL(x, y)) as response:
                    if response.status == 404:
                        chunk_image = Image.new("RGBA", (TILE_W, TILE_H), fill)
                        break
                    elif response.status == 429:
                        backoff_time = RATE_LIMIT_SLEEP_TIME * (RETRY_BACKOFF_BASE ** attempt)
                        tqdm.write(f"({x}, {y}) Rate limited (attempt {attempt + 1}/{MAX_RETRIES}). Waiting {backoff_time} seconds")
                        await asyncio.sleep(backoff_time)
                        continue
                    elif response.status == 200:
                        image_data = await response.content.read()
                        img_rgba = Image.open(io.BytesIO(image_data)).convert("RGBA")
                        chunk_image = Image.new("RGBA", img_rgba.size, fill)
                        chunk_image.paste(img_rgba, mask=img_rgba.getchannel("A"))
                        break
                    else:
                        tqdm.write(f"({x}, {y}) Unexpected status: {response.status}")
                        if attempt == MAX_RETRIES - 1:
                            chunk_image = Image.new("RGBA", (TILE_W, TILE_H), fill)
                        else:
                            await asyncio.sleep(2 ** attempt)
                            continue

            except Exception as e:
                tqdm.write(f"({x}, {y}) Error: {e}")
                if attempt == MAX_RETRIES - 1:
                    chunk_image = Image.new("RGBA", (TILE_W, TILE_H), fill)
                else:
                    await asyncio.sleep(2 ** attempt)
                    continue

        if args.save_chunks:
            chunk_image.save(f"chunks/{x}_{y}_{time}.png")

        await asyncio.sleep(args.delay)
        bar.update(1)
        return chunk_image

async def main():
    sem = asyncio.Semaphore(MAX_CONCURRENT_REQUESTS)
    tiles = {}
    tasks = {}
    fill = parse_color(args.fill) if args.fill is not None else (0,0,0,0)
    watch = parse_watch(args.watch) if args.watch is not None else 0

    coord_data = parse_coordinates()
    chunks_to_download = coord_data['chunks']

    create_directories()

    total_chunks = len(chunks_to_download)
    print(f"Downloading {total_chunks} chunk(s) with {args.delay}s delay between requests...")

    bar = tqdm(total=total_chunks)
    bar.set_description("Obtaining chunks")

    while True:
        async with aiohttp.ClientSession() as session:
            async with asyncio.TaskGroup() as group:
                for chunk_x, chunk_y in chunks_to_download:
                    tasks[(chunk_x, chunk_y)] = group.create_task(
                        get_chunk(chunk_x, chunk_y, session, sem, fill, bar)
                    )

        bar.close()
        print("Done downloading chunks")
        print("Creating final image... ", end="")

        results = {coords: task.result() for coords, task in tasks.items()}
        for coords, value in results.items():
            tiles[coords] = value

        create_and_save_final_image(tiles, fill, coord_data)
        print("Done")

        if watch == 0:
            break
        else:
            print(f"Waiting {watch} seconds")
            await asyncio.sleep(watch)
            # Reset for next iteration
            tiles.clear()
            tasks.clear()
            bar = tqdm(total=total_chunks)
            bar.set_description("Obtaining chunks")


try:
    asyncio.run(main())
except KeyboardInterrupt:
    print("\nStopping")

[joaoalves03]

What this script does is download every chunk between X and Y.
Each chunk in wplace is 1000x1000 pixels.
By doing python wplace-export.py 44 50 172 114, you're asking for every single chunk between (44,50) and (172,114). As you said, that's over 8 thousand chunks.

The script you got from claude seems to edit the chunk image to limit it to the coordinates that you specify. I think this is a good idea, and if I find the time, I'll add that to the script.

[EpicLPer]

Yeah I was a bit confused at first cause it had an extra option to save the chunk as well, I assumed wrong at first what the script does :)
Can say tho that the Claude script has been working very well for the past hours to capture a specific area every 60 seconds for a timelapse.