Revert to v2.3 version

PBC2_4.py

@@ -1,818 +0,0 @@
-"""PBC2.4 clean core codec.
-
-Self-contained refactor of the PBC2.x codec line. It keeps the classic random-stroke
-algorithm, adds the PBC3.4 hybrid focus optimization, and drops demo/comparison code.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, replace
-from time import perf_counter
-from typing import Optional, Union
-
-import numpy as np
-from numba import njit, uint32, uint64
-from PIL import Image
-
-MAGIC = b"PBC24"
-VERSION = 1
-
-RESAMPLE = {
-    "nearest": Image.Resampling.NEAREST,
-    "box": Image.Resampling.BOX,
-    "bilinear": Image.Resampling.BILINEAR,
-    "hamming": Image.Resampling.HAMMING,
-    "bicubic": Image.Resampling.BICUBIC,
-    "lanczos": Image.Resampling.LANCZOS,
-}
-PLACEMENT = {"random": 0, "grid": 1, "hybrid": 2}
-COLOR = {"RGB": 0, "YCbCr": 1}
-CYCLE = {None: 0, False: 0, "Default": 1, "Strict": 2, "Balanced": 3, "Smart": 4}
-CRITERIA = {"Sum": 0, "Max": 1, "Min": 2}
-
-
-@dataclass
-class PBCConfig:
-    stroke_count: int = -1
-    size_range: tuple[float, float] = (-1.0, -1.0)
-    mult_list: tuple[int, ...] = (-10, 0, 5, 20)
-    start_mode: str = "Average"
-    start_custom: tuple[int, int, int] = (128, 128, 128)
-    decay_cutoff: float = -1.0
-    decay_softness: float = -1.0
-    decay_progress: float = -1.0
-    focus_strokes: int = 100
-    focus_warmup: float = -1.0
-    focus_max_bits: int = 8
-    focus_padding: int = 4
-    focus_criteria: str = "Sum"
-    focus_mode: str = "auto"
-    focus_sample_side: int = 384
-    focus_sample_threshold: int = 1536
-    channel_cycle: Union[str, bool, None] = "Smart"
-    channel_cycle_strokes: int = 100
-    channel_cycle_warmup: float = 0.9
-    channel_cycle_criteria: str = "Min"
-    color_space: str = "RGB"
-    downsample_rate: float = -1.0
-    downsample_initialize: bool = True
-    downsample_initialize_rate: float = 16.0
-    downsample_initialize_bits: int = 8
-    resample: str = "bicubic"
-    placement_mode: str = "random"
-    seed: int = 2003
-
-
-@dataclass
-class PBCResult:
-    image: Image.Image
-    data: bytes
-    config: PBCConfig
-    losses: tuple[int, int, int]
-    mse: int
-    header_bits: int
-    total_bits: int
-    encode_seconds: float
-
-    def save(self, path: str) -> None:
-        with open(path, "wb") as f:
-            f.write(self.data)
-
-
-class BitWriter:
-    def __init__(self):
-        self.buf = bytearray()
-        self.acc = 0
-        self.n = 0
-        self.bits = 0
-
-    def write(self, value: int, count: int) -> None:
-        value = int(value)
-        for i in range(count - 1, -1, -1):
-            self.acc = (self.acc << 1) | ((value >> i) & 1)
-            self.n += 1
-            self.bits += 1
-            if self.n == 8:
-                self.buf.append(self.acc)
-                self.acc = 0
-                self.n = 0
-
-    def write_signed(self, value: int, count: int) -> None:
-        self.write(0 if value < 0 else 1, 1)
-        self.write(abs(int(value)), count - 1)
-
-    def write_float(self, value: float, decimals: int = 4, count: int = 20) -> None:
-        self.write(int(round(value * (10 ** decimals))), count)
-
-    def write_array(self, arr: np.ndarray, bits: int) -> None:
-        for v in arr.reshape(-1):
-            self.write(int(v), bits)
-
-    def finish(self) -> tuple[bytes, int]:
-        pad = (8 - self.n) % 8
-        if self.n:
-            self.buf.append(self.acc << pad)
-        return bytes(self.buf), pad
-
-
-class BitReader:
-    def __init__(self, data: bytes):
-        self.data = data
-        self.i = 0
-        self.bits = 0
-
-    def read(self, count: int) -> int:
-        v = 0
-        for _ in range(count):
-            byte = self.data[self.i >> 3]
-            bit = (byte >> (7 - (self.i & 7))) & 1
-            v = (v << 1) | bit
-            self.i += 1
-            self.bits += 1
-        return v
-
-    def read_signed(self, count: int) -> int:
-        sign = self.read(1)
-        v = self.read(count - 1)
-        return v if sign else -v
-
-    def read_float(self, decimals: int = 4, count: int = 20) -> float:
-        return self.read(count) / (10 ** decimals)
-
-    def read_array(self, shape: tuple[int, ...], bits: int) -> np.ndarray:
-        arr = np.empty(int(np.prod(shape)), dtype=np.uint8)
-        for i in range(arr.size):
-            arr[i] = self.read(bits)
-        return arr.reshape(shape)
-
-
-@njit(inline="always")
-def _pcg_step(state):
-    old = state
-    state = uint64(old * 6364136223846793005 + 1442695040888963407)
-    x = uint32(((old >> 18) ^ old) >> 27)
-    rot = uint32(old >> 59)
-    out = (x >> rot) | (x << ((-rot) & 31))
-    return state, out
-
-
-@njit(inline="always")
-def _focus_bitcount(h, w, size, max_bits):
-    ch, cw = h, w
-    bits = 0
-    split_h = True
-    while bits < max_bits:
-        if split_h:
-            if ch // 2 < size:
-                break
-            ch //= 2
-        else:
-            if cw // 2 < size:
-                break
-            cw //= 2
-        split_h = not split_h
-        bits += 1
-    return bits
-
-
-@njit(inline="always")
-def _focus_bounds(h, w, size, code, bits, pad):
-    rs, re, cs, ce = 0, h, 0, w
-    split_h = True
-    for b in range(bits - 1, -1, -1):
-        bit = (code >> b) & 1
-        if split_h:
-            mid = (rs + re) // 2
-            if bit == 0:
-                re = mid
-            else:
-                rs = mid
-        else:
-            mid = (cs + ce) // 2
-            if bit == 0:
-                ce = mid
-            else:
-                cs = mid
-        split_h = not split_h
-    re -= size
-    ce -= size
-    rs = max(0, rs - pad)
-    cs = max(0, cs - pad)
-    re = min(h - size, re + pad)
-    ce = min(w - size, ce + pad)
-    if re <= rs:
-        re = rs + 1
-    if ce <= cs:
-        ce = cs + 1
-    return rs, cs, re, ce
-
-
-@njit
-def _select_focus_exact(target, canvas, h, w, bits, criteria):
-    if bits == 0:
-        return 0
-    best_code = 0
-    best = -1.0
-    for code in range(1 << bits):
-        rs, cs, re, ce = _focus_bounds(h, w, 0, code, bits, 0)
-        if criteria == 0:
-            val = 0.0
-            for r in range(rs, re):
-                for c in range(cs, ce):
-                    d = target[r, c] - canvas[r, c]
-                    val += abs(d)
-        elif criteria == 1:
-            val = 0.0
-            for r in range(rs, re):
-                for c in range(cs, ce):
-                    d = abs(target[r, c] - canvas[r, c])
-                    if d > val:
-                        val = d
-        else:
-            val = 1e18
-            for r in range(rs, re):
-                for c in range(cs, ce):
-                    d = abs(target[r, c] - canvas[r, c])
-                    if d < val:
-                        val = d
-        if val > best:
-            best = val
-            best_code = code
-    return best_code
-
-
-@njit(inline="always")
-def _sample_focus_code(r, c, h, w, bits):
-    rs, re, cs, ce = 0, h, 0, w
-    code = 0
-    split_h = True
-    for _ in range(bits):
-        code <<= 1
-        if split_h:
-            mid = (rs + re) // 2
-            if r >= mid:
-                code |= 1
-                rs = mid
-            else:
-                re = mid
-        else:
-            mid = (cs + ce) // 2
-            if c >= mid:
-                code |= 1
-                cs = mid
-            else:
-                ce = mid
-        split_h = not split_h
-    return code
-
-
-@njit
-def _select_focus_sampled(target, canvas, h, w, bits, sample_side):
-    if bits == 0:
-        return 0
-    sums = np.zeros(1 << bits, dtype=np.float64)
-    sr = min(h, sample_side)
-    sc = min(w, sample_side)
-    for ir in range(sr):
-        r = (ir * h + h // 2) // sr
-        if r >= h:
-            r = h - 1
-        for ic in range(sc):
-            c = (ic * w + w // 2) // sc
-            if c >= w:
-                c = w - 1
-            d = target[r, c] - canvas[r, c]
-            if d < 0:
-                d = -d
-            sums[_sample_focus_code(r, c, h, w, bits)] += d
-    best_code = 0
-    best = sums[0]
-    for i in range(1, sums.size):
-        if sums[i] > best:
-            best = sums[i]
-            best_code = i
-    return best_code
-
-
-@njit(inline="always")
-def _coords(state, i, mode, rs, cs, re, ce, size):
-    if re <= rs:
-        re = rs + 1
-    if ce <= cs:
-        ce = cs + 1
-    if mode == 0 or (mode == 2 and (i & 1) == 1):
-        state, rr = _pcg_step(state)
-        state, cc = _pcg_step(state)
-        return state, rs + int(rr % uint32(re - rs)), cs + int(cc % uint32(ce - cs))
-    gh = max(1, (re - rs) // max(1, size))
-    gw = max(1, (ce - cs) // max(1, size))
-    idx = i % (gh * gw)
-    gr = idx // gw
-    gc = idx % gw
-    row = rs if gh == 1 else rs + (gr * (re - rs - 1)) // (gh - 1)
-    col = cs if gw == 1 else cs + (gc * (ce - cs - 1)) // (gw - 1)
-    return state, row, col
-
-
-@njit(inline="always")
-def _apply_tile(target, canvas, r0, r1, c0, c1, mults):
-    if r0 >= r1 or c0 >= c1:
-        return 0
-    s = 0.0
-    n = 0
-    for r in range(r0, r1):
-        for c in range(c0, c1):
-            s += target[r, c] - canvas[r, c]
-            n += 1
-    mean = s / n
-    best_i = 0
-    best_d = abs(mults[0] - mean)
-    for i in range(1, mults.size):
-        d = abs(mults[i] - mean)
-        if d < best_d:
-            best_d = d
-            best_i = i
-    m = mults[best_i]
-    if m != 0:
-        for r in range(r0, r1):
-            for c in range(c0, c1):
-                v = canvas[r, c] + m
-                if v < 0:
-                    v = 0
-                elif v > 255:
-                    v = 255
-                canvas[r, c] = v
-    return best_i
-
-
-@njit
-def _channel_selector(target, canvas, strategy, criteria):
-    out = np.empty(3, dtype=np.int64)
-    out[0], out[1], out[2] = 0, 1, 2
-    if strategy == 1:
-        return out
-    errs = np.zeros(3, dtype=np.float64)
-    h, w = target.shape[0], target.shape[1]
-    for ch in range(3):
-        if criteria == 0:
-            s = 0.0
-            for r in range(h):
-                for c in range(w):
-                    s += abs(target[r, c, ch] - canvas[r, c, ch])
-            errs[ch] = s
-        elif criteria == 1:
-            m = 0.0
-            for r in range(h):
-                for c in range(w):
-                    d = abs(target[r, c, ch] - canvas[r, c, ch])
-                    if d > m:
-                        m = d
-            errs[ch] = m
-        else:
-            m = 1e18
-            for r in range(h):
-                for c in range(w):
-                    d = abs(target[r, c, ch] - canvas[r, c, ch])
-                    if d < m:
-                        m = d
-            errs[ch] = m
-    order = np.argsort(errs)[::-1]
-    if strategy == 2:
-        out[:] = order[0]
-    elif strategy == 3:
-        out[0], out[1], out[2] = order[0], order[0], order[1]
-    elif strategy == 4:
-        if errs[order[0]] > 2 * errs[order[1]]:
-            out[:] = order[0]
-        elif errs[order[1]] > 2 * errs[order[2]]:
-            out[0], out[1], out[2] = order[0], order[0], order[1]
-    return out
-
-
-@njit
-def _encode_loop(target, canvas, sizes, mults, seed, placement, focus_strokes, focus_warmup, focus_max_bits, focus_pad, focus_criteria, focus_mode, sample_side, cycle_mode, cycle_strokes, cycle_warmup, cycle_criteria):
-    n = sizes.size
-    h, w = target.shape[0], target.shape[1]
-    indices = np.zeros((n, 4), dtype=np.uint16)
-    focus_codes = np.full(n, -1, dtype=np.int64)
-    focus_bits = np.zeros(n, dtype=np.uint8)
-    cycle_codes = np.full((n, 3), -1, dtype=np.int64)
-    counters = np.empty(3, dtype=np.int64)
-    counters[0] = counters[1] = counters[2] = focus_warmup // 3
-    fcodes = np.zeros(3, dtype=np.int64)
-    fbits = np.zeros(3, dtype=np.int64)
-    selector = np.empty(3, dtype=np.int64)
-    selector[0], selector[1], selector[2] = 0, 1, 2
-    timer = cycle_warmup
-    state = uint64(seed)
-    for i in range(n):
-        size = sizes[i]
-        channel = selector[i % 3]
-        if counters[channel] <= 0:
-            bits = _focus_bitcount(h, w, size, focus_max_bits)
-            if focus_mode == 2:
-                code = _select_focus_sampled(target[:, :, channel], canvas[:, :, channel], h, w, bits, sample_side)
-            else:
-                code = _select_focus_exact(target[:, :, channel], canvas[:, :, channel], h, w, bits, focus_criteria)
-            fcodes[channel] = code
-            fbits[channel] = bits
-            focus_codes[i] = code
-            focus_bits[i] = bits
-            counters[channel] = focus_strokes
-        if cycle_mode != 0 and timer <= 0:
-            selector = _channel_selector(target, canvas, cycle_mode, cycle_criteria)
-            cycle_codes[i, 0], cycle_codes[i, 1], cycle_codes[i, 2] = selector[0], selector[1], selector[2]
-            timer = cycle_strokes
-        if fbits[channel] > 0:
-            rs, cs, re, ce = _focus_bounds(h, w, size, fcodes[channel], fbits[channel], focus_pad)
-        else:
-            rs, cs, re, ce = 0, 0, h - size, w - size
-        state, row, col = _coords(state, i, placement, rs, cs, re, ce, size)
-        half = size // 2
-        indices[i, 0] = _apply_tile(target[:, :, channel], canvas[:, :, channel], row, row + half, col, col + half, mults)
-        indices[i, 1] = _apply_tile(target[:, :, channel], canvas[:, :, channel], row, row + half, col + half, col + size, mults)
-        indices[i, 2] = _apply_tile(target[:, :, channel], canvas[:, :, channel], row + half, row + size, col, col + half, mults)
-        indices[i, 3] = _apply_tile(target[:, :, channel], canvas[:, :, channel], row + half, row + size, col + half, col + size, mults)
-        counters[channel] -= 1
-        if cycle_mode != 0:
-            timer -= 1
-    return indices, focus_codes, focus_bits, cycle_codes, canvas
-
-
-@njit
-def _decode_loop(canvas, sizes, mults, indices, focus_codes, focus_bits, cycle_codes, seed, placement, focus_strokes, focus_warmup, focus_pad, cycle_mode, cycle_strokes, cycle_warmup):
-    n = sizes.size
-    h, w = canvas.shape[0], canvas.shape[1]
-    counters = np.empty(3, dtype=np.int64)
-    counters[0] = counters[1] = counters[2] = focus_warmup // 3
-    fcodes = np.zeros(3, dtype=np.int64)
-    fbits = np.zeros(3, dtype=np.int64)
-    selector = np.empty(3, dtype=np.int64)
-    selector[0], selector[1], selector[2] = 0, 1, 2
-    timer = cycle_warmup
-    state = uint64(seed)
-    for i in range(n):
-        size = sizes[i]
-        channel = selector[i % 3]
-        if focus_codes[i] >= 0:
-            fcodes[channel] = focus_codes[i]
-            fbits[channel] = focus_bits[i]
-            counters[channel] = focus_strokes
-        if cycle_mode != 0 and cycle_codes[i, 0] >= 0:
-            selector[0], selector[1], selector[2] = cycle_codes[i, 0], cycle_codes[i, 1], cycle_codes[i, 2]
-            timer = cycle_strokes
-        if fbits[channel] > 0:
-            rs, cs, re, ce = _focus_bounds(h, w, size, fcodes[channel], fbits[channel], focus_pad)
-        else:
-            rs, cs, re, ce = 0, 0, h - size, w - size
-        state, row, col = _coords(state, i, placement, rs, cs, re, ce, size)
-        half = size // 2
-        for k in range(4):
-            if k == 0:
-                r0, r1, c0, c1 = row, row + half, col, col + half
-            elif k == 1:
-                r0, r1, c0, c1 = row, row + half, col + half, col + size
-            elif k == 2:
-                r0, r1, c0, c1 = row + half, row + size, col, col + half
-            else:
-                r0, r1, c0, c1 = row + half, row + size, col + half, col + size
-            m = mults[indices[i, k]]
-            if m != 0:
-                for r in range(r0, r1):
-                    for c in range(c0, c1):
-                        v = canvas[r, c, channel] + m
-                        if v < 0:
-                            v = 0
-                        elif v > 255:
-                            v = 255
-                        canvas[r, c, channel] = v
-        counters[channel] -= 1
-        if cycle_mode != 0:
-            timer -= 1
-    return canvas
-
-
-def _resample_id(name: str) -> int:
-    return list(RESAMPLE).index(name)
-
-
-def _resample_name(idx: int) -> str:
-    return list(RESAMPLE)[idx]
-
-
-def _decay(length: int, start: int, end: int, cutoff: float, softness: float, progress: float):
-    if cutoff == -1:
-        cutoff = 0.01 + (1 / 1.0000115) ** (length + 15000)
-    if softness == -1:
-        softness = 0.5
-    if progress == -1:
-        progress = 0.5
-    cutoff, softness, progress = round(cutoff, 4), round(softness, 4), round(progress, 4)
-    x = np.linspace(0, length, length)
-    if cutoff <= 0:
-        return np.full(length, end, dtype=np.int64), cutoff, softness, progress
-    lencut = length * cutoff
-    if lencut >= length * 3:
-        return np.full(length, start, dtype=np.int64), cutoff, softness, progress
-    lin = start + (x / (length * cutoff)) * (end - start)
-    if softness <= 0:
-        sig = np.where(x >= lencut / 2, end, start)
-    else:
-        k = 1.0 / softness * (np.sqrt(abs(end - start)) / length)
-        sig = start + (end - start) / (1 + np.exp(-k * (x - lencut / 2)))
-    curve = progress * sig + (1 - progress) * lin
-    curve[x >= lencut] = end
-    return (curve // 2 * 2).astype(np.int64), cutoff, softness, progress
-
-
-def _rgb_to_ycbcr(img):
-    return np.asarray(Image.fromarray(np.clip(img, 0, 255).astype(np.uint8), "RGB").convert("YCbCr"), dtype=np.int16)
-
-
-def _ycbcr_to_rgb(img):
-    return np.asarray(Image.fromarray(np.clip(img, 0, 255).astype(np.uint8), "YCbCr").convert("RGB"), dtype=np.uint8)
-
-
-def _prepare_config(img_size, cfg: PBCConfig) -> PBCConfig:
-    cfg = replace(cfg)
-    if cfg.stroke_count == -1:
-        cfg.stroke_count = int(20000 + 0.0015 * ((max(img_size) + 3200) ** 2))
-    if cfg.downsample_rate == -1:
-        cfg.downsample_rate = 1 if min(img_size) < 600 else min(img_size) / 500
-    if cfg.downsample_initialize and cfg.downsample_initialize_rate < 32:
-        if cfg.stroke_count > 20000:
-            if cfg.decay_cutoff == -1:
-                cfg.decay_cutoff = 0.3
-            if cfg.size_range == (-1.0, -1.0):
-                cfg.size_range = (0.05, 0.01)
-            if cfg.focus_warmup == -1:
-                cfg.focus_warmup = 0.1
-        else:
-            if cfg.decay_cutoff == -1:
-                cfg.decay_cutoff = 0.7
-            if cfg.size_range == (-1.0, -1.0):
-                cfg.size_range = (0.1, 0.03)
-            if cfg.focus_warmup == -1:
-                cfg.focus_warmup = 0.7
-    if cfg.focus_warmup == -1:
-        v = 0.75 - (0.000014 * (cfg.stroke_count - 1000) ** 2) / 550000
-        cfg.focus_warmup = max(0.0, min(v, 1.0))
-    return cfg
-
-
-def _start_color(img, cfg: PBCConfig):
-    if cfg.start_mode == "Black":
-        return (0, 0, 0) if cfg.color_space == "RGB" else (0, 128, 128)
-    if cfg.start_mode == "White":
-        return (255, 255, 255) if cfg.color_space == "RGB" else (255, 128, 128)
-    if cfg.start_mode == "Custom":
-        return cfg.start_custom
-    if cfg.start_mode == "Median":
-        return tuple(int(np.median(img[:, :, c])) for c in range(3))
-    if cfg.start_mode == "True Median":
-        return tuple(np.median(img.reshape(-1, 3), axis=0).astype(int))
-    return tuple(int(np.mean(img[:, :, c])) for c in range(3))
-
-
-def _pack(cfg, w, h, original_size, sizes, decay_vals, start_color, init, symbols):
-    writer = BitWriter()
-    writer.write(1 if cfg.downsample_rate > 1 else 0, 1)
-    if cfg.downsample_rate > 1:
-        writer.write(original_size[0], 16)
-        writer.write(original_size[1], 16)
-    writer.write(1 if cfg.color_space == "YCbCr" else 0, 1)
-    writer.write(_resample_id(cfg.resample), 3)
-    writer.write(h, 16)
-    writer.write(w, 16)
-    writer.write(cfg.stroke_count, 32)
-    for v in start_color:
-        writer.write(v, 8)
-    writer.write(1 if cfg.downsample_initialize else 0, 1)
-    if cfg.downsample_initialize:
-        writer.write(init.shape[0], 16)
-        writer.write(init.shape[1], 16)
-        writer.write(cfg.downsample_initialize_bits, 4)
-        writer.write_array(init, cfg.downsample_initialize_bits)
-    writer.write(int(sizes[0]), 16)
-    writer.write(int(sizes[-1]), 16)
-    for flag, val in decay_vals:
-        writer.write(flag, 1)
-        writer.write_float(val)
-    writer.write(len(cfg.mult_list), 9)
-    for m in cfg.mult_list:
-        writer.write_signed(m, 9)
-    writer.write(int(cfg.focus_warmup * cfg.stroke_count), 32)
-    writer.write(cfg.focus_strokes, 20)
-    writer.write(cfg.focus_max_bits, 8)
-    writer.write(cfg.focus_padding, 8)
-    writer.write(CRITERIA[cfg.focus_criteria], 2)
-    writer.write(CYCLE[cfg.channel_cycle], 3)
-    if CYCLE[cfg.channel_cycle] != 0:
-        writer.write(cfg.channel_cycle_strokes, 20)
-        writer.write(int(cfg.channel_cycle_warmup * cfg.stroke_count), 32)
-        writer.write(CRITERIA[cfg.channel_cycle_criteria], 2)
-    writer.write(PLACEMENT[cfg.placement_mode], 2)
-    writer.write(cfg.seed, 64)
-    header_bits = writer.bits
-
-    indices, focus_codes, focus_bits, cycle_codes = symbols
-    mbits = int(np.ceil(np.log2(len(cfg.mult_list))))
-    for i in range(cfg.stroke_count):
-        if focus_codes[i] >= 0:
-            writer.write(int(focus_codes[i]), int(focus_bits[i]))
-        if cycle_codes[i, 0] >= 0:
-            writer.write(int(cycle_codes[i, 0]), 2)
-            writer.write(int(cycle_codes[i, 1]), 2)
-            writer.write(int(cycle_codes[i, 2]), 2)
-        for idx in indices[i]:
-            writer.write(int(idx), mbits)
-
-    payload, pad = writer.finish()
-    return MAGIC + bytes([VERSION, pad]) + payload, header_bits, writer.bits
-
-
-class PBC:
-    Config = PBCConfig
-    Result = PBCResult
-
-    @staticmethod
-    def compress(img: Union[str, Image.Image, np.ndarray], config: Optional[PBCConfig] = None, **overrides) -> PBCResult:
-        t0 = perf_counter()
-        cfg = replace(config or PBCConfig(), **overrides)
-        pil = Image.open(img).convert("RGB") if isinstance(img, str) else Image.fromarray(img).convert("RGB") if isinstance(img, np.ndarray) else img.convert("RGB")
-        original_size = pil.size
-        cfg = _prepare_config(original_size, cfg)
-        resample = RESAMPLE[cfg.resample]
-        work_pil = pil
-        if cfg.downsample_rate > 1:
-            work_pil = pil.resize((max(1, int(pil.width / cfg.downsample_rate)), max(1, int(pil.height / cfg.downsample_rate))), resample)
-        target = np.asarray(work_pil, dtype=np.int16)
-        if cfg.color_space == "YCbCr":
-            target = _rgb_to_ycbcr(target)
-        h, w = target.shape[:2]
-        start = _start_color(target, cfg)
-        init = np.empty((0, 0, 3), dtype=np.uint8)
-        init_store = init
-        if cfg.downsample_initialize:
-            ih = max(1, int(h / cfg.downsample_initialize_rate))
-            iw = max(1, int(w / cfg.downsample_initialize_rate))
-            init = np.asarray(work_pil.resize((iw, ih), resample), dtype=np.uint8)
-            if cfg.downsample_initialize_bits < 8:
-                init = ((init >> (8 - cfg.downsample_initialize_bits)) << (8 - cfg.downsample_initialize_bits)).astype(np.uint8)
-                init_store = (init >> (8 - cfg.downsample_initialize_bits)).astype(np.uint8)
-            else:
-                init_store = init
-            canvas = np.asarray(Image.fromarray(init).resize((w, h), resample), dtype=np.int16)
-            if cfg.color_space == "YCbCr":
-                canvas = _rgb_to_ycbcr(canvas)
-        else:
-            canvas = np.full((h, w, 3), start, dtype=np.int16)
-        s0, s1 = cfg.size_range
-        if s0 == -1:
-            s0 = 0.3 + (1 / 1.00095) ** (cfg.stroke_count + 7000)
-        if s1 == -1:
-            s1 = 0.01 + (1 / 1.00015) ** (cfg.stroke_count + 10200)
-        sizes, cutoff, soft, prog = _decay(cfg.stroke_count, int(s0 * (min(h, w) - 2)) + 2, int(s1 * (min(h, w) - 2)) + 2, cfg.decay_cutoff, cfg.decay_softness, cfg.decay_progress)
-        if cfg.focus_mode == "sampled" or (cfg.focus_mode == "auto" and min(h, w) >= cfg.focus_sample_threshold):
-            focus_mode_id = 2
-        elif cfg.focus_mode in ("auto", "exact"):
-            focus_mode_id = 1
-        else:
-            raise ValueError("focus_mode must be 'auto', 'exact', or 'sampled'")
-        indices, focus_codes, focus_bits, cycle_codes, canvas = _encode_loop(
-            target, canvas, sizes, np.asarray(cfg.mult_list, dtype=np.int16), cfg.seed, PLACEMENT[cfg.placement_mode],
-            cfg.focus_strokes, int(cfg.focus_warmup * cfg.stroke_count), cfg.focus_max_bits, cfg.focus_padding,
-            CRITERIA[cfg.focus_criteria], focus_mode_id, cfg.focus_sample_side,
-            CYCLE[cfg.channel_cycle], cfg.channel_cycle_strokes, int(cfg.channel_cycle_warmup * cfg.stroke_count), CRITERIA[cfg.channel_cycle_criteria],
-        )
-        final = np.clip(canvas, 0, 255)
-        final = _ycbcr_to_rgb(final) if cfg.color_space == "YCbCr" else final.astype(np.uint8)
-        out_pil = Image.fromarray(final)
-        if cfg.downsample_rate > 1:
-            out_pil = out_pil.resize(original_size, resample)
-        data, header_bits, total_bits = _pack(cfg, w, h, original_size, sizes, ((cfg.decay_cutoff == -1, cutoff), (cfg.decay_softness == -1, soft), (cfg.decay_progress == -1, prog)), start, init_store, (indices, focus_codes, focus_bits, cycle_codes))
-        out = np.asarray(out_pil, dtype=np.uint8)
-        src = np.asarray(pil, dtype=np.uint8)
-        losses = tuple(int(np.mean((src[:, :, c].astype(np.float32) - out[:, :, c].astype(np.float32)) ** 2)) for c in range(3))
-        return PBCResult(out_pil, data, cfg, losses, int(sum(losses) / 3), header_bits, total_bits, perf_counter() - t0)
-
-    @staticmethod
-    def decompress(data: Union[bytes, bytearray, str], return_result: bool = False):
-        if isinstance(data, str):
-            with open(data, "rb") as f:
-                data = f.read()
-        if data[:5] != MAGIC or data[5] != VERSION:
-            raise ValueError("Not a PBC2.4 v1 stream")
-        reader = BitReader(bytes(data[7:]))
-        down = reader.read(1)
-        original_size = None
-        if down:
-            original_size = (reader.read(16), reader.read(16))
-        color_space = "YCbCr" if reader.read(1) else "RGB"
-        resample_name = _resample_name(reader.read(3))
-        resample = RESAMPLE[resample_name]
-        h, w = reader.read(16), reader.read(16)
-        stroke_count = reader.read(32)
-        start = tuple(reader.read(8) for _ in range(3))
-        down_init = bool(reader.read(1))
-        init_bits = 8
-        if down_init:
-            ih, iw = reader.read(16), reader.read(16)
-            init_bits = reader.read(4)
-            init = reader.read_array((ih, iw, 3), init_bits)
-            if init_bits < 8:
-                init = (init << (8 - init_bits)).astype(np.uint8)
-            canvas = np.asarray(Image.fromarray(init).resize((w, h), resample), dtype=np.int16)
-            if color_space == "YCbCr":
-                canvas = _rgb_to_ycbcr(canvas)
-        else:
-            canvas = np.full((h, w, 3), start, dtype=np.int16)
-        size_start, size_end = reader.read(16), reader.read(16)
-        vals = []
-        for _ in range(3):
-            flag = reader.read(1)
-            val = reader.read_float()
-            vals.append(-1.0 if flag else val)
-        sizes, _, _, _ = _decay(stroke_count, size_start, size_end, vals[0], vals[1], vals[2])
-        mlen = reader.read(9)
-        mult_list = tuple(reader.read_signed(9) for _ in range(mlen))
-        focus_warmup = reader.read(32)
-        focus_strokes, focus_max_bits, focus_pad = reader.read(20), reader.read(8), reader.read(8)
-        _ = reader.read(2)
-        cycle_mode = reader.read(3)
-        cycle_strokes = 0; cycle_warmup = 0
-        if cycle_mode:
-            cycle_strokes = reader.read(20); cycle_warmup = reader.read(32); _ = reader.read(2)
-        placement = reader.read(2)
-        seed = reader.read(64)
-        indices = np.zeros((stroke_count, 4), dtype=np.uint16)
-        focus_codes = np.full(stroke_count, -1, dtype=np.int64)
-        focus_bits = np.zeros(stroke_count, dtype=np.uint8)
-        cycle_codes = np.full((stroke_count, 3), -1, dtype=np.int64)
-        counters = [focus_warmup // 3] * 3
-        selector = [0, 1, 2]
-        timer = cycle_warmup
-        mbits = int(np.ceil(np.log2(mlen)))
-        for i in range(stroke_count):
-            channel = selector[i % 3]
-            if counters[channel] <= 0:
-                bits = _focus_bitcount(h, w, int(sizes[i]), focus_max_bits)
-                focus_bits[i] = bits
-                focus_codes[i] = reader.read(bits) if bits else 0
-                counters[channel] = focus_strokes
-            if cycle_mode and timer <= 0:
-                selector = [reader.read(2), reader.read(2), reader.read(2)]
-                cycle_codes[i] = selector
-                timer = cycle_strokes
-            for k in range(4):
-                indices[i, k] = reader.read(mbits)
-            counters[channel] -= 1
-            if cycle_mode:
-                timer -= 1
-        canvas = _decode_loop(canvas, sizes, np.asarray(mult_list, dtype=np.int16), indices, focus_codes, focus_bits, cycle_codes, seed, placement, focus_strokes, focus_warmup, focus_pad, cycle_mode, cycle_strokes, cycle_warmup)
-        final = np.clip(canvas, 0, 255)
-        final = _ycbcr_to_rgb(final) if color_space == "YCbCr" else final.astype(np.uint8)
-        img = Image.fromarray(final)
-        if original_size is not None:
-            img = img.resize(original_size, resample)
-        if not return_result:
-            return img
-        cfg = PBCConfig(stroke_count=stroke_count, mult_list=mult_list, color_space=color_space, downsample_initialize=down_init, downsample_initialize_bits=init_bits, resample=resample_name, placement_mode=list(PLACEMENT)[placement], seed=seed)
-        return img, cfg
-
-    @staticmethod
-    def encode_file(input_path: str, output_path: str, config: Optional[PBCConfig] = None, **overrides) -> PBCResult:
-        result = PBC.compress(input_path, config, **overrides)
-        result.save(output_path)
-        return result
-
-    save = encode_file
-
-    @staticmethod
-    def decode_file(input_path: str, output_path: Optional[str] = None) -> Image.Image:
-        img = PBC.decompress(input_path)
-        if output_path:
-            img.save(output_path)
-        return img
-
-    load = decode_file
-
-    @staticmethod
-    def preload_numba() -> None:
-        img = Image.fromarray(np.random.randint(0, 256, (16, 16, 3), dtype=np.uint8))
-        PBC.compress(img, stroke_count=8, downsample_initialize=False, focus_warmup=1.0, channel_cycle=False)
-
-def _generate_multlist(bit_count: int = 2, min_value: int = -10, max_value: int = 20, mode: str = "Stable_Uniform"):
-    n = 1 << int(bit_count)
-    if n <= 1:
-        return [int(round((min_value + max_value) / 2))]
-    if mode == "Random":
-        rng = np.random.default_rng(2003)
-        vals = sorted(set(int(x) for x in rng.integers(min_value, max_value + 1, size=max(n * 4, 16))))
-        if len(vals) >= n:
-            return vals[:n]
-    return [int(round(x)) for x in np.linspace(min_value, max_value, n)]
-
-
-PBC.generate_multlist = staticmethod(_generate_multlist)
-PBC2_4 = PBC

PBC2_4_stream_patch.py

@@ -1,286 +0,0 @@
-"""Fast streaming compatibility patch for PBC2_4.py.
-
-Use either:
-    import PBC2_4_stream_patch
-after importing PBC2_4, or paste this file at the bottom of PBC2_4.py.
-"""
-
-from __future__ import annotations
-
-from dataclasses import replace
-import numpy as np
-from PIL import Image
-
-from PBC2_4 import (
-    PBC,
-    PBCConfig,
-    RESAMPLE,
-    PLACEMENT,
-    CYCLE,
-    CRITERIA,
-    _prepare_config,
-    _start_color,
-    _rgb_to_ycbcr,
-    _ycbcr_to_rgb,
-    _decay,
-    _focus_bitcount,
-    _select_focus_exact,
-    _select_focus_sampled,
-    _focus_bounds,
-    _coords,
-    _apply_tile,
-    _channel_selector,
-    _pack,
-)
-
-_RESAMPLE_FROM_PIL = {
-    int(Image.Resampling.NEAREST): "nearest",
-    int(Image.Resampling.BOX): "box",
-    int(Image.Resampling.BILINEAR): "bilinear",
-    int(Image.Resampling.HAMMING): "hamming",
-    int(Image.Resampling.BICUBIC): "bicubic",
-    int(Image.Resampling.LANCZOS): "lanczos",
-}
-
-
-def _generate_multlist(bit_count: int = 2, min_value: int = -10, max_value: int = 20, mode: str = "Stable_Uniform"):
-    n = 1 << int(bit_count)
-    if n <= 1:
-        return [int(round((min_value + max_value) / 2))]
-    if mode == "Random":
-        rng = np.random.default_rng(2003)
-        vals = sorted(set(int(x) for x in rng.integers(min_value, max_value + 1, size=max(n * 8, 32))))
-        if len(vals) >= n:
-            return vals[:n]
-    return [int(round(x)) for x in np.linspace(min_value, max_value, n)]
-
-
-def _normalize_kwargs(kwargs):
-    kwargs = dict(kwargs)
-    kwargs.pop("display_autos", None)
-    kwargs.pop("use_numba", None)
-    kwargs.pop("save_path", None)
-
-    if "decay_params" in kwargs:
-        decay = kwargs.pop("decay_params") or {}
-        kwargs.setdefault("decay_cutoff", decay.get("cutoff", -1))
-        kwargs.setdefault("decay_softness", decay.get("softness", -1))
-        kwargs.setdefault("decay_progress", decay.get("progress", -1))
-
-    aliases = {
-        "strokes_per_quadrant": "focus_strokes",
-        "quadrant_warmup_time": "focus_warmup",
-        "quadrant_max_bits": "focus_max_bits",
-        "quadrant_padding": "focus_padding",
-        "quadrant_selection_criteria": "focus_criteria",
-        "strokes_per_channel_cycle": "channel_cycle_strokes",
-        "channel_cycle_warmup_time": "channel_cycle_warmup",
-        "cycle_selection_criteria": "channel_cycle_criteria",
-    }
-    for old, new in aliases.items():
-        if old in kwargs:
-            kwargs.setdefault(new, kwargs.pop(old))
-
-    if kwargs.get("channel_cycle") == "123":
-        kwargs["channel_cycle"] = "Default"
-
-    if "downsample_alg" in kwargs:
-        alg = kwargs.pop("downsample_alg")
-        if isinstance(alg, str):
-            kwargs.setdefault("resample", alg.lower())
-        else:
-            kwargs.setdefault("resample", _RESAMPLE_FROM_PIL.get(int(alg), "bicubic"))
-
-    if "mult_list" in kwargs:
-        kwargs["mult_list"] = tuple(int(x) for x in kwargs["mult_list"])
-
-    return kwargs
-
-
-def _compress_stream(
-    img_pil=None,
-    stream_interval: int = 100,
-    save_filename=None,
-    config: PBCConfig | None = None,
-    **kwargs,
-):
-    """Single-pass streaming encoder.
-
-    This mirrors PBC.compress setup, then runs the stroke loop once and yields
-    intermediate canvas frames every `stream_interval` strokes. It does not
-    recompress from scratch per frame.
-    """
-    if img_pil is None:
-        img_pil = kwargs.pop("img", None)
-    if img_pil is None:
-        return
-
-    cfg = replace(config or PBCConfig(), **_normalize_kwargs(kwargs))
-    pil = Image.open(img_pil).convert("RGB") if isinstance(img_pil, str) else Image.fromarray(img_pil).convert("RGB") if isinstance(img_pil, np.ndarray) else img_pil.convert("RGB")
-    original_size = pil.size
-    cfg = _prepare_config(original_size, cfg)
-    resample = RESAMPLE[cfg.resample]
-
-    work_pil = pil
-    if cfg.downsample_rate > 1:
-        work_pil = pil.resize((max(1, int(pil.width / cfg.downsample_rate)), max(1, int(pil.height / cfg.downsample_rate))), resample)
-
-    target = np.asarray(work_pil, dtype=np.int16)
-    if cfg.color_space == "YCbCr":
-        target = _rgb_to_ycbcr(target)
-    h, w = target.shape[:2]
-    start = _start_color(target, cfg)
-
-    init = np.empty((0, 0, 3), dtype=np.uint8)
-    init_store = init
-    if cfg.downsample_initialize:
-        ih = max(1, int(h / cfg.downsample_initialize_rate))
-        iw = max(1, int(w / cfg.downsample_initialize_rate))
-        init = np.asarray(work_pil.resize((iw, ih), resample), dtype=np.uint8)
-        if cfg.downsample_initialize_bits < 8:
-            init = ((init >> (8 - cfg.downsample_initialize_bits)) << (8 - cfg.downsample_initialize_bits)).astype(np.uint8)
-            init_store = (init >> (8 - cfg.downsample_initialize_bits)).astype(np.uint8)
-        else:
-            init_store = init
-        canvas = np.asarray(Image.fromarray(init).resize((w, h), resample), dtype=np.int16)
-        if cfg.color_space == "YCbCr":
-            canvas = _rgb_to_ycbcr(canvas)
-    else:
-        canvas = np.full((h, w, 3), start, dtype=np.int16)
-
-    s0, s1 = cfg.size_range
-    if s0 == -1:
-        s0 = 0.3 + (1 / 1.00095) ** (cfg.stroke_count + 7000)
-    if s1 == -1:
-        s1 = 0.01 + (1 / 1.00015) ** (cfg.stroke_count + 10200)
-    sizes, cutoff, soft, prog = _decay(
-        cfg.stroke_count,
-        int(s0 * (min(h, w) - 2)) + 2,
-        int(s1 * (min(h, w) - 2)) + 2,
-        cfg.decay_cutoff,
-        cfg.decay_softness,
-        cfg.decay_progress,
-    )
-
-    if cfg.focus_mode == "sampled" or (cfg.focus_mode == "auto" and min(h, w) >= cfg.focus_sample_threshold):
-        focus_mode_id = 2
-    elif cfg.focus_mode in ("auto", "exact"):
-        focus_mode_id = 1
-    else:
-        raise ValueError("focus_mode must be 'auto', 'exact', or 'sampled'")
-
-    mults = np.asarray(cfg.mult_list, dtype=np.int16)
-    indices = np.zeros((cfg.stroke_count, 4), dtype=np.uint16)
-    focus_codes = np.full(cfg.stroke_count, -1, dtype=np.int64)
-    focus_bits = np.zeros(cfg.stroke_count, dtype=np.uint8)
-    cycle_codes = np.full((cfg.stroke_count, 3), -1, dtype=np.int64)
-
-    focus_warmup = int(cfg.focus_warmup * cfg.stroke_count)
-    cycle_warmup = int(cfg.channel_cycle_warmup * cfg.stroke_count)
-    focus_counters = [focus_warmup // 3] * 3
-    active_focus_codes = [0, 0, 0]
-    active_focus_bits = [0, 0, 0]
-    selector = [0, 1, 2]
-    cycle_timer = cycle_warmup
-    state = np.uint64(cfg.seed)
-
-    cycle_mode = CYCLE[cfg.channel_cycle]
-    placement = PLACEMENT[cfg.placement_mode]
-    stream_interval = max(1, int(stream_interval))
-    next_stream = 0
-    last_yield = -1
-    approx_header_bits = 512 + (init_store.size * cfg.downsample_initialize_bits if cfg.downsample_initialize else 0)
-    mult_bits = int(np.ceil(np.log2(len(cfg.mult_list))))
-
-    for i in range(cfg.stroke_count):
-        channel = selector[i % 3]
-        size = int(sizes[i])
-        target_layer = target[:, :, channel]
-        canvas_layer = canvas[:, :, channel]
-
-        if focus_counters[channel] <= 0:
-            bits = int(_focus_bitcount(h, w, size, cfg.focus_max_bits))
-            if focus_mode_id == 2:
-                code = int(_select_focus_sampled(target_layer, canvas_layer, h, w, bits, cfg.focus_sample_side))
-            else:
-                code = int(_select_focus_exact(target_layer, canvas_layer, h, w, bits, CRITERIA[cfg.focus_criteria]))
-            active_focus_codes[channel] = code
-            active_focus_bits[channel] = bits
-            focus_codes[i] = code
-            focus_bits[i] = bits
-            focus_counters[channel] = cfg.focus_strokes
-
-        if cycle_mode != 0 and cycle_timer <= 0:
-            order = _channel_selector(target, canvas, cycle_mode, CRITERIA[cfg.channel_cycle_criteria])
-            selector = [int(order[0]), int(order[1]), int(order[2])]
-            cycle_codes[i, 0], cycle_codes[i, 1], cycle_codes[i, 2] = selector[0], selector[1], selector[2]
-            cycle_timer = cfg.channel_cycle_strokes
-
-        if active_focus_bits[channel] > 0:
-            rs, cs, re, ce = _focus_bounds(h, w, size, active_focus_codes[channel], active_focus_bits[channel], cfg.focus_padding)
-        else:
-            rs, cs, re, ce = 0, 0, h - size, w - size
-
-        state, row, col = _coords(state, i, placement, rs, cs, re, ce, size)
-        state = np.uint64(state)
-        row = int(row)
-        col = int(col)
-        half = size // 2
-
-        indices[i, 0] = _apply_tile(target_layer, canvas_layer, row, row + half, col, col + half, mults)
-        indices[i, 1] = _apply_tile(target_layer, canvas_layer, row, row + half, col + half, col + size, mults)
-        indices[i, 2] = _apply_tile(target_layer, canvas_layer, row + half, row + size, col, col + half, mults)
-        indices[i, 3] = _apply_tile(target_layer, canvas_layer, row + half, row + size, col + half, col + size, mults)
-
-        focus_counters[channel] -= 1
-        if cycle_mode != 0:
-            cycle_timer -= 1
-
-        if i >= next_stream:
-            next_stream = i + stream_interval
-            last_yield = i
-            frame = np.clip(canvas, 0, 255)
-            frame = _ycbcr_to_rgb(frame) if cfg.color_space == "YCbCr" else frame.astype(np.uint8)
-            frame_pil = Image.fromarray(frame)
-            if cfg.downsample_rate > 1:
-                frame_pil = frame_pil.resize(original_size, resample)
-            yield frame_pil, f"Processed {i + 1}/{cfg.stroke_count} strokes. {((i + 1) / cfg.stroke_count) * 100:.2f}%", approx_header_bits + (i + 1) * 4 * mult_bits, []
-
-    final = np.clip(canvas, 0, 255)
-    final = _ycbcr_to_rgb(final) if cfg.color_space == "YCbCr" else final.astype(np.uint8)
-    final_img_pil = Image.fromarray(final)
-    if cfg.downsample_rate > 1:
-        final_img_pil = final_img_pil.resize(original_size, resample)
-
-    data, header_bits, total_bits = _pack(
-        cfg,
-        w,
-        h,
-        original_size,
-        sizes,
-        ((cfg.decay_cutoff == -1, cutoff), (cfg.decay_softness == -1, soft), (cfg.decay_progress == -1, prog)),
-        start,
-        init_store,
-        (indices, focus_codes, focus_bits, cycle_codes),
-    )
-
-    if save_filename not in (None, False, -1):
-        with open(save_filename, "wb") as f:
-            f.write(data)
-
-    out = np.asarray(final_img_pil, dtype=np.uint8)
-    src = np.asarray(pil, dtype=np.uint8)
-    losses = [int(np.mean((src[:, :, c].astype(np.float32) - out[:, :, c].astype(np.float32)) ** 2)) for c in range(3)]
-    orig_bits = pil.size[0] * pil.size[1] * 3 * 8
-    bit_stats = "\n========================\nBITSTREAM STATS:\n"
-    bit_stats += f"Header: {header_bits} bits\n"
-    bit_stats += f"Strokes: {total_bits - header_bits} bits\n"
-    bit_stats += f"Total: {total_bits / 8 / 1024:.2f} KB from {orig_bits / 8 / 1024:.2f} KB original ({(total_bits / orig_bits) * 100:.2f}% size, {orig_bits / total_bits:.2f}x compression)\n"
-    bit_stats += "========================\n"
-
-    if last_yield != cfg.stroke_count - 1:
-        yield final_img_pil, bit_stats, total_bits, losses
-
-
-PBC.generate_multlist = staticmethod(_generate_multlist)
-PBC.compress_stream = staticmethod(_compress_stream)

server.py

@@ -11,18 +11,20 @@ from fastapi.staticfiles import StaticFiles
 from PIL import Image
 import numpy as np
 
-from PBC2_4 import PBC
-import PBC2_4_stream_patch  # registers PBC.generate_multlist and PBC.compress_stream
+from PBC2_3 import PBC
 
-app = FastAPI(title="PBC Demo")
+app = FastAPI(title="PBC Compression Demo")
 
-RESAMPLE_NAME = {
-    "Lanczos": "lanczos",
-    "Bicubic": "bicubic",
-    "Bilinear": "bilinear",
-    "Nearest": "nearest",
+RESAMPLE = {
+    "Lanczos": Image.LANCZOS,
+    "Bicubic": Image.BICUBIC,
+    "Bilinear": Image.BILINEAR,
+    "Nearest": Image.NEAREST,
 }
 
+# High-resolution multiplier list (bit count 7, range -255..255) for the landing
+# teaser. Compression rate is irrelevant there, so a richer palette just makes the
+# streamed build look better without costing extra time.
 DEMO_MULT_LIST = list(PBC.generate_multlist(7, -255, 255, "Stable_Uniform"))
 
 
@@ -32,8 +34,9 @@ def _png_b64(img: Image.Image) -> str:
     return "data:image/png;base64," + base64.b64encode(buf.getvalue()).decode()
 
 
-def _pbc_b64(data: bytes) -> str:
-    return base64.b64encode(data).decode()
+def _pbc_b64(bitstream: str) -> str:
+    b_data, pad_len = PBC._bits_to_bytes(bitstream)
+    return base64.b64encode(bytes([pad_len]) + bytes(b_data)).decode()
 
 
 def _f(v, d):
@@ -51,74 +54,6 @@ def _truthy(v):
     return str(v).lower() == "true"
 
 
-def _channel_cycle(v):
-    return "Default" if v == "123" else v
-
-
-def _manual_kwargs(
-    stroke_count,
-    downsample_initialize_rate,
-    downsample_initialize,
-    size_range_start,
-    size_range_end,
-    color_space,
-    downsample_rate,
-    downsample_alg,
-    start_mode,
-    decay_mode,
-    decay_cutoff,
-    decay_softness,
-    decay_progress,
-    mult_list,
-    strokes_per_quadrant,
-    quadrant_warmup_time,
-    quadrant_max_bits,
-    quadrant_padding,
-    quadrant_selection_criteria,
-    channel_cycle,
-    strokes_per_channel_cycle,
-    channel_cycle_warmup_time,
-    cycle_selection_criteria,
-    focus_mode,
-    focus_sample_side,
-    focus_sample_threshold,
-    downsample_initialize_bits,
-):
-    try:
-        mlist = tuple(int(x) for x in ast.literal_eval(mult_list))
-        assert mlist
-    except (ValueError, SyntaxError, AssertionError, TypeError):
-        mlist = (-10, 0, 5, 20)
-
-    return dict(
-        stroke_count=_i(stroke_count, -1),
-        size_range=(_f(size_range_start, 0.3), _f(size_range_end, 0.01)),
-        mult_list=mlist,
-        start_mode=start_mode,
-        decay_cutoff=-1.0 if decay_mode == "Auto" else _f(decay_cutoff, 0.5),
-        decay_softness=-1.0 if decay_mode == "Auto" else _f(decay_softness, 0.5),
-        decay_progress=-1.0 if decay_mode == "Auto" else _f(decay_progress, 0.5),
-        focus_strokes=_i(strokes_per_quadrant, 100),
-        focus_warmup=_f(quadrant_warmup_time, 0.5),
-        focus_max_bits=_i(quadrant_max_bits, 8),
-        focus_padding=_i(quadrant_padding, 4),
-        focus_criteria=quadrant_selection_criteria,
-        focus_mode=focus_mode,
-        focus_sample_side=_i(focus_sample_side, 384),
-        focus_sample_threshold=_i(focus_sample_threshold, 1536),
-        channel_cycle=_channel_cycle(channel_cycle),
-        channel_cycle_strokes=_i(strokes_per_channel_cycle, 100),
-        channel_cycle_warmup=_f(channel_cycle_warmup_time, 0.9),
-        channel_cycle_criteria=cycle_selection_criteria,
-        color_space=color_space,
-        downsample_rate=_f(downsample_rate, -1),
-        downsample_initialize=_truthy(downsample_initialize),
-        downsample_initialize_rate=_f(downsample_initialize_rate, 16),
-        downsample_initialize_bits=_i(downsample_initialize_bits, 8),
-        resample=RESAMPLE_NAME.get(downsample_alg, "bicubic"),
-    )
-
-
 @app.get("/api/multlist")
 def multlist(bit_count: int = 2, min: int = -10, max: int = 20, mode: str = "Stable_Uniform"):
     return {"list": list(PBC.generate_multlist(bit_count, min, max, mode))}
@@ -151,10 +86,6 @@ async def compress(
     strokes_per_channel_cycle: str = Form("100"),
     channel_cycle_warmup_time: str = Form("0.9"),
     cycle_selection_criteria: str = Form("Min"),
-    focus_mode: str = Form("auto"),
-    focus_sample_side: str = Form("384"),
-    focus_sample_threshold: str = Form("1536"),
-    downsample_initialize_bits: str = Form("8"),
 ):
     raw_bytes = await image.read()
     img = Image.open(io.BytesIO(raw_bytes)).convert("RGB")
@@ -167,56 +98,57 @@ async def compress(
             stroke_count=_i(stroke_count, -1),
             downsample_initialize=_truthy(downsample_initialize),
             downsample_initialize_rate=_f(downsample_initialize_rate, 16),
-            downsample_initialize_bits=_i(downsample_initialize_bits, 8),
         )
-    else:
-        kwargs = _manual_kwargs(
-            stroke_count,
-            downsample_initialize_rate,
-            downsample_initialize,
-            size_range_start,
-            size_range_end,
-            color_space,
-            downsample_rate,
-            downsample_alg,
-            start_mode,
-            decay_mode,
-            decay_cutoff,
-            decay_softness,
-            decay_progress,
-            mult_list,
-            strokes_per_quadrant,
-            quadrant_warmup_time,
-            quadrant_max_bits,
-            quadrant_padding,
-            quadrant_selection_criteria,
-            channel_cycle,
-            strokes_per_channel_cycle,
-            channel_cycle_warmup_time,
-            cycle_selection_criteria,
-            focus_mode,
-            focus_sample_side,
-            focus_sample_threshold,
-            downsample_initialize_bits,
+    else:  # Manual
+        decay = {"cutoff": -1, "softness": -1, "progress": -1} if decay_mode == "Auto" else {
+            "cutoff": _f(decay_cutoff, 0.5),
+            "softness": _f(decay_softness, 0.5),
+            "progress": _f(decay_progress, 0.5),
+        }
+        try:
+            mlist = [int(x) for x in ast.literal_eval(mult_list)]
+            assert mlist
+        except (ValueError, SyntaxError, AssertionError, TypeError):
+            mlist = [-10, 0, 5, 20]
+        kwargs = dict(
+            stroke_count=_i(stroke_count, -1),
+            size_range=(_f(size_range_start, 0.3), _f(size_range_end, 0.01)),
+            mult_list=mlist,
+            start_mode=start_mode,
+            decay_params=decay,
+            strokes_per_quadrant=_i(strokes_per_quadrant, 100),
+            quadrant_warmup_time=_f(quadrant_warmup_time, 0.5),
+            quadrant_max_bits=_i(quadrant_max_bits, 8),
+            quadrant_padding=_i(quadrant_padding, 4),
+            quadrant_selection_criteria=quadrant_selection_criteria,
+            channel_cycle=channel_cycle,
+            strokes_per_channel_cycle=_i(strokes_per_channel_cycle, 100),
+            channel_cycle_warmup_time=_f(channel_cycle_warmup_time, 0.9),
+            cycle_selection_criteria=cycle_selection_criteria,
+            color_space=color_space,
+            downsample_rate=_f(downsample_rate, -1),
+            downsample_initialize=_truthy(downsample_initialize),
+            downsample_initialize_rate=_f(downsample_initialize_rate, 16),
+            downsample_alg=RESAMPLE.get(downsample_alg, Image.BICUBIC),
         )
 
     timer = time.time()
-    result = PBC.compress(img, **kwargs)
+    reconstructed, _stats, bitstream, _losses = PBC.compress(img_pil=img, save_filename=None, **kwargs)
     elapsed = time.time() - timer
 
-    reconstructed = result.image.convert("RGB")
+    # Full-resolution MSE/PSNR: original vs the upsampled reconstruction.
     a = np.asarray(img, dtype=np.float32)
-    b = np.asarray(reconstructed.resize(img.size), dtype=np.float32)
+    b = np.asarray(reconstructed.convert("RGB").resize(img.size), dtype=np.float32)
     mse = float(np.mean((a - b) ** 2))
     psnr = 10 * math.log10(255.0 ** 2 / mse) if mse > 0 else 99.0
 
     original_raw = w * h * 3
-    compressed = len(result.data)
+    compressed = len(bitstream) / 8
 
     return JSONResponse({
         "original_image": _png_b64(img),
         "reconstructed_image": _png_b64(reconstructed),
-        "pbc_base64": _pbc_b64(result.data),
+        "pbc_base64": _pbc_b64(bitstream),
         "width": w,
         "height": h,
         "original_raw_kb": round(original_raw / 1024, 2),
@@ -227,7 +159,7 @@ async def compress(
         "mse": round(mse, 1),
         "psnr": round(psnr, 2),
         "time_seconds": round(elapsed, 2),
-        "params": {"mode": mode, **{k: (list(v) if isinstance(v, tuple) else v) for k, v in kwargs.items()}},
+        "params": {"mode": mode, **{k: (list(v) if isinstance(v, tuple) else v) for k, v in kwargs.items() if k not in ("downsample_alg", "decay_params")}},
     })
 
 
@@ -235,18 +167,12 @@ async def compress(
 async def stream_compress(image: UploadFile = File(...), downsample_initialize: str = Form("false")):
     raw = await image.read()
     img = Image.open(io.BytesIO(raw)).convert("RGB")
+    dsi = _truthy(downsample_initialize)
 
     def gen():
         for item in PBC.compress_stream(
-            img_pil=img,
-            save_filename=None,
-            mult_list=tuple(DEMO_MULT_LIST),
-            stroke_count=-1,
-            stream_interval=150,
-            downsample_initialize=_truthy(downsample_initialize),
-            downsample_rate=1,
-            focus_warmup=1.0,
-            channel_cycle=False,
+            img_pil=img, save_filename=None,
+            mult_list=DEMO_MULT_LIST, stream_interval=150,
         ):
             frame = item[0]
             if isinstance(frame, Image.Image):
@@ -258,8 +184,11 @@ async def stream_compress(image: UploadFile = File(...), downsample_initialize:
 @app.post("/api/decode")
 async def decode(file: UploadFile = File(...)):
     raw = await file.read()
+    pad_len = raw[0]
+    bitstream = PBC._bytes_to_bits(raw[1:], pad_len)
+
     timer = time.time()
-    img = PBC.decompress(raw).convert("RGB")
+    img = PBC.decompress(bitstream).convert("RGB")
     elapsed = time.time() - timer
 
     w, h = img.size

static/app.js

@@ -344,7 +344,6 @@ function gotoView(v) {
 const PARAMS = [
   { id: "stroke_count", label: "Stroke count", hint: "higher = better quality but slower and less compression", group: "Core", modes: ["Semi", "Manual"], type: "slider", min: 0, max: 200000, step: 1000, value: 40000, full: true },
   { id: "downsample_initialize_rate", label: "Downsample init rate", group: "Core", modes: ["Semi", "Manual"], type: "slider", min: 2, max: 32, step: 0.1, value: 16, disableToggle: true },
-  { id: "downsample_initialize_bits", label: "Downsample init bits", hint: "8 = raw, 6–7 = smaller init layer", group: "Core", modes: ["Semi", "Manual"], type: "slider", min: 4, max: 8, step: 1, value: 8 },
 
   { id: "size_range_start", label: "Size range start", group: "Strokes", modes: ["Manual"], type: "slider", min: 0.001, max: 1, step: 0.001, value: 0.3 },
   { id: "size_range_end", label: "Size range end", group: "Strokes", modes: ["Manual"], type: "slider", min: 0.001, max: 1, step: 0.001, value: 0.01 },
@@ -365,15 +364,11 @@ const PARAMS = [
   { id: "mult_max", label: "Multiplier maximum", group: "Multiplier list", modes: ["Manual"], type: "slider", min: -255, max: 255, step: 1, value: 20 },
   { id: "mult_list", label: "Multiplier list", hint: "editable", group: "Multiplier list", modes: ["Manual"], type: "text", value: "[-10, 0, 5, 20]", gen: true },
 
-  { id: "strokes_per_quadrant", label: "Strokes / focus region", group: "Focus", modes: ["Manual"], type: "slider", min: 10, max: 1000, step: 10, value: 100 },
-  { id: "quadrant_warmup_time", label: "Focus warmup", group: "Focus", modes: ["Manual"], type: "slider", min: 0, max: 1, step: 0.01, value: 0.5 },
-  { id: "quadrant_max_bits", label: "Focus max bits", group: "Focus", modes: ["Manual"], type: "slider", min: 1, max: 32, step: 1, value: 8 },
-  { id: "quadrant_padding", label: "Focus padding", group: "Focus", modes: ["Manual"], type: "slider", min: 0, max: 32, step: 1, value: 4 },
-  { id: "quadrant_selection_criteria", label: "Focus selection", group: "Focus", modes: ["Manual"], type: "select", options: ["Sum", "Max", "Min"], value: "Sum" },
-
-  { id: "focus_mode", label: "Focus mode", hint: "auto uses sampled focus on large canvases", group: "Focus", modes: ["Manual"], type: "select", options: ["auto", "exact", "sampled"], value: "auto" },
-  { id: "focus_sample_side", label: "Sampled focus side", group: "Focus", modes: ["Manual"], type: "slider", min: 128, max: 1024, step: 128, value: 384 },
-  { id: "focus_sample_threshold", label: "Sampled focus threshold", group: "Focus", modes: ["Manual"], type: "slider", min: 512, max: 4096, step: 128, value: 1536 },
+  { id: "strokes_per_quadrant", label: "Strokes / quadrant", group: "Quadrants", modes: ["Manual"], type: "slider", min: 10, max: 1000, step: 10, value: 100 },
+  { id: "quadrant_warmup_time", label: "Quadrant warmup", group: "Quadrants", modes: ["Manual"], type: "slider", min: 0, max: 1, step: 0.01, value: 0.5 },
+  { id: "quadrant_max_bits", label: "Quadrant max bits", group: "Quadrants", modes: ["Manual"], type: "slider", min: 1, max: 32, step: 1, value: 8 },
+  { id: "quadrant_padding", label: "Quadrant padding", group: "Quadrants", modes: ["Manual"], type: "slider", min: 0, max: 32, step: 1, value: 4 },
+  { id: "quadrant_selection_criteria", label: "Quadrant selection", group: "Quadrants", modes: ["Manual"], type: "select", options: ["Sum", "Max", "Min"], value: "Sum" },
 
   { id: "channel_cycle", label: "Channel cycle strategy", group: "Channel cycle", modes: ["Manual"], type: "select", options: ["Smart", "Strict", "Balanced", "123"], value: "Smart" },
   { id: "strokes_per_channel_cycle", label: "Strokes / cycle", group: "Channel cycle", modes: ["Manual"], type: "slider", min: 10, max: 1000, step: 10, value: 100 },

static/index.html

@@ -16,7 +16,7 @@
 <section id="landing" class="section landing">
   <div class="landing-grid">
     <div class="landing-left">
-      <p class="eyebrow">PBC · v2.4</p>
+      <p class="eyebrow">PBC · v2.3</p>
       <h1 class="title">Probabilistic <em>Brush</em> Compression.</h1>
       <p class="lede">
         An unconventional lossy image compression algorithm. It compresses image

static/styles.css

@@ -63,7 +63,7 @@ em{font-style:normal;color:var(--red);}
 .roster-hint{font-family:'JetBrains Mono',monospace;font-size:11px;color:var(--faint);letter-spacing:.1em;margin:0;}
 .roster-note{font-size:11px;color:var(--faint);opacity:.8;margin:0;text-align:center;max-width:340px;}
 .roster-note .x{transition:opacity .2s;}
-.landing-right.use-real .roster-note .x{text-decoration:line-through;opacity:.4;}
+.landing-right.use-real .roster-note .x{text-decoration:line-through;opacity:.2;}
 .landing-right.use-real .roster-hint{visibility:hidden;}
 .real-toggle{display:flex;align-items:center;gap:.45rem;font-size:11.5px;color:var(--dim);cursor:pointer;margin:.2rem 0 0;user-select:none;position:relative;z-index:2;}
 .real-toggle input{accent-color:var(--red);width:14px;height:14px;cursor:pointer;}