allRGB

Periodic System v4

2026-02-16T12:51:09+01:00

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from __future__ import annotations

import argparse
import math
import os
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Dict, List, Tuple, Optional

import numpy as np
from PIL import Image, ImageDraw, ImageFont
import colorsys

USE_NUMBA = False
try:
    from numba import njit  # type: ignore
    USE_NUMBA = True
except Exception:
    USE_NUMBA = False

WIDTH = 4096
HEIGHT = 4096
TOTAL_COLORS = WIDTH * HEIGHT  # 16,777,216

ELEMENT_COUNT = 128
GRID_COLS = 16
GRID_ROWS = 8
CELL_W = WIDTH // GRID_COLS   # 256
CELL_H = HEIGHT // GRID_ROWS  # 512

TEXT_MARGIN = 12
LINE_GAP = 10
AA_SCALE_DEFAULT = 2

# Thicker borders
BORDER_THICK_DEFAULT = 4  # px

# Bin quantization
BIN_SHIFT = 3
BINS_PER_CH = 256 >> BIN_SHIFT  # 32
NBINS = BINS_PER_CH * BINS_PER_CH * BINS_PER_CH  # 32768


ELEMENT_SYMBOLS = [
    "H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne",
    "Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca",
    "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn",
    "Ga", "Ge", "As", "Se", "Br", "Kr", "Rb", "Sr", "Y", "Zr",
    "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn",
    "Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Ce", "Pr", "Nd",
    "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb",
    "Lu", "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg",
    "Tl", "Pb", "Bi", "Po", "At", "Rn", "Fr", "Ra", "Ac", "Th",
    "Pa", "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm",
    "Md", "No", "Lr", "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Ds",
    "Rg", "Cn", "Nh", "Fl", "Mc", "Lv", "Ts", "Og"
]

ELEMENT_NAMES = [
    "Hydrogen", "Helium", "Lithium", "Beryllium", "Boron", "Carbon", "Nitrogen", "Oxygen", "Fluorine", "Neon",
    "Sodium", "Magnesium", "Aluminium", "Silicon", "Phosphorus", "Sulfur", "Chlorine", "Argon", "Potassium", "Calcium",
    "Scandium", "Titanium", "Vanadium", "Chromium", "Manganese", "Iron", "Cobalt", "Nickel", "Copper", "Zinc",
    "Gallium", "Germanium", "Arsenic", "Selenium", "Bromine", "Krypton", "Rubidium", "Strontium", "Yttrium", "Zirconium",
    "Niobium", "Molybdenum", "Technetium", "Ruthenium", "Rhodium", "Palladium", "Silver", "Cadmium", "Indium", "Tin",
    "Antimony", "Tellurium", "Iodine", "Xenon", "Caesium", "Barium", "Lanthanum", "Cerium", "Praseodymium", "Neodymium",
    "Promethium", "Samarium", "Europium", "Gadolinium", "Terbium", "Dysprosium", "Holmium", "Erbium", "Thulium", "Ytterbium",
    "Lutetium", "Hafnium", "Tantalum", "Tungsten", "Rhenium", "Osmium", "Iridium", "Platinum", "Gold", "Mercury",
    "Thallium", "Lead", "Bismuth", "Polonium", "Astatine", "Radon", "Francium", "Radium", "Actinium", "Thorium",
    "Protactinium", "Uranium", "Neptunium", "Plutonium", "Americium", "Curium", "Berkelium", "Californium", "Einsteinium", "Fermium",
    "Mendelevium", "Nobelium", "Lawrencium", "Rutherfordium", "Dubnium", "Seaborgium", "Bohrium", "Hassium", "Meitnerium", "Darmstadtium",
    "Roentgenium", "Copernicium", "Nihonium", "Flerovium", "Moscovium", "Livermorium", "Tennessine", "Oganesson"
]


def generate_symbol(n: int) -> str:
    if n <= 118:
        return ELEMENT_SYMBOLS[n - 1]
    digit_to_letter = ['n', 'u', 'b', 't', 'q', 'p', 'h', 's', 'o', 'e']
    return ''.join(digit_to_letter[int(d)] for d in str(n)).capitalize()[:3]


def generate_name(n: int) -> str:
    if n <= 118:
        return ELEMENT_NAMES[n - 1]
    roots = ['nil', 'un', 'bi', 'tri', 'quad', 'pent', 'hex', 'sept', 'oct', 'enn']
    digits = [int(d) for d in str(n)]
    parts = [roots[d] for d in digits]
    if parts[-1] in ('bi', 'tri'):
        parts[-1] = parts[-1][:-1]
    for i in range(len(parts) - 1):
        if parts[i] == 'enn' and parts[i + 1] == 'nil':
            parts[i] = 'en'
    return ''.join(parts).capitalize() + "ium"


def generate_weight(n: int) -> str:
    return f"[{n:.1f}]"


def classify_element(n: int) -> str:
    if n == 1: return "nonmetal"
    if n in [2,10,18,36,54,86,118]: return "noble_gas"
    if n in [5,14,32,33,51,52,84]: return "metalloid"
    if n in [9,17,35,53,85,117]: return "halogen"
    if n in [6,7,8,15,16,34]: return "nonmetal"
    if n in [3,11,19,37,55,87,119]: return "alkali"
    if n in [4,12,20,38,56,88,120]: return "alkaline"
    if 57 <= n <= 71: return "lanthanide"
    if 89 <= n <= 103: return "actinide"
    if 104 <= n <= 112 or (21 <= n <= 30) or (39 <= n <= 48) or (72 <= n <= 80): return "transition"
    if (13 <= n <= 16) or (31 <= n <= 34) or (49 <= n <= 52) or (81 <= n <= 84): return "post_transition"
    if 121 <= n <= 138: return "actinide"
    return "unknown"


def generate_spiral_grid(cols: int, rows: int) -> List[List[int]]:
    grid = [[-1] * cols for _ in range(rows)]
    cx, cy = cols // 2, rows // 2
    x, y = cx, cy
    dx = [1, 0, -1, 0]
    dy = [0, 1, 0, -1]
    steps = 1
    dir_idx = 0
    count = 1
    while count <= cols * rows:
        for _ in range(2):
            for _ in range(steps):
                if 0 <= x < cols and 0 <= y < rows:
                    grid[y][x] = count
                    count += 1
                    if count > cols * rows:
                        return grid
                x += dx[dir_idx]
                y += dy[dir_idx]
            dir_idx = (dir_idx + 1) % 4
        steps += 1
    return grid


def dilate8(mask: np.ndarray) -> np.ndarray:
    p = np.pad(mask, 1, mode="constant", constant_values=False)
    c = p[1:-1, 1:-1]
    n = p[:-2, 1:-1]
    s = p[2:, 1:-1]
    w = p[1:-1, :-2]
    e = p[1:-1, 2:]
    nw = p[:-2, :-2]
    ne = p[:-2, 2:]
    sw = p[2:, :-2]
    se = p[2:, 2:]
    return c | n | s | w | e | nw | ne | sw | se


def _candidate_font_dirs() -> List[Path]:
    dirs: List[Path] = []
    windir = os.environ.get("WINDIR", r"C:\Windows")
    dirs.append(Path(windir) / "Fonts")
    dirs += [Path("/Library/Fonts"), Path.home() / "Library" / "Fonts"]
    dirs += [Path("/usr/share/fonts"), Path("/usr/local/share/fonts"), Path.home() / ".fonts"]
    return [d for d in dirs if d.exists()]


def find_font_file(name_substr: str, prefer_bold: bool) -> Optional[str]:
    name_substr_l = name_substr.lower()
    exts = (".ttf", ".otf", ".ttc")
    best: Optional[Path] = None
    best_score = -1
    for d in _candidate_font_dirs():
        try:
            if sys.platform.startswith("win"):
                paths = [d / p for p in os.listdir(d)]
            else:
                paths = list(d.glob("*")) + list(d.glob("*/*")) + list(d.glob("*/*/*"))
        except Exception:
            continue
        for p in paths:
            if not p.is_file() or p.suffix.lower() not in exts:
                continue
            fn = p.name.lower()
            if name_substr_l not in fn:
                continue
            score = 0
            if prefer_bold:
                if "bold" in fn: score += 50
                if "semibold" in fn or "demi" in fn: score += 30
            else:
                if "regular" in fn or "book" in fn: score += 20
                if "bold" in fn: score -= 10
            if "myriad" in fn: score += 10
            if "pro" in fn: score += 5
            if score > best_score:
                best_score = score
                best = p
    return str(best) if best else None


@dataclass
class Fonts:
    small: ImageFont.FreeTypeFont
    regular: ImageFont.FreeTypeFont
    bold: ImageFont.FreeTypeFont


def load_fonts(cell_h: int, font_regular_path: Optional[str], font_bold_path: Optional[str], aa_scale: int) -> Fonts:
    fs_symbol = max(28, int(cell_h * 0.20)) * aa_scale
    fs_reg = max(18, int(cell_h * 0.08)) * aa_scale
    fs_small = max(14, int(cell_h * 0.05)) * aa_scale

    reg_path = font_regular_path or find_font_file("Myriad", prefer_bold=False) or "DejaVuSans.ttf"
    bold_path = font_bold_path or find_font_file("Myriad", prefer_bold=True) or reg_path

    small = ImageFont.truetype(reg_path, fs_small)
    regular = ImageFont.truetype(reg_path, fs_reg)
    bold = ImageFont.truetype(bold_path, fs_symbol)
    return Fonts(small=small, regular=regular, bold=bold)


def render_text_mask(cell_w: int, cell_h: int, n: int, fonts: Fonts, aa_scale: int) -> np.ndarray:
    Wb = cell_w * aa_scale
    Hb = cell_h * aa_scale
    mask_big = Image.new("L", (Wb, Hb), 0)
    draw = ImageDraw.Draw(mask_big)

    lines = [
        (str(n), fonts.regular),
        (generate_symbol(n), fonts.bold),
        (generate_weight(n), fonts.regular),
        (generate_name(n), fonts.small),
    ]

    x = TEXT_MARGIN * aa_scale
    y = TEXT_MARGIN * aa_scale
    for text, font in lines:
        draw.text((x, y), text, font=font, fill=255)
        y += int(font.size + (LINE_GAP * aa_scale))

    mask_small = mask_big.resize((cell_w, cell_h), resample=Image.BOX)
    arr = np.asarray(mask_small, dtype=np.uint8)
    return arr >= 96


def compute_masks_for_cell(n: int, fonts: Fonts, aa_scale: int, border_thick: int) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
    label = render_text_mask(CELL_W, CELL_H, n, fonts, aa_scale)

    t = max(1, int(border_thick))
    border = np.zeros((CELL_H, CELL_W), dtype=bool)
    border[:t, :] = True
    border[-t:, :] = True
    border[:, :t] = True
    border[:, -t:] = True

    label = label & (~border)
    outline = dilate8(label) & (~label) & (~border)
    fill = ~(label | outline | border)
    return label, outline, border, fill


def bin_of_color_ids(ids: np.ndarray) -> np.ndarray:
    r = (ids >> 16) & 0xFF
    g = (ids >> 8) & 0xFF
    b = ids & 0xFF
    br = r >> BIN_SHIFT
    bg = g >> BIN_SHIFT
    bb = b >> BIN_SHIFT
    return (br << 10) | (bg << 5) | bb


if USE_NUMBA:
    @njit
    def _bin_of_color_numba(c: np.uint32) -> np.int32:
        r = (c >> 16) & 0xFF
        g = (c >> 8) & 0xFF
        b = c & 0xFF
        br = r >> BIN_SHIFT
        bg = g >> BIN_SHIFT
        bb = b >> BIN_SHIFT
        return (br << 10) | (bg << 5) | bb

    @njit
    def build_bin_pool_from_perm_numba(perm: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
        counts = np.zeros(NBINS, dtype=np.int32)
        n = perm.shape[0]
        for i in range(n):
            counts[_bin_of_color_numba(perm[i])] += 1

        start = np.empty(NBINS, dtype=np.int32)
        end = np.empty(NBINS, dtype=np.int32)
        s = 0
        for b in range(NBINS):
            start[b] = s
            s += counts[b]
            end[b] = s

        nxt = start.copy()
        grouped = np.empty(n, dtype=np.uint32)
        for i in range(n):
            c = perm[i]
            b = _bin_of_color_numba(c)
            j = nxt[b]
            grouped[j] = c
            nxt[b] = j + 1

        return grouped, start, end


def build_bin_pool_from_perm(perm: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
    if USE_NUMBA:
        return build_bin_pool_from_perm_numba(perm)

    bins = bin_of_color_ids(perm).astype(np.int32)
    counts = np.bincount(bins, minlength=NBINS).astype(np.int32)
    start = np.zeros(NBINS, dtype=np.int32)
    start[1:] = np.cumsum(counts[:-1])
    end = start + counts
    order = np.argsort(bins, kind="stable")
    grouped = perm[order]
    return grouped, start, end


@dataclass
class BinAllocator:
    grouped: np.ndarray
    cur: np.ndarray
    end: np.ndarray


class BinStream:
    def __init__(self, alloc: BinAllocator, bins_order: np.ndarray):
        self.a = alloc
        self.bins = bins_order.astype(np.int32, copy=False)
        self.i = 0

    def take(self, k: int) -> np.ndarray:
        out = np.empty(k, dtype=np.uint32)
        o = 0
        while o < k:
            if self.i >= self.bins.shape[0]:
                raise RuntimeError("BinStream exhausted bins_order.")
            b = int(self.bins[self.i])
            avail = int(self.a.end[b] - self.a.cur[b])
            if avail <= 0:
                self.i += 1
                continue
            n = min(avail, k - o)
            s = int(self.a.cur[b]); e = s + n
            out[o:o+n] = self.a.grouped[s:e]
            self.a.cur[b] = e
            o += n
            if self.a.cur[b] >= self.a.end[b]:
                self.i += 1
        return out


@dataclass
class CellInfo:
    n: int
    col: int
    row: int
    series: str


def build_cells() -> List[CellInfo]:
    spiral = generate_spiral_grid(GRID_COLS, GRID_ROWS)
    pos_by_element: Dict[int, Tuple[int, int]] = {}
    for y in range(GRID_ROWS):
        for x in range(GRID_COLS):
            n = spiral[y][x]
            if 1 <= n <= ELEMENT_COUNT:
                pos_by_element[n] = (x, y)
    cells: List[CellInfo] = []
    for n in range(1, ELEMENT_COUNT + 1):
        col, row = pos_by_element[n]
        cells.append(CellInfo(n=n, col=col, row=row, series=classify_element(n)))
    return cells


def cell_bounds(col: int, row: int) -> Tuple[int, int, int, int]:
    x0 = col * CELL_W
    y0 = row * CELL_H
    return x0, y0, x0 + CELL_W, y0 + CELL_H


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--out", default="periodic_table_allrgb_128_spiral.png")
    ap.add_argument("--seed", type=int, default=1)
    ap.add_argument("--aa", type=int, default=AA_SCALE_DEFAULT)
    ap.add_argument("--border", type=int, default=BORDER_THICK_DEFAULT, help="Border thickness in pixels (default: 4)")
    ap.add_argument("--font-regular", default=None)
    ap.add_argument("--font-bold", default=None)
    args = ap.parse_args()

    aa_scale = max(1, int(args.aa))
    border_thick = max(1, int(args.border))

    cells = build_cells()
    fonts = load_fonts(CELL_H, args.font_regular, args.font_bold, aa_scale)

    # Count masks + series demand
    total_label = total_outline = total_border = 0
    fill_by_series: Dict[str, int] = {}
    for c in cells:
        label, outline, border, fill = compute_masks_for_cell(c.n, fonts, aa_scale, border_thick)
        total_label += int(label.sum())
        total_outline += int(outline.sum())
        total_border += int(border.sum())
        fill_by_series[c.series] = fill_by_series.get(c.series, 0) + int(fill.sum())

    if total_label + total_outline + total_border + sum(fill_by_series.values()) != TOTAL_COLORS:
        raise RuntimeError("Mask accounting mismatch.")

    # Bin metrics
    def precompute_bin_metrics():
        hue = np.zeros(NBINS, dtype=np.float32)
        sat = np.zeros(NBINS, dtype=np.float32)
        val = np.zeros(NBINS, dtype=np.float32)
        for b in range(NBINS):
            br = (b >> 10) & 31
            bg = (b >> 5) & 31
            bb = b & 31
            rc = (br << BIN_SHIFT) + (1 << (BIN_SHIFT - 1))
            gc = (bg << BIN_SHIFT) + (1 << (BIN_SHIFT - 1))
            bc = (bb << BIN_SHIFT) + (1 << (BIN_SHIFT - 1))
            h, s, v = colorsys.rgb_to_hsv(rc / 255.0, gc / 255.0, bc / 255.0)
            hue[b] = h; sat[b] = s; val[b] = v
        return hue, sat, val

    hue, sat, val = precompute_bin_metrics()
    bins = np.arange(NBINS, dtype=np.int32)

    # Dark/light/border bin orders (unchanged)
    dark_bins = bins[np.lexsort((-(sat.astype(np.float64)), val.astype(np.float64)))]
    light_bins = bins[np.lexsort((sat.astype(np.float64), -val.astype(np.float64)))]
    border_bins = bins[np.lexsort((-val.astype(np.float64), np.abs(val.astype(np.float64) - 0.5), sat.astype(np.float64)))]

    # FILL bin order: push low-saturation (gray-ish) bins to the end
    # Primary: is_gray (0 first, 1 last), then hue, then prefer higher sat/val.
    S_GRAY = 0.20
    is_gray = (sat < S_GRAY).astype(np.int32)
    fill_bins = bins[np.lexsort((
        -val.astype(np.float64),
        -sat.astype(np.float64),
        hue.astype(np.float64),
        is_gray.astype(np.float64),  # primary (last key): colorful first, grays last
    ))]

    rng = np.random.default_rng(args.seed)
    perm = rng.permutation(TOTAL_COLORS).astype(np.uint32)
    grouped, start, end = build_bin_pool_from_perm(perm)

    alloc = BinAllocator(grouped=grouped, cur=start.copy(), end=end)
    label_stream = BinStream(alloc, dark_bins)
    outline_stream = BinStream(alloc, light_bins)
    border_stream = BinStream(alloc, border_bins)
    fill_stream = BinStream(alloc, fill_bins)

    label_colors = label_stream.take(total_label)
    outline_colors = outline_stream.take(total_outline)
    border_colors = border_stream.take(total_border)

    series_order = sorted(fill_by_series.keys())
    series_fill_colors: Dict[str, np.ndarray] = {}
    for s in series_order:
        series_fill_colors[s] = fill_stream.take(fill_by_series[s])

    img_ids = np.zeros((HEIGHT, WIDTH), dtype=np.uint32)

    idx_label = idx_outline = idx_border = 0
    idx_fill = {s: 0 for s in series_order}

    for c in cells:
        x0, y0, x1, y1 = cell_bounds(c.col, c.row)
        cell = img_ids[y0:y1, x0:x1]  # view

        label, outline, border, fill = compute_masks_for_cell(c.n, fonts, aa_scale, border_thick)

        # Fill
        fill_idx = np.flatnonzero(fill)
        kf = fill_idx.size
        if kf:
            chunk = series_fill_colors[c.series][idx_fill[c.series]: idx_fill[c.series] + kf]
            idx_fill[c.series] += kf
            rr = np.random.default_rng((args.seed * 1000003 + c.n) & 0xFFFFFFFF)
            rr.shuffle(fill_idx)
            yy = fill_idx // CELL_W
            xx = fill_idx % CELL_W
            cell[yy, xx] = chunk

        # Border (now thicker)
        border_idx = np.flatnonzero(border)
        kb = border_idx.size
        if kb:
            yy = border_idx // CELL_W
            xx = border_idx % CELL_W
            cell[yy, xx] = border_colors[idx_border: idx_border + kb]
            idx_border += kb

        # Outline
        outline_idx = np.flatnonzero(outline)
        ko = outline_idx.size
        if ko:
            yy = outline_idx // CELL_W
            xx = outline_idx % CELL_W
            cell[yy, xx] = outline_colors[idx_outline: idx_outline + ko]
            idx_outline += ko

        # Label
        label_idx = np.flatnonzero(label)
        kl = label_idx.size
        if kl:
            yy = label_idx // CELL_W
            xx = label_idx % CELL_W
            cell[yy, xx] = label_colors[idx_label: idx_label + kl]
            idx_label += kl

    # Convert packed ids -> RGB
    rgb = np.empty((HEIGHT, WIDTH, 3), dtype=np.uint8)
    rgb[..., 0] = ((img_ids >> 16) & 0xFF).astype(np.uint8)
    rgb[..., 1] = ((img_ids >> 8) & 0xFF).astype(np.uint8)
    rgb[..., 2] = (img_ids & 0xFF).astype(np.uint8)

    Image.fromarray(rgb, "RGB").save(args.out)
    print(f"✅ Saved: {args.out}")


if __name__ == "__main__":
    main()

The Prism Cross

2026-02-16T10:15:17+01:00

This piece explores the limits of digital display by forcing every possible color onto a rigid, linear grid. The horizontal artifacts and noise textures are not random; they are the result of a rigorous mapping process that ensures no two pixels share the same hex code. The result is a vibrant, flickering cross-section of the visible digital universe.

24-Bit Horizon

2026-02-16T10:06:23+01:00

A modern take on pointillism through the lens of computer science. By mapping the entire RGB color cube onto a figurative landscape, this piece explores how the human eye perceives form and gradients even when every pixel is a distinct, non-repeating hue. The rolling hills and water serve as a canvas for a perfect mathematical distribution of light and color.

The Spectrum Nautilus

2026-02-16T10:05:59+01:00

A digital exploration of mathematical perfection and organic form. This $4096 \times 4096$ spiral maps the entire 24-bit RGB color space into a singular, continuous growth pattern. By arranging all 16,777,216 unique colors into a logarithmic flow, the piece mimics the proportions of a sea shell, bridging the gap between cold data and natural beauty.

Ganesha

2026-02-14T12:03:05+01:00

The Benevolent Guardian

Static Bloom

2026-02-14T11:59:36+01:00

flower and the digital "static"

Favicons v1

2026-02-10T22:25:08+01:00

Shortcut icons for the 256² most popular websites.

Made with Chatgpt, Google Colab, Google Drive, and Python.

M87 Black Hole v2

2026-02-07T21:15:33+01:00

Unlike the first M87 Black Hole image on this site, this version uses actual eso data.

# Colab-ready: AllRGB (4096x4096) encoding of the EHT/ESO polarized M87* image (eso2105a)
# Bias: dark pixels -> neutral near-black colors; bright pixels -> orange-ish colors
# Still uses every 24-bit RGB value exactly once.

import os
import gc
import requests
import numpy as np
from PIL import Image

# -----------------------------
# Settings
# -----------------------------
OUT_SIZE = 4096
N = OUT_SIZE * OUT_SIZE  # 16,777,216

ESO_TIF = "https://cdn.eso.org/images/original/eso2105a.tif"
ESO_JPG = "https://cdn.eso.org/images/large/eso2105a.jpg"

DOWNLOAD_PATH = "eso2105a_source"
OUT_PNG = "m87_polarized_allrgb_orange_black_4096.png"

# 0..65280 (because we use integer Rec.709 weights summing to 256)
# Increase to push "neutral blacks" deeper into midtones; decrease to make orange bias kick in earlier.
DARK_LUMA_CUTOFF = 12000

# -----------------------------
# Helpers
# -----------------------------
def download(url: str, path: str, chunk=1<<20):
    print("Downloading:", url)
    r = requests.get(url, stream=True, timeout=60)
    r.raise_for_status()
    with open(path, "wb") as f:
        for b in r.iter_content(chunk_size=chunk):
            if b:
                f.write(b)
    return path

def load_source_image():
    tif_path = DOWNLOAD_PATH + ".tif"
    jpg_path = DOWNLOAD_PATH + ".jpg"

    if not os.path.exists(tif_path) and not os.path.exists(jpg_path):
        try:
            download(ESO_TIF, tif_path)
            path = tif_path
        except Exception as e:
            print("TIFF download failed, falling back to JPEG.\nReason:", repr(e))
            download(ESO_JPG, jpg_path)
            path = jpg_path
    else:
        path = tif_path if os.path.exists(tif_path) else jpg_path

    img = Image.open(path).convert("RGB")
    print("Loaded:", path, "size:", img.size)
    return img

def center_crop_to_square(img: Image.Image) -> Image.Image:
    w, h = img.size
    s = min(w, h)
    left = (w - s) // 2
    top = (h - s) // 2
    return img.crop((left, top, left + s, top + s))

def resize_to_4096(img: Image.Image) -> Image.Image:
    return img.resize((OUT_SIZE, OUT_SIZE), resample=Image.LANCZOS)

def luma16_from_rgb_u8(rgb_u8: np.ndarray) -> np.ndarray:
    """
    Luma in 0..65280 using integer weights summing to 256:
      luma16 = 54*R + 183*G + 19*B
    """
    r = rgb_u8[..., 0].astype(np.uint32)
    g = rgb_u8[..., 1].astype(np.uint32)
    b = rgb_u8[..., 2].astype(np.uint32)
    return (54*r + 183*g + 19*b).astype(np.uint16)

def xor_u32_range(n: int) -> int:
    m = n - 1
    def xor_0_to(m):
        r = m & 3
        if r == 0: return m
        if r == 1: return 1
        if r == 2: return m + 1
        return 0
    return xor_0_to(m)

def orange_score_int(r, g, b):
    """
    Higher = more orange-ish (warm):
      prefer B low, R high, G mid, and R~G.
    Works on uint32 arrays; returns int16-ish range.
    """
    r = r.astype(np.int32)
    g = g.astype(np.int32)
    b = b.astype(np.int32)
    score = (2*r + g) - (4*b) - np.abs(r - g)
    # extra bias for "R>=G>=B"
    score += 256 * (r >= g).astype(np.int32)
    score += 256 * (g >= b).astype(np.int32)
    return score.astype(np.int32)

def neutral_score_int(r, g, b):
    """
    Higher = more neutral/gray (channels close).
    """
    r = r.astype(np.int32)
    g = g.astype(np.int32)
    b = b.astype(np.int32)
    d = np.abs(r - g) + np.abs(g - b)  # 0..510
    return (510 - d).astype(np.int32)

# -----------------------------
# 1) Load and prep the scientific image
# -----------------------------
src = load_source_image()
src_sq = center_crop_to_square(src)
src_4096 = resize_to_4096(src_sq)

target_rgb = np.asarray(src_4096, dtype=np.uint8)  # (4096,4096,3)
target_luma16 = luma16_from_rgb_u8(target_rgb)     # uint16 0..65280

# Compute per-pixel style key:
# - dark pixels: prefer neutralness
# - bright pixels: prefer orange-ness
Rpx = target_rgb[..., 0].astype(np.uint32)
Gpx = target_rgb[..., 1].astype(np.uint32)
Bpx = target_rgb[..., 2].astype(np.uint32)

px_orange = orange_score_int(Rpx, Gpx, Bpx)
px_neutral = neutral_score_int(Rpx, Gpx, Bpx)

# Style score switches based on darkness of the *pixel*:
px_style = np.where(target_luma16 < DARK_LUMA_CUTOFF, px_neutral, px_orange).astype(np.int32)

# Free PIL objects
del src, src_sq, src_4096
gc.collect()

# -----------------------------
# 2) Pixel order: (luma ascending, style descending within same luma)
# -----------------------------
print("Sorting pixels by (luma, style)...")
# lexsort: last key is primary -> primary=luma, secondary=-style
pix_order = np.lexsort((-px_style.reshape(-1), target_luma16.reshape(-1)))

del Rpx, Gpx, Bpx, px_orange, px_neutral, px_style
gc.collect()

# -----------------------------
# 3) Palette: allRGB values 0..2^24-1, sorted by (luma, style)
#    Dark luma -> prefer neutral blacks; bright luma -> prefer orange-ish
# -----------------------------
print("Building allRGB values 0..2^24-1 ...")
vals = np.arange(N, dtype=np.uint32)

r = (vals >> 16).astype(np.uint32)
g = ((vals >> 8) & 255).astype(np.uint32)
b = (vals & 255).astype(np.uint32)

pal_luma16 = (54*r + 183*g + 19*b).astype(np.uint16)

col_orange = orange_score_int(r, g, b)
col_neutral = neutral_score_int(r, g, b)
col_style = np.where(pal_luma16 < DARK_LUMA_CUTOFF, col_neutral, col_orange).astype(np.int32)

print("Sorting palette by (luma, style)...")
col_order = np.lexsort((-col_style, pal_luma16))
colors_sorted = vals[col_order]  # uint32 length N

del r, g, b, pal_luma16, col_orange, col_neutral, col_style, col_order, vals
gc.collect()

# -----------------------------
# 4) Assign: darkest pixels -> darkest colors, with the style bias within each luma
# -----------------------------
print("Assigning colors to pixels...")
out_flat = np.empty(N, dtype=np.uint32)
out_flat[pix_order] = colors_sorted

del pix_order, colors_sorted, target_rgb, target_luma16
gc.collect()

# -----------------------------
# 5) Unpack to uint8 RGB image and save
# -----------------------------
print("Unpacking to RGB and saving PNG...")
R = ((out_flat >> 16) & 255).astype(np.uint8)
G = ((out_flat >> 8) & 255).astype(np.uint8)
B = (out_flat & 255).astype(np.uint8)

out_rgb = np.stack([R, G, B], axis=1).reshape(OUT_SIZE, OUT_SIZE, 3)

# Fast permutation sanity checks (not a full uniqueness scan)
expected_sum = (np.uint64(N - 1) * np.uint64(N)) // 2
actual_sum = out_flat.astype(np.uint64).sum()
assert actual_sum == expected_sum, "Sum check failed (colors likely not a permutation)."

expected_xor = np.uint32(xor_u32_range(N))
actual_xor = np.bitwise_xor.reduce(out_flat.astype(np.uint32))
assert actual_xor == expected_xor, "XOR check failed (colors likely not a permutation)."

img_out = Image.fromarray(out_rgb, mode="RGB")
img_out.save(OUT_PNG, compress_level=3)
print("Wrote:", OUT_PNG)

# Optional preview (Colab)
try:
    import matplotlib.pyplot as plt
    plt.figure(figsize=(6, 6))
    plt.imshow(out_rgb)
    plt.axis("off")
    plt.show()
except Exception:
    pass

# Optional: download from Colab
# from google.colab import files
# files.download(OUT_PNG)

Made with Chatgpt, Python, and Google Colab.

Random Penta-Thread Weaver 8k (No AI)

2026-02-05T10:08:01+01:00

The algorithm works like this:

Pick a color and set a pixel to this color.
Repeat step 1 as many times as desired.
Pick a color.
Find the colored edge pixel closest in color to this color.
Set one of its uncolored 8-adjacent pixels to this color.
Go to step 3 unless all pixels have been colored.

Command line used:

./color -o2048x8192x8_5-starts.ppm -s2048:8192:8 -p1506,3613 -p714,3488 -p350,4202 -p917,4769 -p1631,4405

Generated with C code (Public Domain) from Christopher Wellons:

github.com/skeeto/every-rgb

Random Quad-Thread Weaver 4k (No AI)

2026-02-05T10:03:39+01:00

The algorithm works like this:

Pick a color and set a pixel to this color.
Repeat step 1 as many times as desired.
Pick a color.
Find the colored edge pixel closest in color to this color.
Set one of its uncolored 8-adjacent pixels to this color.
Go to step 3 unless all pixels have been colored.

Command line used:

 ./color -o4096x4096x8_4-starts.ppm -s4096:4096:8 -p0,0 -p4095,0 -p0,4095 -p4095,4095

Generated with C code (Public Domain) from Christopher Wellons:

github.com/skeeto/every-rgb

smiley face 2

2026-02-03T10:19:26+01:00

import random
from PIL import Image
from collections import defaultdict
img = Image.open("allthecolors.png").convert("RGB")
pixels = img.load()

def fillsquare(xcord, ycord, orient, zval):
    for x in range(256):
        for y in range(256):
            if orient == 1:
                pixels[xcord*256+x, ycord*256+255-y] = (x, y, zval)
            if orient == 2:
                pixels[xcord*256+255-x, ycord*256+255-y] = (x, y, zval)
            if orient == 3:
                pixels[xcord*256+255-x, ycord*256+y] = (x, y, zval)
            if orient == 4:
                pixels[xcord*256+x, ycord*256+y] = (x, y, zval)


which=defaultdict(int)
which[(2,2)]=1
which[(3,2)]=2
which[(4,2)]=1
which[(5,2)]=2
which[(5,3)]=3
which[(5,4)]=2
which[(5,5)]=3
which[(4,5)]=4
which[(3,5)]=3
which[(2,5)]=4
which[(2,4)]=1
which[(2,3)]=4
which[(3,3)]=3
which[(4,3)]=4
which[(3,4)]=2
which[(4,4)]=1


which[(15-2,2)]=1
which[(15-3,2)]=2
which[(15-4,2)]=1
which[(15-5,2)]=2
which[(15-5,3)]=3
which[(15-5,4)]=2
which[(15-5,5)]=3
which[(15-4,5)]=4
which[(15-3,5)]=3
which[(15-2,5)]=4
which[(15-2,4)]=1
which[(15-2,3)]=4
which[(15-3,3)]=3
which[(15-4,3)]=4
which[(15-3,4)]=2
which[(15-4,4)]=1

for j in range(1,7):
    which[(2*j,8)]=1
    which[(2*j+1,8)]=2
    which[(2*j,9)]=4
    which[(2*j+1,9)]=3

for j in range(2,6):
    which[(2*j,10)]=1
    which[(2*j+1,10)]=2
    which[(2*j,11)]=4
    which[(2*j+1,11)]=3

for j in range(3,5):
    which[(2*j,12)]=1
    which[(2*j+1,12)]=2
    which[(2*j,13)]=4
    which[(2*j+1,13)]=3


for x in range(16):
    for y in range(16):
        if which[(x,y)] != 0:
            fillsquare(x,y,which[(x,y)],16*x+y);
        else:
            fillsquare(x,y,x%2+1,16*x+y);


img.save("allthecolors.png")

Smiley Face

2026-02-03T08:36:30+01:00

import random
from PIL import Image
from collections import defaultdict
img = Image.open("allthecolors.png").convert("RGB")
pixels = img.load()

def fillsquare(xcord, ycord, orient, zval):
    for x in range(256):
        for y in range(256):
            if orient == 0:
                pixels[xcord*256+x, ycord*256+255-y] = (x, y, zval)
            if orient == 1:
                pixels[xcord*256+x, ycord*256+255-y] = (x, y, zval)
            if orient == 2:
                pixels[xcord*256+255-x, ycord*256+255-y] = (x, y, zval)
            if orient == 3:
                pixels[xcord*256+255-x, ycord*256+y] = (x, y, zval)
            if orient == 4:
                pixels[xcord*256+x, ycord*256+y] = (x, y, zval)


which=defaultdict(int)
which[(2,2)]=1
which[(3,2)]=2
which[(4,2)]=1
which[(5,2)]=2
which[(5,3)]=3
which[(5,4)]=2
which[(5,5)]=3
which[(4,5)]=4
which[(3,5)]=3
which[(2,5)]=4
which[(2,4)]=1
which[(2,3)]=4
which[(3,3)]=3
which[(4,3)]=4
which[(3,4)]=2
which[(4,4)]=1


which[(15-2,2)]=1
which[(15-3,2)]=2
which[(15-4,2)]=1
which[(15-5,2)]=2
which[(15-5,3)]=3
which[(15-5,4)]=2
which[(15-5,5)]=3
which[(15-4,5)]=4
which[(15-3,5)]=3
which[(15-2,5)]=4
which[(15-2,4)]=1
which[(15-2,3)]=4
which[(15-3,3)]=3
which[(15-4,3)]=4
which[(15-3,4)]=2
which[(15-4,4)]=1

for j in range(1,7):
    which[(2*j,8)]=1
    which[(2*j+1,8)]=2
    which[(2*j,9)]=4
    which[(2*j+1,9)]=3

for j in range(2,6):
    which[(2*j,10)]=1
    which[(2*j+1,10)]=2
    which[(2*j,11)]=4
    which[(2*j+1,11)]=3

for j in range(3,5):
    which[(2*j,12)]=1
    which[(2*j+1,12)]=2
    which[(2*j,13)]=4
    which[(2*j+1,13)]=3


for x in range(16):
    for y in range(16):
        fillsquare(x,y,which[(x,y)],16*x+y);

img.save("allthecolors.png")

Shades

2026-01-26T19:49:43+01:00

Simple euclidean distance squared algorithm but colors are also shaded depending on luminosity and redness.

The Chromatic Quilt

2026-01-10T19:39:31+01:00

A digital tapestry woven from the entire spectrum of human-visible computer color. The nested rectangular patterns evoke the feeling of a woven fabric, but with the cold, mathematical precision. Every thread of this quilt is a unique color value.

The Iris of Infinity

2026-01-10T19:34:56+01:00

Resembling a cosmic eye or a layered glass marble, this piece organizes 16.7 million unique pixels into smooth, circular gradients. The subtle shading between the rings gives the flat 2D plane a sense of depth and spherical volume, inviting the viewer to look deeper into the center of the spectrum.

The Glass Kaleidoscope

2026-01-10T19:34:05+01:00

Inspired by the way light fractures through a heavy prism. This piece separates every possible digital color into a sharp, angular dance of light and shadow. The dark "folds" between the color fans create a sense of three-dimensional depth, making the flat screen feel like a folded paper fan of pure light.

Pokédex 1–1024 v2

2026-01-08T15:03:52+01:00

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
all_colors_with_pokemon.py — "better" version focused on sprite fidelity + exact 24-bit coverage

Goals
- Output: 4096×4096 RGBA PNG.
- RGB: every 24-bit RGB value (0..16,777,215) appears **exactly once** in the whole image.
- Pokémon: a 32×32 grid of sprites (IDs 1..1024), drawn from the *same* 24-bit pool.
- Background alpha: 128; Sprite alpha: 255.
- Performance: GPU used for the big shuffle when available; CPU/Numba for the rest.

Key idea (why this works and why sprites don't turn into noise)
- The canvas starts as a full permutation of all 24-bit colors.
- For each sprite pixel, we swap its desired color (or a very close unused substitute if that RGB was already used
  by a previous sprite pixel) into that pixel location.
- For duplicates, instead of a slow global nearest-neighbor search (which often devolves into far-away colors
  and produces "noise"), we allocate substitute colors from a **quantized RGB bin pool**.
  This keeps substitutes near the original color and stays fast.

Dependencies
    pip install numpy pillow requests tqdm psutil numba cupy-cuda12x

Colab usage
    from google.colab import drive
    drive.mount('/content/drive')
    !pip install numpy pillow requests tqdm psutil numba cupy-cuda12x
    !python all_colors_with_pokemon.py
"""

import os
import logging
import psutil
from io import BytesIO

import numpy as np
from PIL import Image
import requests
from tqdm import tqdm
from numba import njit

# -----------------------------
# GPU shuffle (CuPy)
# -----------------------------
USE_GPU = True
try:
    import cupy as cp
except Exception:
    USE_GPU = False

# -----------------------------
# Configuration
# -----------------------------
IMAGE_SIZE = 4096
TOTAL_PIXELS = IMAGE_SIZE * IMAGE_SIZE  # 16,777,216
SEED = 42
POKE_COUNT = 1024
GRID = 32
TILE_SIZE = IMAGE_SIZE // GRID  # 128
SPRITE_CACHE_DIR = "/content/drive/MyDrive/pokemon_sprites"
OUTPUT_FILE = "all_colors_with_pokemon.png"

# Duplicate handling: quantized bins
# 32 bins per channel -> 32^3 = 32768 bins
BIN_SHIFT = 3  # 8 values per bin
BINS_PER_CH = 256 >> BIN_SHIFT  # 32
NBINS = BINS_PER_CH * BINS_PER_CH * BINS_PER_CH  # 32768
MAX_BIN_RING = 6  # expand search in bin-space (0..6) before global fallback

# Logging
logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logger = logging.getLogger(__name__)


def log_mem(stage: str):
    vm = psutil.virtual_memory()
    logger.info(f"[{stage}] RAM {vm.used//1024//1024}MB/{vm.total//1024//1024}MB")


# -----------------------------
# Sprite fetch & cache
# -----------------------------

def fetch_sprites() -> tuple[np.ndarray, np.ndarray]:
    """Return (positions, orig_colors) for fully opaque pixels only.

    - Sprites are cached to Google Drive.
    - We use NEAREST scaling for pixel-art crispness.

    Note: `.convert('RGBA')` is only done if the source image isn't already RGBA.
    It's negligible compared to network + resize, and it guarantees we have an alpha channel.
    """
    os.makedirs(SPRITE_CACHE_DIR, exist_ok=True)
    pos_list: list[int] = []
    col_list: list[int] = []

    for pid in tqdm(range(1, POKE_COUNT + 1), desc="Sprites"):
        cache_path = os.path.join(SPRITE_CACHE_DIR, f"{pid}.png")
        img = None

        if os.path.exists(cache_path):
            img = Image.open(cache_path)
        else:
            try:
                r = requests.get(f"https://pokeapi.co/api/v2/pokemon/{pid}/", timeout=10)
                r.raise_for_status()
                data = r.json()
                url = data["sprites"]["front_default"]
                if not url:
                    continue
                img = Image.open(BytesIO(requests.get(url, timeout=15).content))
                img.save(cache_path)
            except Exception as e:
                logger.warning(f"Sprite {pid} fetch failed: {e}")
                continue

        if img is None:
            continue

        if img.mode != "RGBA":
            img = img.convert("RGBA")

        img = img.resize((TILE_SIZE, TILE_SIZE), Image.NEAREST)
        arr = np.asarray(img, dtype=np.uint8)

        # fully opaque only (keeps edges crisp; no anti-aliased semi-alpha pixels)
        mask = arr[..., 3] == 255
        ys, xs = np.nonzero(mask)

        ids = (
            (arr[..., 0].astype(np.uint32) << 16)
            | (arr[..., 1].astype(np.uint32) << 8)
            | (arr[..., 2].astype(np.uint32))
        )

        row, col = divmod(pid - 1, GRID)
        y0, x0 = row * TILE_SIZE, col * TILE_SIZE

        for y, x in zip(ys, xs):
            pos_list.append(int((y0 + y) * IMAGE_SIZE + (x0 + x)))
            col_list.append(int(ids[y, x]))

    log_mem("After sprite fetch")
    return np.asarray(pos_list, dtype=np.int32), np.asarray(col_list, dtype=np.uint32)


# -----------------------------
# Bin pool construction
# -----------------------------

@njit
def _bin_of_color(c: np.uint32) -> np.int32:
    r = (c >> 16) & 0xFF
    g = (c >> 8) & 0xFF
    b = c & 0xFF
    br = r >> BIN_SHIFT
    bg = g >> BIN_SHIFT
    bb = b >> BIN_SHIFT
    return (br << (2 * 5)) + (bg << 5) + bb  # 5 bits per component (0..31)


@njit
def build_bin_pool_from_perm(perm: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
    """Group a color permutation into contiguous per-bin segments.

    Returns:
        grouped: uint32[N] colors, grouped by bin
        start:   int32[NBINS] inclusive start offset
        end:     int32[NBINS] exclusive end offset

    Order inside each bin inherits the randomness of `perm`.
    """
    counts = np.zeros(NBINS, dtype=np.int32)
    n = perm.shape[0]

    for i in range(n):
        b = _bin_of_color(perm[i])
        counts[b] += 1

    start = np.empty(NBINS, dtype=np.int32)
    end = np.empty(NBINS, dtype=np.int32)
    s = 0
    for b in range(NBINS):
        start[b] = s
        s += counts[b]
        end[b] = s

    # next write pointer per bin
    nxt = start.copy()
    grouped = np.empty(n, dtype=np.uint32)

    for i in range(n):
        c = perm[i]
        b = _bin_of_color(c)
        j = nxt[b]
        grouped[j] = c
        nxt[b] = j + 1

    return grouped, start, end


# -----------------------------
# Embedding with bin-based duplicate remap
# -----------------------------

@njit
def embed_swaps_binpool(
    perm: np.ndarray,
    pos_of_color: np.ndarray,
    positions: np.ndarray,
    orig_colors: np.ndarray,
    grouped: np.ndarray,
    start: np.ndarray,
    end: np.ndarray,
) -> None:
    """Swap desired colors into sprite positions.

    - First occurrence of a sprite RGB uses the exact color.
    - Duplicates allocate a new (unused-for-sprite) color from nearby quantized bins.

    This preserves exact global coverage because `perm` stays a permutation; we only swap.
    """
    used = np.zeros(TOTAL_PIXELS, dtype=np.bool_)

    # cursor per bin into `grouped`
    cur = start.copy()

    # global cursor for last-resort fallback
    global_cur = 0

    n = positions.shape[0]
    for i in range(n):
        p = positions[i]
        orig = orig_colors[i]

        # Choose c: exact if not used yet by sprite
        if not used[orig]:
            c = orig
            used[c] = True
        else:
            # Allocate near-by unused color from bin pool
            # Determine target bin from original
            b0 = _bin_of_color(orig)
            br0 = (b0 >> 10) & 31
            bg0 = (b0 >> 5) & 31
            bb0 = b0 & 31

            found = False

            # Expand ring in bin-space
            for ring in range(MAX_BIN_RING + 1):
                # iterate cube shell in bin coords (Chebyshev ring)
                rmin = br0 - ring
                rmax = br0 + ring
                gmin = bg0 - ring
                gmax = bg0 + ring
                bmin = bb0 - ring
                bmax = bb0 + ring

                if rmin < 0:
                    rmin = 0
                if gmin < 0:
                    gmin = 0
                if bmin < 0:
                    bmin = 0
                if rmax > 31:
                    rmax = 31
                if gmax > 31:
                    gmax = 31
                if bmax > 31:
                    bmax = 31

                for rr in range(rmin, rmax + 1):
                    for gg in range(gmin, gmax + 1):
                        for bb in range(bmin, bmax + 1):
                            if ring != 0:
                                # keep only the shell
                                if (abs(rr - br0) < ring and abs(gg - bg0) < ring and abs(bb - bb0) < ring):
                                    continue

                            b = (rr << 10) + (gg << 5) + bb
                            # pop next unused from this bin
                            while cur[b] < end[b]:
                                cand = grouped[cur[b]]
                                cur[b] += 1
                                if not used[cand]:
                                    c = cand
                                    used[c] = True
                                    found = True
                                    break
                            if found:
                                break
                        if found:
                            break
                    if found:
                        break
                if found:
                    break

            if not found:
                # Global fallback: advance through grouped until we find unused
                while global_cur < grouped.shape[0] and used[grouped[global_cur]]:
                    global_cur += 1
                if global_cur >= grouped.shape[0]:
                    # should never happen
                    c = 0
                else:
                    c = grouped[global_cur]
                    used[c] = True
                    global_cur += 1

        # Swap c into p
        src = pos_of_color[c]
        tmp = perm[p]
        perm[p] = c
        perm[src] = tmp
        pos_of_color[c] = p
        pos_of_color[tmp] = src


# -----------------------------
# Main
# -----------------------------

def main():
    log_mem("Start")

    # 1) Shuffle all colors (GPU if possible)
    if USE_GPU:
        try:
            rng = cp.random.RandomState(SEED)
            perm = cp.asnumpy(rng.permutation(cp.arange(TOTAL_PIXELS, dtype=cp.uint32)))
            log_mem("After GPU shuffle")
        except Exception as e:
            logger.warning(f"GPU shuffle failed, CPU fallback: {e}")
            perm = np.random.default_rng(SEED).permutation(TOTAL_PIXELS).astype(np.uint32)
            log_mem("After CPU shuffle")
    else:
        perm = np.random.default_rng(SEED).permutation(TOTAL_PIXELS).astype(np.uint32)
        log_mem("After CPU shuffle")

    # 2) Reverse lookup: position of each color in perm
    pos_of_color = np.empty(TOTAL_PIXELS, dtype=np.int32)
    for idx in range(TOTAL_PIXELS):
        pos_of_color[int(perm[idx])] = idx
    log_mem("After lookup build")

    # 3) Sprites
    positions, orig_colors = fetch_sprites()
    logger.info(f"Sprite pixels: {positions.size}")

    # 4) Build bin pools from the *random* permutation to get randomized candidates per bin
    logger.info("Building quantized bin pool from perm (Numba)…")
    grouped, start, end = build_bin_pool_from_perm(perm)
    log_mem("After bin pool")

    # 5) Embed (swap) with bin-based duplicate remap
    logger.info("Embedding sprites with bin-pool remap (Numba)…")
    embed_swaps_binpool(perm, pos_of_color, positions, orig_colors, grouped, start, end)
    log_mem("After embedding")

    # 6) Build RGBA buffer (RGB from perm, alpha background 128; sprite pixels 255)
    buf = np.empty((TOTAL_PIXELS, 4), dtype=np.uint8)
    buf[:, 0] = (perm >> 16) & 0xFF
    buf[:, 1] = (perm >> 8) & 0xFF
    buf[:, 2] = perm & 0xFF
    buf[:, 3] = 128
    buf[positions, 3] = 255
    log_mem("After buffer build")

    # 7) Optional: verify unique color count (expensive; enable if you want)
    # flat_ids = (buf[:,0].astype(np.uint32)<<16) | (buf[:,1].astype(np.uint32)<<8) | buf[:,2].astype(np.uint32)
    # u = np.unique(flat_ids).size
    # logger.info(f"Unique RGB count: {u}")

    img = Image.fromarray(buf.reshape((IMAGE_SIZE, IMAGE_SIZE, 4)), "RGBA")
    img.save(OUTPUT_FILE)
    log_mem("Done")


if __name__ == "__main__":
    main()

Saturation Gradient Balanced

2025-12-05T12:11:12+01:00

Paint splatter

2025-12-03T08:53:45+01:00

See https://www.reddit.com/r/generative/comments/1pcvp84/paint_splatter/ for discussion.

Smack My Higgs Up

2025-11-18T21:45:16+01:00

The initial prompt:

Can you write Python script that can run in a Google Colab notebook that generates an image that contains all 24-bit RGB colors exactly once, and that represents the discovery of the Higgs boson. If possible, I want you to use actual scattering data/imagery of the Large Hadron Collider.

After some back-and-forth, resulted in the following script:

import os
from io import BytesIO

import numpy as np
import pandas as pd
from PIL import Image
import matplotlib.pyplot as plt
import requests

# ---------------- Global configuration ----------------

CANVAS_SIZE  = 4096                  # 4096 x 4096 = 2^24
TOTAL_COLORS = 1 << 24               # 16,777,216

CSV_URL   = "https://zenodo.org/records/8034556/files/higgs2011.csv?download=1"
CSV_PATH  = "higgs2011.csv"

# Optional CMS event-display image (press-style)
EVENT_IMG_URL = (
    "https://upload.wikimedia.org/wikipedia/commons/3/32/"
    "CMS-PHO-EVENTS-2012-007-1.png"
)
USE_EVENT_DISPLAY = False  # set to True if you want to blend this in

OUTPUT_ALLRGB = "higgs_allrgb_4096_notext.png"


# ---------------- Data loading ----------------

def load_higgs_dataframe(local_path=CSV_PATH, url=CSV_URL):
    """
    Load the CMS Higgs 4-lepton CSV.
    If the file doesn't exist locally, download it from Zenodo.
    """
    if not os.path.exists(local_path):
        print(f"Downloading Higgs CSV from\n  {url}")
        resp = requests.get(url, timeout=120)
        resp.raise_for_status()
        with open(local_path, "wb") as f:
            f.write(resp.content)
        print(f"Saved as {local_path}")

    df = pd.read_csv(local_path)
    print("Loaded CSV with columns:")
    print(df.columns.tolist())
    print("Number of events:", len(df))
    return df


# ---------------- Higgs data → η–φ maps ----------------

def build_higgs_event_maps_from_df(df, mass_target=125.0, grid_size=1024):
    """
    Use the CMS Higgs 4-lepton CSV (E, px, py, pz, eta, phi for 4 leptons)
    to build:

      - intensity_map: 2D float32 in [0,1]
      - colour_map:    3D float32 in [0,1], RGB

    Steps:
      1) Compute the 4-lepton invariant mass per event.
      2) Pick the event with mass closest to `mass_target` (GeV).
      3) Paint each lepton as a Gaussian blob in (eta, phi).
         Intensity ~ pT, colour hue ~ phi, brightness ~ pT.
    """
    H = W = grid_size

    # Energies & momenta
    E_cols  = [f"E{i}"   for i in range(1, 5)]
    px_cols = [f"px{i}"  for i in range(1, 5)]
    py_cols = [f"py{i}"  for i in range(1, 5)]
    pz_cols = [f"pz{i}"  for i in range(1, 5)]

    for cols in (E_cols, px_cols, py_cols, pz_cols):
        for c in cols:
            if c not in df.columns:
                raise RuntimeError(f"Expected column '{c}' in dataframe, but it's missing.")

    # Total 4-vector per event
    E_tot  = df[E_cols].sum(axis=1).to_numpy(dtype=np.float64)
    px_tot = df[px_cols].sum(axis=1).to_numpy(dtype=np.float64)
    py_tot = df[py_cols].sum(axis=1).to_numpy(dtype=np.float64)
    pz_tot = df[pz_cols].sum(axis=1).to_numpy(dtype=np.float64)

    p2_tot = px_tot**2 + py_tot**2 + pz_tot**2
    m2_4l  = E_tot**2 - p2_tot
    m2_4l  = np.clip(m2_4l, 0.0, None)
    m4l    = np.sqrt(m2_4l)  # GeV

    # Event closest to target mass (≈125 GeV = Higgs)
    idx = np.abs(m4l - mass_target).argmin()
    ev  = df.iloc[idx]

    print(f"Selected event index: {idx}")
    print(f"Run: {ev['Run']}, Event: {ev['Event']}")
    print(f"4-lepton mass ≈ {m4l[idx]:.2f} GeV")

    # Kinematics for the 4 leptons
    eta_vals = np.array([ev[f"eta{i}"] for i in range(1, 5)], dtype=np.float32)
    phi_vals = np.array([ev[f"phi{i}"] for i in range(1, 5)], dtype=np.float32)
    px_vals  = np.array([ev[f"px{i}"]  for i in range(1, 5)], dtype=np.float32)
    py_vals  = np.array([ev[f"py{i}"]  for i in range(1, 5)], dtype=np.float32)
    pt_vals  = np.sqrt(px_vals**2 + py_vals**2)  # transverse momentum

    # (eta, phi) grid
    eta_min = float(eta_vals.min() - 0.5)
    eta_max = float(eta_vals.max() + 0.5)
    if eta_max - eta_min < 1.0:
        mid = 0.5 * (eta_min + eta_max)
        eta_min, eta_max = mid - 0.5, mid + 0.5

    phi_min = -np.pi
    phi_max =  np.pi

    y, x = np.mgrid[0:H, 0:W].astype(np.float32)
    eta_grid = eta_min + (eta_max - eta_min) * (y / (H - 1))
    phi_grid = phi_min + (phi_max - phi_min) * (x / (W - 1))

    intensity = np.zeros((H, W), dtype=np.float32)
    rgb       = np.zeros((H, W, 3), dtype=np.float32)
    weight    = np.zeros((H, W), dtype=np.float32)

    sigma_eta = 0.3 * max(eta_max - eta_min, 1.0)
    sigma_phi = 0.3 * (phi_max - phi_min)

    pt_max = float(pt_vals.max())
    if pt_max <= 0:
        pt_max = 1.0

    # Paint each lepton as a Gaussian blob
    for eta, phi, pt in zip(eta_vals, phi_vals, pt_vals):
        d_eta = eta_grid - eta
        # periodic wrap in phi
        d_phi = np.arctan2(np.sin(phi_grid - phi), np.cos(phi_grid - phi))

        g = np.exp(-0.5 * ((d_eta / sigma_eta) ** 2 + (d_phi / sigma_phi) ** 2))

        # Intensity contribution ~ pT * Gaussian
        w = float(pt)
        intensity += w * g

        # Colour: hue from phi, brightness from pT
        hue = (float(phi) + np.pi) / (2 * np.pi)  # 0..1
        val = float(pt) / pt_max                  # 0..1
        sat = 1.0

        # Simple HSV -> RGB (scalar h, choose 1 branch)
        h = hue * 6.0
        i = int(np.floor(h)) % 6
        f = h - np.floor(h)
        p = val * (1 - sat)
        q = val * (1 - sat * f)
        t = val * (1 - sat * (1 - f))

        r_c = np.zeros_like(g, dtype=np.float32)
        g_c = np.zeros_like(g, dtype=np.float32)
        b_c = np.zeros_like(g, dtype=np.float32)

        if i == 0:
            r_c[:, :], g_c[:, :], b_c[:, :] = val, t,   p
        elif i == 1:
            r_c[:, :], g_c[:, :], b_c[:, :] = q,   val, p
        elif i == 2:
            r_c[:, :], g_c[:, :], b_c[:, :] = p,   val, t
        elif i == 3:
            r_c[:, :], g_c[:, :], b_c[:, :] = p,   q,   val
        elif i == 4:
            r_c[:, :], g_c[:, :], b_c[:, :] = t,   p,   val
        else:
            r_c[:, :], g_c[:, :], b_c[:, :] = val, p,   q

        rgb[..., 0] += g * r_c
        rgb[..., 1] += g * g_c
        rgb[..., 2] += g * b_c
        weight      += g

    # Normalise intensity to [0,1]
    inten_min = float(intensity.min())
    inten_max = float(intensity.max())
    if inten_max > inten_min:
        intensity = (intensity - inten_min) / (inten_max - inten_min)
    else:
        intensity[:] = 0.0

    # Normalise RGB to [0,1]
    mask = weight > 0
    rgb[mask] /= weight[mask, None]

    rgb_min = float(rgb.min())
    rgb_max = float(rgb.max())
    if rgb_max > rgb_min:
        rgb = (rgb - rgb_min) / (rgb_max - rgb_min)
    else:
        rgb[:] = 0.0

    return intensity.astype(np.float32), rgb.astype(np.float32)


# ---------------- Analytic LHC pattern ----------------

def make_analytic_lhc_intensity(size=CANVAS_SIZE):
    """
    Analytic pattern: central glow, LHC ring, two beams.
    """
    H = W = size
    y, x = np.mgrid[0:H, 0:W].astype(np.float32)

    cx = (W - 1) / 2.0
    cy = (H - 1) / 2.0

    dx = x - cx
    dy = y - cy
    r  = np.sqrt(dx * dx + dy * dy)
    r_norm = r / r.max()

    central = np.clip(1.0 - r_norm**2, 0.0, 1.0)
    ring    = np.exp(-0.5 * ((r_norm - 0.7) / 0.05)**2)

    beam1 = np.exp(-0.5 * (dx / (0.01 * W))**2)
    beam2 = np.exp(-0.5 * (dy / (0.01 * H))**2)

    intensity = (
        0.35 * central +
        0.45 * ring +
        0.10 * beam1 +
        0.10 * beam2
    )
    intensity = np.clip(intensity, 0.0, 1.0).astype(np.float32)
    return intensity


# ---------------- Optional event-display image overlay ----------------

def load_event_display(max_side=None, url=EVENT_IMG_URL):
    """
    Load a (greyscale) event-display image if available, resize to fit max_side.
    """
    if max_side is None:
        max_side = int(CANVAS_SIZE * 0.8)

    try:
        print(f"Downloading event-display image from\n  {url}")
        resp = requests.get(url, timeout=60)
        resp.raise_for_status()
        im = Image.open(BytesIO(resp.content)).convert("L")
        w, h = im.size
        scale = min(max_side / float(w), max_side / float(h), 1.0)
        new_size = (max(1, int(w * scale)), max(1, int(h * scale)))
        if new_size != (w, h):
            im = im.resize(new_size, Image.BICUBIC)
        print("Event-display size:", im.size)
        return im
    except Exception as e:
        print("Warning: could not load event-display image:", e)
        return None


def blend_event_into_intensity(intensity, event_image, weight=0.5):
    """
    Blend an event-display image into the intensity map at the centre.
    intensity: 2D float32 [0,1]
    event_image: PIL L image
    """
    if event_image is None:
        return intensity

    H, W = intensity.shape
    ev = np.array(event_image, dtype=np.float32) / 255.0
    eh, ew = ev.shape

    x0 = (W - ew) // 2
    y0 = (H - eh) // 2

    sub = intensity[y0:y0 + eh, x0:x0 + ew]
    blended = np.clip((1.0 - weight) * sub + weight * ev, 0.0, 1.0)
    intensity[y0:y0 + eh, x0:x0 + ew] = blended
    return intensity


# ---------------- Combine intensity sources (NO TEXT) ----------------

def build_combined_intensity_map(df,
                                 size=CANVAS_SIZE,
                                 grid_size_data=1024,
                                 use_event_display=USE_EVENT_DISPLAY):
    """
    Build a 4096x4096 intensity map combining:
      - Analytic LHC ring+beams pattern
      - Data-driven Higgs event η–φ blobs
      - Optional event-display image
    (No text overlay.)
    Returns:
      combined_4k:  4096x4096 float32 [0,1]
      data_int:     grid_size_data x grid_size_data
      data_colour:  grid_size_data x grid_size_data x 3
    """
    # 1) Data-driven Higgs η–φ maps
    data_int, data_colour = build_higgs_event_maps_from_df(
        df,
        mass_target=125.0,
        grid_size=grid_size_data,
    )

    # Upscale data intensity to 4K
    data_int_u8 = Image.fromarray((np.clip(data_int, 0.0, 1.0) * 255).astype("uint8"))
    data_int_4k = np.array(
        data_int_u8.resize((size, size), resample=Image.BICUBIC),
        dtype=np.float32,
    ) / 255.0

    # 2) Analytic LHC pattern at 4K
    analytic_4k = make_analytic_lhc_intensity(size)

    # 3) Combine analytic + data (weights can be tuned)
    combined = 0.6 * analytic_4k + 0.8 * data_int_4k
    combined = np.clip(combined, 0.0, 1.0)

    # 4) Optional event-display overlay
    if use_event_display:
        event_img = load_event_display(max_side=int(size * 0.8))
        if event_img is not None:
            combined = blend_event_into_intensity(combined, event_img, weight=0.4)

    # 5) Final normalisation to [0,1]
    mn = float(combined.min())
    mx = float(combined.max())
    if mx > mn:
        combined = (combined - mn) / (mx - mn)
    else:
        combined[:] = 0.0

    return combined.astype(np.float32), data_int.astype(np.float32), data_colour.astype(np.float32)


# ---------------- AllRGB generator (simple luminance logic) ----------------

def generate_allrgb_from_intensity(intensity_4k, output_path=OUTPUT_ALLRGB,
                                   verify_permutation=True):
    """
    Given a 4096x4096 intensity field in [0,1], produce a 4096x4096 RGB image
    that uses every 24-bit color exactly once, assigning darker colors to
    darker pixels and vice versa.
    """
    H = W = CANVAS_SIZE
    assert intensity_4k.shape == (H, W), "intensity_4k must be 4096x4096"

    flat_intensity = intensity_4k.ravel().astype(np.float32)

    # Generate all 24-bit colors as integers 0xRRGGBB
    print("Generating full 24-bit RGB set...")
    colors = np.arange(TOTAL_COLORS, dtype=np.uint32)

    # Compute approximate sRGB luminance
    print("Computing luminance for all colors...")
    r = ((colors >> 16) & 0xFF).astype(np.float32)
    g = ((colors >> 8)  & 0xFF).astype(np.float32)
    b = (colors         & 0xFF).astype(np.float32)
    lum = 0.2126 * r + 0.7152 * g + 0.0722 * b
    del r, g, b

    # Sort pixels by target intensity (dark -> bright)
    print("Sorting pixels by intensity...")
    pixel_order = np.argsort(flat_intensity)
    del flat_intensity

    # Sort colors by luminance (dark -> bright)
    print("Sorting colors by luminance...")
    color_order = np.argsort(lum)
    del lum

    # Assign each color exactly once
    print("Assigning colors to pixels...")
    flat_result = np.empty(TOTAL_COLORS, dtype=np.uint32)
    flat_result[pixel_order] = colors[color_order]
    del pixel_order, color_order, colors

    # Optional permutation check
    if verify_permutation:
        print("Verifying that every 24-bit color is used exactly once...")
        sorted_result = np.sort(flat_result)
        reference     = np.arange(TOTAL_COLORS, dtype=np.uint32)
        assert np.array_equal(sorted_result, reference), "Color permutation check FAILED"
        del sorted_result, reference
        print("Permutation check passed ✅")

    # Reshape to RGB image and save
    print("Reshaping and saving PNG...")
    img_r = ((flat_result >> 16) & 0xFF).astype(np.uint8).reshape(H, W)
    img_g = ((flat_result >> 8)  & 0xFF).astype(np.uint8).reshape(H, W)
    img_b = (flat_result         & 0xFF).astype(np.uint8).reshape(H, W)
    del flat_result

    img = np.stack([img_r, img_g, img_b], axis=-1)
    out = Image.fromarray(img)
    out.save(output_path, format="PNG")
    print(f"Saved allRGB Higgs image as: {output_path}")


# ---------------- Main orchestration ----------------

def main():
    # 1) Load real CMS Higgs data
    df = load_higgs_dataframe()

    # 2) Build combined 4K intensity map + 1024² data previews
    combined_4k, data_int, data_colour = build_combined_intensity_map(
        df,
        size=CANVAS_SIZE,
        grid_size_data=1024,
        use_event_display=USE_EVENT_DISPLAY,
    )

    print("Combined 4K intensity shape:", combined_4k.shape)
    print("Data intensity shape        :", data_int.shape)
    print("Data colour shape          :", data_colour.shape)

    # 3) Save some previews
    gray_data   = Image.fromarray((np.clip(data_int, 0.0, 1.0) * 255).astype("uint8"))
    colour_data = Image.fromarray((np.clip(data_colour, 0.0, 1.0) * 255).astype("uint8"))
    gray_data.save("higgs_event_intensity_gray_1024.png")
    colour_data.save("higgs_event_intensity_colour_1024.png")

    combined_preview = Image.fromarray((combined_4k * 255).astype("uint8"))
    combined_preview_1024 = combined_preview.resize((1024, 1024), resample=Image.BICUBIC)
    combined_preview_1024.save("combined_intensity_preview_1024.png")

    # 4) Quick inline preview in Colab
    plt.figure(figsize=(15, 5))
    plt.subplot(1, 3, 1)
    plt.title("Higgs η–φ intensity (1024²)")
    plt.imshow(data_int, cmap="inferno", origin="lower")
    plt.axis("off")

    plt.subplot(1, 3, 2)
    plt.title("Higgs η–φ coloured (1024²)")
    plt.imshow(data_colour, origin="lower")
    plt.axis("off")

    plt.subplot(1, 3, 3)
    plt.title("Combined intensity (4K → 1024 preview, no text)")
    plt.imshow(np.array(combined_preview_1024, dtype=np.uint8),
               cmap="gray", origin="lower")
    plt.axis("off")

    plt.tight_layout()
    plt.show()

    # 5) Generate the 4096x4096 allRGB image
    generate_allrgb_from_intensity(combined_4k, output_path=OUTPUT_ALLRGB)


if __name__ == "__main__":
    main()

Testbeeld v1

2025-11-10T13:40:26+01:00

I used Chatgpt 5 Thinking to write Python code that generates an image inspired by output of the PM 5544 circle pattern generator that was used for test cards for all Dutch tv channels during my childhood.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
AllRGB Philips PM5544 generator (SVG + pooled color mapping)
------------------------------------------------------------

This script:

1. Loads a reference PM5544 image, which may be:
   - An SVG file (vector, via CairoSVG), or
   - A raster file (PNG/JPEG/etc., via Pillow).
2. Rasterizes (if SVG) and resizes it to fit inside a 4096×4096 square while
   preserving aspect ratio. The pattern is centered on a mid-grey background.
3. Treats the resulting 4096×4096 pixels as "target" colors.
4. Enumerates all 24-bit colors (0x000000 .. 0xFFFFFF).
5. Builds color "pools" for both targets and palette, based on luma and
   saturation (dark/mid/light greys, moderate colors, vivid colors).
6. Within each pool, assigns colors so that:
   - grey pools are mapped along luma gradients (good ramps and gray planes),
   - color pools are mapped by hue sector + luma (bars, patches and colored
     details get vivid colors of similar hue).
7. Writes out the resulting 4096×4096 image and verifies that every 24-bit
   color is used exactly once (permutation + XOR + channel sums).
"""

import io
import os
import time

import numpy as np
from PIL import Image


# ---------------------------------------------------------------------
# Configuration
# ---------------------------------------------------------------------
W = H = 4096
TOTAL_PIXELS = W * H
TOTAL_COLORS = 1 << 24  # 16,777,216

assert TOTAL_PIXELS == TOTAL_COLORS, "Canvas must have exactly 2^24 pixels."

# Path to your reference PM5544 image (SVG recommended).
REF_PATH = "pm5544.svg"   # <-- change this to your SVG/PNG path


# ---------------------------------------------------------------------
# Basic helpers
# ---------------------------------------------------------------------
def xor_0_to_n_minus_1(n: int) -> int:
    """XOR of integers 0..n-1 (closed form)."""
    m = n - 1
    r = m % 4
    if r == 0:
        return m
    elif r == 1:
        return 1
    elif r == 2:
        return m + 1
    else:
        return 0


def luma709_u8(r: np.ndarray, g: np.ndarray, b: np.ndarray) -> np.ndarray:
    """
    Approximate Rec.709 luma in 0..255 using integer math:

        Y ≈ (54*R + 183*G + 19*B + 128) >> 8
    """
    y = (54 * r.astype(np.uint32) +
         183 * g.astype(np.uint32) +
         19 * b.astype(np.uint32) + 128) >> 8
    return y.astype(np.uint16)


def hsv_sector(r: np.ndarray, g: np.ndarray, b: np.ndarray,
               s: np.ndarray) -> np.ndarray:
    """
    Rough HSV hue sector: 0=R,1=Y,2=G,3=C,4=B,5=M.

    Only meaningful when saturation s>0, but fine for global array.
    """
    r8 = r.astype(np.float32)
    g8 = g.astype(np.float32)
    b8 = b.astype(np.float32)

    maxi = np.maximum(np.maximum(r8, g8), b8)
    mini = np.minimum(np.minimum(r8, g8), b8)
    d = maxi - mini

    hue = np.zeros_like(maxi, dtype=np.float32)
    mr = (r8 >= g8) & (r8 >= b8)
    mg = (g8 > r8) & (g8 >= b8)
    mb = ~(mr | mg)

    idx = mr & (d > 0)
    hue[idx] = (60.0 * ((g8[idx] - b8[idx]) / d[idx]) + 360.0) % 360.0

    idx = mg & (d > 0)
    hue[idx] = 60.0 * ((b8[idx] - r8[idx]) / d[idx] + 2.0)

    idx = mb & (d > 0)
    hue[idx] = 60.0 * ((r8[idx] - g8[idx]) / d[idx] + 4.0)

    sec = np.floor(hue / 60.0).astype(np.int16) % 6
    return sec.astype(np.int8)


# ---------------------------------------------------------------------
# Reference image loading (SVG or raster)
# ---------------------------------------------------------------------
def load_reference_image(ref_path: str) -> Image.Image:
    """
    Load the reference image as a Pillow RGB image.

    - If ref_path ends with ".svg" (case-insensitive), use CairoSVG to
      rasterize the SVG to PNG bytes at high resolution, then load via Pillow.
    - Otherwise, open directly with Pillow and convert to RGB.
    """
    ext = os.path.splitext(ref_path)[1].lower()

    if ext == ".svg":
        import cairosvg

        with open(ref_path, "rb") as f:
            svg_bytes = f.read()

        # Render at least W wide; height will follow aspect.
        png_bytes = cairosvg.svg2png(bytestring=svg_bytes, output_width=W)
        img = Image.open(io.BytesIO(png_bytes)).convert("RGB")
    else:
        img = Image.open(ref_path).convert("RGB")

    return img


def load_reference_target(ref_path: str) -> np.ndarray:
    """
    Load the reference PM5544 image (SVG or raster), resize to fit inside
    4096×4096 while preserving aspect ratio, center on mid-grey, and return
    a flattened (N,3) uint8 array of target colors.
    """
    img = load_reference_image(ref_path)
    rw, rh = img.size

    # Scale to fit inside 4096×4096 preserving aspect ratio
    scale = min(W / rw, H / rh)
    new_w = int(round(rw * scale))
    new_h = int(round(rh * scale))

    # High-quality resample
    try:
        resample = Image.Resampling.LANCZOS
    except AttributeError:
        resample = Image.LANCZOS

    img_resized = img.resize((new_w, new_h), resample)

    # Start with mid-grey background
    canvas = np.full((H, W, 3), 128, dtype=np.uint8)

    # Center the resized pattern on the canvas
    ox = (W - new_w) // 2
    oy = (H - new_h) // 2
    arr_resized = np.asarray(img_resized, dtype=np.uint8)
    canvas[oy:oy + new_h, ox:ox + new_w, :] = arr_resized

    # Flatten to (N,3)
    target = canvas.reshape(-1, 3)
    assert target.shape == (TOTAL_PIXELS, 3)
    return target


# ---------------------------------------------------------------------
# Palette features and pooled assignment
# ---------------------------------------------------------------------
def build_palette_features() -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
    """
    Enumerate all 24-bit RGB colors and compute features:

        c    : 24-bit color as uint32 (0xRRGGBB)
        Y    : luma 0..255 (uint16)
        S    : saturation 0..255 (uint8)
        SEC  : hue sector 0..5 (int8)
    """
    N = TOTAL_COLORS
    c = np.arange(N, dtype=np.uint32)

    R = ((c >> 16) & 0xFF).astype(np.uint8)
    G = ((c >> 8) & 0xFF).astype(np.uint8)
    B = (c & 0xFF).astype(np.uint8)

    Y = luma709_u8(R, G, B)

    maxc = np.maximum(np.maximum(R, G), B)
    minc = np.minimum(np.minimum(R, G), B)
    S = (maxc.astype(np.int16) - minc.astype(np.int16)).astype(np.uint8)

    SEC = hsv_sector(R, G, B, S)

    # We don't keep R,G,B to save memory; we only need c, Y, S, SEC.
    return c, Y, S, SEC


def assign_colors_pooled(target: np.ndarray,
                         palette_features: tuple[np.ndarray, np.ndarray,
                                                 np.ndarray, np.ndarray]
                         ) -> np.ndarray:
    """
    Core "pooling" assignment:

    - Compute Y (luma), S (saturation), SEC (hue sector) for target pixels.
    - Classify both target and palette colors into 5 bands:
        0 = dark grey       (low S, low Y)
        1 = mid grey        (low S, mid Y)
        2 = light grey      (low S, high Y)
        3 = moderate colors (medium S)
        4 = vivid colors    (high S)
    - For each band b in [0,1,2,4,3]:
        * gather all target pixels in band b,
        * gather all unused palette colors in band b (or borrow from others),
        * inside band:
            - for grey bands 0..2:  sort target & palette by Y and match
            - for color bands 3,4:  sort by (SEC, Y) and match
    - Returns assigned_color: array of 24-bit color integers (0xRRGGBB),
      length N, such that each palette color is used exactly once.
    """
    N = target.shape[0]
    assert N == TOTAL_COLORS

    c, Yp, Sp, SECp = palette_features

    # Features for target
    Rt = target[:, 0].astype(np.uint8)
    Gt = target[:, 1].astype(np.uint8)
    Bt = target[:, 2].astype(np.uint8)

    Yt = luma709_u8(Rt, Gt, Bt)
    maxc_t = np.maximum(np.maximum(Rt, Gt), Bt)
    minc_t = np.minimum(np.minimum(Rt, Gt), Bt)
    St = (maxc_t.astype(np.int16) - minc_t.astype(np.int16)).astype(np.uint8)
    SECt = hsv_sector(Rt, Gt, Bt, St)

    # Band thresholds
    S_GRAY = 25   # how "grey" is "grey"
    Y_MID1 = 85   # dark -> mid
    Y_MID2 = 170  # mid -> light

    # Classify target into 5 bands
    band_t = np.empty(N, dtype=np.int8)
    grey_mask = St <= S_GRAY
    band_t[grey_mask & (Yt < Y_MID1)] = 0
    band_t[grey_mask & (Yt >= Y_MID1) & (Yt < Y_MID2)] = 1
    band_t[grey_mask & (Yt >= Y_MID2)] = 2
    color_mask = ~grey_mask
    band_t[color_mask & (St < 128)] = 3
    band_t[color_mask & (St >= 128)] = 4

    # Same classification for palette
    band_p = np.empty(N, dtype=np.int8)
    grey_mask_p = Sp <= S_GRAY
    band_p[grey_mask_p & (Yp < Y_MID1)] = 0
    band_p[grey_mask_p & (Yp >= Y_MID1) & (Yp < Y_MID2)] = 1
    band_p[grey_mask_p & (Yp >= Y_MID2)] = 2
    color_mask_p = ~grey_mask_p
    band_p[color_mask_p & (Sp < 128)] = 3
    band_p[color_mask_p & (Sp >= 128)] = 4

    used = np.zeros(N, dtype=bool)
    assigned_color = np.empty(N, dtype=np.uint32)

    # We'll process bands in this order:
    #  - greys first (they're the most visually sensitive),
    #  - then vivid colors,
    #  - then moderate colors.
    band_order = [0, 1, 2, 4, 3]

    # Precompute keys for palette (once)
    key_p_gray = Yp.astype(np.int32)
    key_p_color = (SECp.astype(np.int16) * 256 + Yp.astype(np.int16)).astype(np.int32)

    for b in band_order:
        tidx = np.flatnonzero(band_t == b)
        n_t = tidx.size
        if n_t == 0:
            continue

        cand = np.flatnonzero((~used) & (band_p == b))
        n_c = cand.size

        if b in (0, 1, 2):
            key_t = Yt.astype(np.int32)
            key_p = key_p_gray
        else:
            key_t = (SECt.astype(np.int16) * 256 + Yt.astype(np.int16)).astype(np.int32)
            key_p = key_p_color

        if n_c >= n_t:
            # Enough palette colors of this band.
            pal_all = cand
            t_sorted = tidx[np.argsort(key_t[tidx], kind="stable")]
            p_sorted = pal_all[np.argsort(key_p[pal_all], kind="stable")][:n_t]
        else:
            # Not enough colors in this band; borrow from others by key-proximity.
            pal_list = []
            if n_c > 0:
                pal_list.append(cand)
            remaining = n_t - n_c

            all_unused_other = np.flatnonzero(~used & (band_p != b))
            if remaining > all_unused_other.size:
                raise RuntimeError("Not enough palette colors remaining (should not happen).")

            # Pick additional colors whose key is closest to the band’s mean key.
            mean_key = int(key_t[tidx].mean())
            dist = np.abs(key_p[all_unused_other] - mean_key)
            extra = all_unused_other[np.argpartition(dist, remaining - 1)[:remaining]]
            pal_list.append(extra)

            pal_all = np.concatenate(pal_list)

            # Order within band
            t_sorted = tidx[np.argsort(key_t[tidx], kind="stable")]
            p_sorted = pal_all[np.argsort(key_p[pal_all], kind="stable")]

        assert p_sorted.size == n_t
        used[p_sorted] = True
        assigned_color[t_sorted] = c[p_sorted]

    assert used.all(), "Some palette colors were not used."
    return assigned_color


def build_allrgb_from_target(target: np.ndarray) -> Image.Image:
    """
    High-level: build AllRGB image from target colors using pooled mapping.
    """
    print("  Building palette features...")
    palette_features = build_palette_features()

    print("  Assigning 24-bit colors with pooled mapping...")
    assigned = assign_colors_pooled(target, palette_features)

    # Unpack 24-bit colors 0xRRGGBB into RGB image
    R = ((assigned >> 16) & 0xFF).astype(np.uint8)
    G = ((assigned >> 8) & 0xFF).astype(np.uint8)
    B = (assigned & 0xFF).astype(np.uint8)
    img_arr = np.stack([R, G, B], axis=1).reshape(H, W, 3)
    img = Image.fromarray(img_arr, mode="RGB")
    return img


# ---------------------------------------------------------------------
# Verification
# ---------------------------------------------------------------------
def verify_allrgb(img: Image.Image):
    """
    Verify:
      - XOR of all pixel values equals XOR of 0..(2^24-1).
      - Per-channel sums match the theoretical sums for all 24-bit colors.
    """
    arr = np.asarray(img, dtype=np.uint8).reshape(-1, 3)
    packed = (arr[:, 0].astype(np.uint32) << 16) | \
             (arr[:, 1].astype(np.uint32) << 8) | \
             arr[:, 2].astype(np.uint32)

    print("  Verifying XOR coverage...")
    xor_img = np.bitwise_xor.reduce(packed)
    xor_ref = xor_0_to_n_minus_1(TOTAL_COLORS)
    assert xor_img == xor_ref, "XOR coverage check failed."

    print("  Verifying per-channel sums...")
    # Each channel: every value 0..255 appears exactly 256^2 times.
    REPEAT = 256 * 256
    sum_0_255 = (255 * 256) // 2  # sum(range(256))
    exp_sum = REPEAT * sum_0_255
    sums = arr.sum(axis=0)
    assert int(sums[0]) == exp_sum and int(sums[1]) == exp_sum and int(sums[2]) == exp_sum, \
        "Channel sum check failed."

    print("  Verification passed: perfect 24-bit coverage.")


# ---------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------
def main(ref_path: str = REF_PATH, out_path: str = None):
    t0 = time.time()
    print(f"Target resolution: {W}×{H} pixels ({TOTAL_PIXELS:,} total)")
    print(f"Reference file   : {ref_path}")

    print("Loading and preparing reference PM5544 image (SVG/PNG)...")
    target = load_reference_target(ref_path)

    print("Building AllRGB image from reference with pooled color mapping...")
    img = build_allrgb_from_target(target)

    print("Running coverage verification...")
    verify_allrgb(img)

    if out_path is None:
        from datetime import datetime
        ts = datetime.now().strftime("%Y%m%d-%H%M%S")
        ext = os.path.splitext(ref_path)[1].lower().lstrip(".")
        out_path = f"allrgb_pm5544_pooled_from_{ext}_{W}x{H}_{ts}.png"

    print(f"Saving: {out_path}")
    img.save(out_path, optimize=True)

    dt = time.time() - t0
    print(f"Done in {dt:.1f} seconds.")


if __name__ == "__main__":
    np.set_printoptions(suppress=True)
    main()

The Viewer, Xavier (My Beta Self Portrait)

2025-11-10T11:39:31+01:00

This is me! I am known as Xavier John Dimayuga Mercado. I am born on February 10, 2006, and I love coding with technology stuff. My nickname code for the community is The Viewer, Xavier. (17)

The Viewer, Xavier's Mom, my own self portrait

2025-11-10T11:33:50+01:00

Rolly B. Mercado

2025-11-10T11:32:14+01:00

Photography #1
Sunday, November 9, 2025

#ILoveLasagna

2025-11-10T11:27:39+01:00

Lasagna is one of my favorite Italian pasta cuisine epic dishes ever.
If you like to make your own great quality lasagna, please take a reference to watch this Tasty video here: "https://www.youtube.com/watch?v=qEowX-vOb4E"
Have a wonderful feasty sharing time with your family and friends! (16)

My Flashback Living House Room Segment

2025-11-10T11:10:12+01:00

This is a picture taken by my OPPO A96 phone. (15)

[Private Image] (READ DESC)

2025-11-10T11:08:34+01:00

So you thought this image cannot load properly with your internet bandwidth?
Well surprise!
You got pranked! I just made fun editing this inspected website conversion layout using Google Colab.
Happy April Fools' Day! (14)

Luis Manzano

2025-11-09T13:07:07+01:00

Luis Philippe Santos Manzano is born on April 21, 1981. For those Filipino fans from the Philippines, have you ever heard of watching Kapamilya, Deal or No Deal, Minute to Win It, or Rainbow Rumble? (13)

All The Numbers 1-100

2025-11-09T13:05:33+01:00

Do you love counting to 100? I have a very true math fact to tell everyone! The LCM (or least common multiple) of all the numbers 1-100 is 69,720,375,229,712,477,164,533,808,935,312,303,556,800. (12)

The McDonald's Restaurant

2025-11-09T13:01:45+01:00

In some point, I found the best option to proceed to one of our "happy meals" for a very famous artwork made by me. What is your favorite meal on McDonald's? (11)

RGB Saturation Gradient

2025-10-21T11:00:26+02:00

Flat Earth

2025-10-17T12:33:32+02:00

Actual elevation data of Earth (from the National Centers for Environmental Information), crammed into a visual square.

# @title allRGB Earth Elevation (ETOPO1) — 4096×4096, uses all 24-bit RGB colors exactly once
# @markdown This cell downloads real ETOPO1 elevation data, caches it, and generates a 4096×4096 allRGB PNG
# @markdown where darkest colors map to deepest ocean and brightest to highest mountains.

import os, sys, io, zipfile, shutil, math, time, hashlib, textwrap, pathlib, tempfile, stat
import numpy as np
from PIL import Image

# Optional: use rasterio for robust GeoTIFF reading (faster/safer than PIL for big DEMs).
# If import fails, we fall back to PIL (works with this ETOPO1 TIFF).
try:
    import rasterio
    _HAS_RASTERIO = True
except Exception:
    _HAS_RASTERIO = False

# ---------- SETTINGS ----------
TARGET_W = 4096
TARGET_H = 4096
RANDOM_SEED = 1337  # affects only tie-break shuffles; final luminance/elevation ordering is deterministic otherwise

# ETOPO1 bedrock geotiff (global topography/bathymetry, 1 arc-minute ~ 60")
# NOAA NGDC legacy link (still widely mirrored); script tries these in order.
# Working NOAA mirrors (ETOPO1 Bedrock, GeoTIFF-in-a-zip)
ETOPO1_CANDIDATE_URLS = [
    # grid-registered (g) — preferred
    "https://www.ngdc.noaa.gov/mgg/global/relief/ETOPO1/data/bedrock/grid_registered/georeferenced_tiff/ETOPO1_Bed_g_geotiff.zip",
    # cell-registered (c) — fallback
    "https://www.ngdc.noaa.gov/mgg/global/relief/ETOPO1/data/bedrock/cell_registered/georeferenced_tiff/ETOPO1_Bed_c_geotiff.zip",
]

# Cache root: prefer Google Drive if available/authorized, else local /content cache
DEFAULT_LOCAL_CACHE = "/content/etopo1_cache"

# ---------- UTILITIES ----------
def human_bytes(n):
    for unit in ['B','KB','MB','GB','TB']:
        if n < 1024: return f"{n:.1f} {unit}"
        n /= 1024
    return f"{n:.1f} PB"

def ensure_dir(p):
    os.makedirs(p, exist_ok=True)
    return p

def detect_drive_mount():
    # If the user mounted Drive, prefer a folder there for persistence.
    # We don't auto-mount; we simply detect and use it if already mounted.
    drive_root = "/content/drive"
    if os.path.isdir(drive_root) and any(x for x in os.listdir(drive_root) if x.lower().startswith('my')):
        # Choose a subfolder in MyDrive
        mydrives = [x for x in os.listdir(drive_root) if x.lower().startswith("my")]
        base = os.path.join(drive_root, mydrives[0], "allRGB_Earth")
        return ensure_dir(base)
    return None

def pick_cache_root():
    root = detect_drive_mount()
    if root:
        print(f"✔ Using Google Drive cache: {root}")
        return root
    print(f"ℹ Using local cache: {DEFAULT_LOCAL_CACHE}\n   (Mount Drive first if you want persistence.)")
    return ensure_dir(DEFAULT_LOCAL_CACHE)

CACHE_ROOT = pick_cache_root()

ZIP_PATH = os.path.join(CACHE_ROOT, "ETOPO1_Bed_g_geotiff.zip")
TIF_PATH = os.path.join(CACHE_ROOT, "ETOPO1_Bed_g.tif")
DOWNSAMPLED_NPY = os.path.join(CACHE_ROOT, f"etopo1_{TARGET_W}x{TARGET_H}.npy")
OUTPUT_PNG = os.path.join(CACHE_ROOT, f"allrgb_earth_{TARGET_W}x{TARGET_H}.png")

# ---------- DOWNLOAD ----------
def stream_download(url, dst, chunk=1<<20):
    import requests
    with requests.get(url, stream=True, timeout=60) as r:
        r.raise_for_status()
        total = int(r.headers.get("content-length") or 0)
        got = 0
        t0 = time.time()
        with open(dst, "wb") as f:
            for ch in r.iter_content(chunk_size=chunk):
                if ch:
                    f.write(ch)
                    got += len(ch)
                    if total:
                        done = got/total*100
                        sys.stdout.write(f"\r↓ {url}  {human_bytes(got)}/{human_bytes(total)}  ({done:5.1f}%)")
                        sys.stdout.flush()
        dt = time.time()-t0
        sys.stdout.write(f"\nDownloaded in {dt:.1f}s ({human_bytes(got/dt)}/s)\n")

def ensure_zip():
    if os.path.isfile(ZIP_PATH) and os.path.getsize(ZIP_PATH) > 10_000_000:
        print(f"✔ Cache hit: {ZIP_PATH} ({human_bytes(os.path.getsize(ZIP_PATH))})")
        return
    last_err = None
    for url in ETOPO1_CANDIDATE_URLS:
        try:
            print(f"Attempting download: {url}")
            stream_download(url, ZIP_PATH)
            if os.path.getsize(ZIP_PATH) > 10_000_000:
                print("✔ Download OK.")
                return
        except Exception as e:
            print(f"✖ Failed: {e}")
            last_err = e
    raise RuntimeError(f"Could not download ETOPO1 zip from any source. Last error: {last_err}")

# ---------- UNZIP ----------
def ensure_tif_from_zip():
    if os.path.isfile(TIF_PATH) and os.path.getsize(TIF_PATH) > 10_000_000:
        print(f"✔ Cache hit: {TIF_PATH} ({human_bytes(os.path.getsize(TIF_PATH))})")
        return
    print("Extracting GeoTIFF…")
    with zipfile.ZipFile(ZIP_PATH, 'r') as z:
        members = z.namelist()
        tif_candidates = [m for m in members if m.lower().endswith(".tif")]
        if not tif_candidates:
            raise RuntimeError("No .tif found in ETOPO1 zip.")
        # Most zips have ETOPO1_Bed_g.tif
        member = tif_candidates[0]
        with z.open(member) as zin, open(TIF_PATH, "wb") as fout:
            shutil.copyfileobj(zin, fout)
    print(f"✔ Extracted: {TIF_PATH} ({human_bytes(os.path.getsize(TIF_PATH))})")

# ---------- READ + RESAMPLE ----------
def read_etopo_tiff_as_array():
    """Return elevation in meters as float32 numpy array, shape (H, W)."""
    if _HAS_RASTERIO:
        with rasterio.open(TIF_PATH) as ds:
            arr = ds.read(1).astype(np.float32)  # first band = elevation (meters)
            # (Height, Width)
            return arr
    else:
        # Fallback via PIL (works with this TIFF, but no georeferencing needed here)
        im = Image.open(TIF_PATH)
        arr = np.array(im, dtype=np.float32)
        return arr

def resample_to_target(elev):
    """Resample to (TARGET_H, TARGET_W) with simple area-ish average using block aggregation or bilinear, depending on ratio."""
    h, w = elev.shape
    if (h == TARGET_H) and (w == TARGET_W):
        return elev.copy()

    # Use PIL bilinear (good quality, fast)
    # Normalize to float32, push through PIL, then back.
    # Note: Elevation can be negative; shift to positive for resize to avoid dtype issues; shift back.
    mn, mx = float(elev.min()), float(elev.max())
    shift = -mn if mn < 0 else 0.0
    scale = 1.0/(mx - mn + 1e-9)
    tmp = (elev + shift)*scale  # 0..1
    pil = Image.fromarray(np.clip(tmp, 0, 1), mode='F')  # 32-bit float image
    pil_res = pil.resize((TARGET_W, TARGET_H), resample=Image.BILINEAR)
    out = np.asarray(pil_res, dtype=np.float32)
    out = out*(mx - mn + 1e-9) - shift
    return out

def ensure_downsampled_npy():
    if os.path.isfile(DOWNSAMPLED_NPY):
        print(f"✔ Cache hit: {DOWNSAMPLED_NPY} ({human_bytes(os.path.getsize(DOWNSAMPLED_NPY))})")
        return np.load(DOWNSAMPLED_NPY)
    print("Reading ETOPO1 GeoTIFF…")
    arr = read_etopo_tiff_as_array()
    print(f"  Source DEM shape: {arr.shape}, range: [{arr.min():.1f}, {arr.max():.1f}] m")

    print(f"Resampling to {TARGET_W}×{TARGET_H}…")
    ds = resample_to_target(arr)
    print(f"  Downsampled range: [{ds.min():.1f}, {ds.max():.1f}] m")

    np.save(DOWNSAMPLED_NPY, ds.astype(np.float32))
    print(f"✔ Saved cache: {DOWNSAMPLED_NPY} ({human_bytes(os.path.getsize(DOWNSAMPLED_NPY))})")
    return ds

# ---------- allRGB PALETTE ORDERING ----------
def build_allrgb_sorted_by_luminance():
    """
    Generate every 24-bit RGB color exactly once (0..16,777,215),
    sort by linear luminance Y = 0.2126R + 0.7152G + 0.0722B,
    then break ties with G, R, B (stable lexicographic).
    Returns uint8 array of shape (N, 3), ordered dark->bright.
    """
    N = 256*256*256
    print("Generating full 24-bit RGB palette…")
    # Using uint32 then bit ops is memory-efficient and very fast.
    vals = np.arange(N, dtype=np.uint32)
    R = ((vals >> 16) & 0xFF).astype(np.uint16)  # use u16 to avoid float upcast cost early
    G = ((vals >> 8)  & 0xFF).astype(np.uint16)
    B = (vals & 0xFF).astype(np.uint16)

    # Linear luminance (no gamma correction; lightweight and good enough for ordering)
    # float32 to control memory.
    Y = (0.2126*R.astype(np.float32) + 0.7152*G.astype(np.float32) + 0.0722*B.astype(np.float32))

    # lexsort sorts by last key primary; we want Y primary, with G,R,B tie-breakers
    # So provide keys in order: (B, R, G, Y)
    print("Sorting colors by luminance… (this can take ~10–40s in Colab)")
    idx = np.lexsort((B, R, G, Y))
    # Build ordered palette
    out = np.empty((N,3), dtype=np.uint8)
    out[:,0] = ( (vals[idx] >> 16) & 0xFF ).astype(np.uint8)
    out[:,1] = ( (vals[idx] >> 8)  & 0xFF ).astype(np.uint8)
    out[:,2] = (  vals[idx]        & 0xFF ).astype(np.uint8)
    return out

# ---------- MAPPING: elevation rank -> color rank ----------
def _pack24(rgb_u8):
    # rgb_u8: (N,3) uint8 -> uint32 0xRRGGBB
    return (rgb_u8[:,0].astype(np.uint32) << 16) | \
           (rgb_u8[:,1].astype(np.uint32) << 8)  | \
            rgb_u8[:,2].astype(np.uint32)

def make_allrgb_elevation_image(elev_2d, palette_1d_rgb):
    """
    Map pixels sorted by elevation (low->high) onto colors sorted by luminance (dark->bright).
    Ensures a 1:1 mapping: every pixel gets a unique color exactly once.
    """
    H, W = elev_2d.shape
    N = H*W
    assert N == 256*256*256, "Image must be exactly 4096×4096 to use all 16,777,216 colors once."

    print("Ranking elevation…")
    flat = elev_2d.reshape(-1)
    elev_rank = np.argsort(flat, kind='stable')  # low -> high

    print("Assigning colors to pixels…")
    colors = palette_1d_rgb  # (N,3) uint8, dark -> bright
    out = np.empty((N, 3), dtype=np.uint8)
    out[elev_rank] = colors

    # ---- Correct multiset verification (order-independent) ----
    print("Verifying color accounting (this takes a few seconds)…")
    pal_codes = _pack24(colors)
    img_codes = _pack24(out)

    # Count occurrences for each 24-bit code; must be exactly 1 everywhere
    # Memory note: bincount with minlength=16,777,216 uses ~128–135 MB (OK in Colab).
    pal_counts = np.bincount(pal_codes, minlength=256*256*256)
    img_counts = np.bincount(img_codes, minlength=256*256*256)

    assert pal_counts.dtype == np.int64 and img_counts.dtype == np.int64
    # Both should be vectors of all 1s
    if not (pal_counts == img_counts).all():
        raise AssertionError("Color multiset mismatch — mapping error.")
    if pal_counts.min() != 1 or pal_counts.max() != 1 or img_counts.min() != 1 or img_counts.max() != 1:
        raise AssertionError("Some colors are missing or duplicated.")

    print("✔ Color accounting validated (each of 16,777,216 colors used exactly once).")
    return out.reshape(H, W, 3)

# ---------- MAIN ----------
def main():
    print("=== allRGB Earth Elevation (ETOPO1 bedrock) ===")
    print(f"Target image: {TARGET_W}×{TARGET_H}  (pixels: {TARGET_W*TARGET_H:,})")

    # 1) Ensure elevation data is cached and downsampled
    ensure_zip()
    ensure_tif_from_zip()
    elev = ensure_downsampled_npy()

    # 2) Prepare palette (all 24-bit RGB sorted by luminance)
    palette = build_allrgb_sorted_by_luminance()

    # 3) Map elevation rank -> color rank
    img = make_allrgb_elevation_image(elev, palette)

    # 4) Save PNG
    Image.fromarray(img, mode="RGB").save(OUTPUT_PNG, optimize=True)
    print(f"✔ Saved: {OUTPUT_PNG}")

    # 5) Tiny preview (downscaled) for quick sanity check inside Colab output
    try:
        display(Image.fromarray(img).resize((1024,1024), Image.NEAREST))
    except Exception:
        pass

if __name__ == "__main__":
    main()

Diagonal Gradient

2025-10-17T10:39:26+02:00

Finally got around to some more iterations on the idea I had five years ago. This is about what I imagined it would be, but I had little idea how to actually create it back then. Thanks to ChatGPT, I spent a lot less time putting this one together.

Diagonal Gradient Twisted

2025-10-15T20:54:37+02:00

Diagonal Gradient Rotational

2025-10-15T20:49:39+02:00

Diagonal Gradient Continuous 2D

2025-10-15T20:46:29+02:00

Diagonal Gradient Split

2025-10-15T20:41:34+02:00

Diagonal Gradient Hue Layers

2025-10-15T20:35:06+02:00

Diagonal Gradient Hue

2025-10-15T20:31:38+02:00

Diagonal Bands

2025-10-15T20:28:54+02:00

Black to White

2025-10-15T20:24:28+02:00

Savonarazze

2025-10-08T09:13:16+02:00

Savona fortress (100 million iterations from a randomly swapped trivial allrgb bitmap), then Varazze (16 million). Details here: https://gautiersblog.blogspot.com/2025/10/savonarraze-allrgb-in-ada.html

Sort by Divisibility

2025-10-01T10:24:55+02:00

Every pixel is sorted by the amount of divisors its integer has. The very top has prime numbers (except the first 2 pixels at top left).

VP9 Corruption

2025-09-24T09:44:25+02:00

VP9 is a codec widely used by YouTube. And there's no surprise that its colorful patterns are similar to VP8 and AV1, as they share a lot of similarities internally.

Log. Sequence Extrapolation Sort

2025-09-23T10:43:05+02:00

Colors sorted by e^(ln(r) - 3 ln(g) + 3 ln(b)), or the logarithmic form of r - 3g + bg.
The formula is for extrapolating what comes after the quadratic sequence [R, G, B, ?].
Example: after [10, 11, 14] comes 19. Because the difference between each item is [+1, +3], you need to add 2 to 1 to get 3, so add that to 3, you get 5. Add 5 to 14 and you get 19.
But in this sort in particular it's in exponential scale, so after [2, 4, 16] comes 128, with differences (ratios) of [x2, x4, x8]
It looks like it starts ordered at the top then becomes chaotic after...

Circular Mosaics

2025-09-23T10:17:58+02:00

Cut out 2 groups of pixels in random locations, each group forming a circle of 256px in diameter, then swap them. It's like cookie cutters.
Do this 1,024 times for the final result.
Input template: thingy.png but red and blue is swapped.

FFV1 Corruption

2025-09-21T10:48:17+02:00

FFV1 is a lossless codec popular in the archival and preservation space. Its entropy coding using the range coder gives some interesting patterns when it's corrupted. The codec also splits each frame into a minimum of 4 chunks, so this only shows a single square chunk cropped out, and allRGBified.

Theora Corruption

2025-09-21T10:46:46+02:00

Theora is an old codec based on VP3. It looks cool when corrupted. Each 8x8 DCT block (16x16 in this allRGBified image) seems to be corrupted into a different overarching color. And in the left and bottom borders, some colorful stuff spills into the image.

VP8 Corruption

2025-09-21T10:45:31+02:00

VP8 is an open-source and royalty-free codec that later lead to VP9 and AV1. Even in this corrupted glitch art, you can spot similarities between the family of codecs.

Static Noise

2025-09-21T10:45:13+02:00

All colors are within the 256 frames, each 256x256. The colors are fully shuffled around. (25 fps)

"I Say No" by Wilkie Collins

2025-09-18T11:23:51+02:00

A book embedded into an all-RGB image. Read the top line for more details.

HEVC Corruption

2025-09-17T12:54:35+02:00

This looks pretty similar to my first AV1 glitch art, which is to be expected because both AV1 and HEVC/H.265 are relatively modern video codecs, and at a high level, they're pretty similar under the hood. AV1 has more flexible block partitioning and transforms. This time I ran my allRGB optimizer for 1.5 trillion iterations to get the final result.

AV1 Corruption

2025-09-05T15:42:39+02:00

Video codecs are cool. I made the base glitch art by compressing a single frame of noise into an AV1 video with aomenc, and then randomly flipping bits in the bitstream until I got a result I liked. Many colorful patterns emerged, almost like paint splatters from afar. Look closer and the corruption shows the codec's guts: block partitioning as blocky grids, directional intra prediction as smeared lines, and the wavy checker patterns of the DCT and ADST.

To make it allRGB, I used an iterative evolutionary method to selectively swap pixels. My optimized multithreaded version now runs a billion iterations per minute, generating the final image in no time!

animated 256 flags

2025-09-04T10:55:22+02:00

Inspired from Country Flags v1 by ACJ
Based and sourced from de vlag by ACJ

250 country flags + 5 international + 1 pride

animated PNG
256 images by 256x256
Each of 256 frames has got 65,536 unique colors

Fraunhofer Diffraction v1

2025-09-03T10:39:56+02:00

Inspired by results observed with double-slit experiments. Made with Chatgpt 5, Python 3, and a Google Colab notebook.

#!/usr/bin/env python3
"""
AllRGB + Physics: Fraunhofer double-slit diffraction, 4096×4096,
using each 24-bit RGB color exactly once.

Model:
I(x,y) ∝ cos^2(π x / Δx_interf) · sinc^2(x / Δx_env_x) · sinc^2(y / Δx_env_y)

where np.sinc(z) = sin(πz)/(πz) ⇒ sinc(α) with α = π x/Δ becomes np.sinc(x/Δ).

Brightness mapping:
- Sort pixels by physical intensity I (dark → bright).
- Sort all 16,777,216 RGB colors by Rec.709 relative luminance Y=0.2126R+0.7152G+0.0722B (dark → bright).
- Pair ranks 1:1 to preserve monotone brightness, guaranteeing exact once-only color usage.

References:
- Fraunhofer diffraction & rectangular aperture (sinc²): Wikipedia (Fraunhofer diffraction equation; Rectangular aperture section).
- Double-slit factor cos²×sinc²: standard optics notes/Q&A.
- Rec.709 luminance coefficients (also sRGB primaries): ITU-R BT.709 / Luma (video) page.

Citations are provided in the chat response.
"""

import numpy as np
from PIL import Image
from datetime import datetime

# ------------------------------ CONFIG ------------------------------

W = H = 4096

# Physical-pattern knobs (in PIXELS of the observation plane):
# First zeros of the single-slit envelopes (controls the sinc² widths).
FIRST_ZERO_X = 520.0   # pixels to first horizontal minimum (∝ λR / slit_width)
FIRST_ZERO_Y = 1800.0  # pixels to first vertical minimum (∝ λR / slit_height)

# Interference fringe spacing (distance between cos² maxima).
FRINGE_SPACING = 44.0  # pixels between bright fringes (∝ λR / slit_separation)

# Gamma to gently compress dynamic range of intensity before mapping.
INTENSITY_GAMMA = 1.0  # 1.0 = no change; >1 brightens midtones, <1 darkens

# Output filename
STAMP = datetime.now().strftime("%Y%m%d_%H%M%S")
OUT_PNG = f"allrgb_fraunhofer_double_slit_{W}x{H}_{STAMP}.png"

# ------------------------------ PHYSICS FIELD ------------------------------

def fraunhofer_double_slit_intensity(w=W, h=H,
                                     first_zero_x=FIRST_ZERO_X,
                                     first_zero_y=FIRST_ZERO_Y,
                                     fringe_px=FRINGE_SPACING,
                                     gamma=INTENSITY_GAMMA):
    """
    Build a physically faithful far-field intensity for a finite-height double slit.

    I(x,y) ∝ cos^2(π x / fringe_px) · sinc^2(x / first_zero_x) · sinc^2(y / first_zero_y)

    Using np.sinc(z) = sin(πz)/(πz) so sinc(π x/Δ)/(π x/Δ) == np.sinc(x/Δ).

    Returns
    -------
    I : float32 array, shape (h, w), normalized to [0,1].
    """
    y = np.arange(h, dtype=np.float32) - (h - 1) / 2.0
    x = np.arange(w, dtype=np.float32) - (w - 1) / 2.0
    X, Y = np.meshgrid(x, y)

    # Interference (two coherent slits separated along x)
    cos2 = np.cos(np.pi * X / float(fringe_px)) ** 2

    # Finite slit width/height envelopes (rectangular apertures)
    env_x = np.sinc(X / float(first_zero_x)) ** 2
    env_y = np.sinc(Y / float(first_zero_y)) ** 2

    I = cos2 * env_x * env_y

    if gamma != 1.0:
        # Optional tone shaping, still monotone
        I = I ** (1.0 / float(gamma))

    # Normalize robustly
    I -= I.min()
    m = I.max()
    if m > 0:
        I /= m
    return I.astype(np.float32, copy=False)

# ------------------------------ COLOR ORDERING ------------------------------

def colors_sorted_by_rec709_luma():
    """
    Generate all 24-bit colors exactly once and return their channels
    sorted by Rec.709 relative luminance (dark -> bright).

    Returns
    -------
    Rs, Gs, Bs : uint8 arrays of length N=W*H, luminance-sorted.
    """
    N = W * H
    c = np.arange(N, dtype=np.uint32)  # packed RGB as 0xRRGGBB

    R = ((c >> 16) & 0xFF).astype(np.float32)
    G = ((c >>  8) & 0xFF).astype(np.float32)
    B = ( c        & 0xFF).astype(np.float32)

    # Rec.709 relative luminance (linear light)
    Y = 0.2126 * R + 0.7152 * G + 0.0722 * B

    order = np.argsort(Y, kind="stable")  # deterministic & monotone

    Rs = R[order].astype(np.uint8, copy=False)
    Gs = G[order].astype(np.uint8, copy=False)
    Bs = B[order].astype(np.uint8, copy=False)

    # Free intermediates
    del R, G, B, Y, order, c
    return Rs, Gs, Bs

# ------------------------------ ASSEMBLY & CHECKS ------------------------------

def assemble_and_verify(I, Rs, Gs, Bs, out_path=OUT_PNG):
    """
    Rank-match intensity to luminance and write PNG.
    Also verifies exact once-only 24-bit coverage via multiple invariants.
    """
    N = I.size
    pix_order = np.argsort(I.ravel(), kind="stable")

    img_flat = np.empty((N, 3), dtype=np.uint8)
    img_flat[pix_order, 0] = Rs
    img_flat[pix_order, 1] = Gs
    img_flat[pix_order, 2] = Bs
    del Rs, Gs, Bs, pix_order

    img = img_flat.reshape((H, W, 3))
    del img_flat

    packed = (img[...,0].astype(np.uint32) << 16) | \
             (img[...,1].astype(np.uint32) <<  8) | \
             (img[...,2].astype(np.uint32)      )

    exp = np.arange(N, dtype=np.uint32)

    got_sum  = int(packed.sum(dtype=np.uint64))
    exp_sum  = int(exp.sum(dtype=np.uint64))
    got_sum2 = int((packed.astype(np.uint64) * packed.astype(np.uint64)).sum(dtype=np.uint64))
    exp_sum2 = int((exp.astype(np.uint64) * exp.astype(np.uint64)).sum(dtype=np.uint64))

    # FIXED: flatten before XOR reduce so we get a scalar
    got_xor = int(np.bitwise_xor.reduce(packed.ravel().astype(np.uint32)))
    exp_xor = int(np.bitwise_xor.reduce(exp))

    assert got_sum == exp_sum and got_sum2 == exp_sum2 and got_xor == exp_xor, \
        "Color coverage mismatch — not a perfect permutation of all 24-bit colors."

    Image.fromarray(img, mode="RGB").save(out_path, optimize=True)
    print(f"Saved: {out_path}")

def main():
    print(f"Image: {W}×{H}  (pixels: {W*H:,})")
    print("Computing Fraunhofer double-slit intensity field…")
    I = fraunhofer_double_slit_intensity()

    print("Ranking all 16,777,216 colors by Rec.709 luminance…")
    Rs, Gs, Bs = colors_sorted_by_rec709_luma()

    print("Assembling output image with exactly-once color coverage…")
    assemble_and_verify(I, Rs, Gs, Bs, out_path=OUT_PNG)

if __name__ == "__main__":
    # Be reproducible and concise in NumPy prints
    np.set_printoptions(suppress=True)
    main()

Country Flags v1

2025-09-02T10:26:59+02:00

Like a cliché nerd (think Sheldon Cooper), I’ve always been fascinated by country flags. So much so, that my company de idee even has a free to use online platform dedicated to it called de vlag (the flag in Dutch).

I figured it would be an interesting (read: extra nerdy) exercise to put all the official country flags in an image that contains all 24-bit rgb colors exactly once, while keeping the flags recognizable. This is my first attempt, created with Chatgpt 5, Python 3, and a Google Colab notebook. Please feel free to come up with a better version!

# ============================================
# 4096×4096 "All-RGB" World Flags
#  - HSVY + palette-aware mapping (bijective: uses every 24-bit color exactly once)
#  - Uniform gray background (constant)
#  - Background: lowest-chroma Y≈gray colors first
#  - Flags: HSVY rank + palette-hue tiebreaker
#  - NEW: shuffle only within each flag's individual color fields
#         (per-flag quantization labels), NOT whole-flag regions
#  - Verifies via checksum + XOR
# ============================================

!pip -q install pillow requests tqdm

import os, math, hashlib
from datetime import datetime
import requests
import numpy as np
from PIL import Image
from tqdm import tqdm

# -----------------------------
# Config
# -----------------------------
CANVAS_SIZE = 4096
INCLUDE_UN_OBSERVERS = True
USE_GOOGLE_DRIVE = False
SAVE_DIR = "/content"
CACHE_DIR_NAME = "flags_cache"

UNIFORM_GRAY = 224          # 0..255 uniform background gray
MARGIN_PX = 4               # inner cell padding
PALETTE_COLORS = 6          # per-flag quantization & palette tiebreak

# -----------------------------
# Optional: mount Drive
# -----------------------------
if USE_GOOGLE_DRIVE:
    from google.colab import drive
    drive.mount('/content/drive', force_remount=True)
    SAVE_DIR = "/content/drive/MyDrive"

ASSETS_DIR = os.path.join(SAVE_DIR, "allRGB", "assets")
os.makedirs(ASSETS_DIR, exist_ok=True)
CACHE_DIR = os.path.join(ASSETS_DIR, CACHE_DIR_NAME)
os.makedirs(CACHE_DIR, exist_ok=True)

# -----------------------------
# REST Countries fetch
# -----------------------------
def fetch_country_list(include_observers=True, timeout=60):
    url = "https://restcountries.com/v3.1/all?fields=name,flags,unMember,cca2"
    resp = requests.get(url, timeout=timeout)
    resp.raise_for_status()
    data = resp.json()

    wanted = []
    observers_set = {"Holy See", "Palestine", "State of Palestine"}
    for c in data:
        name = (c.get("name") or {}).get("common")
        un_member = bool(c.get("unMember"))
        flags = c.get("flags") or {}
        png = flags.get("png")
        cca2 = c.get("cca2")
        if not (name and png and cca2):
            continue
        if un_member:
            wanted.append(dict(name=name, png=png, cca2=cca2.lower(), un_member=True))
        elif include_observers and name in observers_set:
            wanted.append(dict(name=name, png=png, cca2=cca2.lower(), un_member=False))
    wanted.sort(key=lambda d: d["name"])
    return wanted

def safe_filename(s):
    return "".join(ch if ch.isalnum() or ch in "-_." else "_" for ch in s)

def download_flag_png(item, cache_dir=CACHE_DIR, timeout=60):
    url = item["png"]
    code = item["cca2"]
    base = f"{safe_filename(code)}.png"
    path = os.path.join(cache_dir, base)
    if os.path.exists(path) and os.path.getsize(path) > 0:
        return path
    try:
        r = requests.get(url, timeout=timeout)
        r.raise_for_status()
        with open(path, "wb") as f:
            f.write(r.content)
        return path
    except Exception:
        try:
            if "/w320/" in url:
                url2 = url.replace("/w320/", "/w640/")
                r2 = requests.get(url2, timeout=timeout)
                r2.raise_for_status()
                with open(path, "wb") as f:
                    f.write(r2.content)
                return path
        except Exception:
            pass
        return None

# -----------------------------
# Grid & mosaic with per-flag label maps
# -----------------------------
def best_grid(n, width=CANVAS_SIZE, height=CANVAS_SIZE):
    cols = int(math.ceil(math.sqrt(n)))
    rows = int(math.ceil(n / cols))
    return rows, cols

def place_flags_mosaic_with_labels(flags, gray=UNIFORM_GRAY, canvas_size=CANVAS_SIZE,
                                   margin=MARGIN_PX, palette_colors=PALETTE_COLORS):
    """
    Returns:
      mosaic_rgb (RGB)
      flag_id_map (H,W) int32: -1 for background, else flag index
      per_flag (list of dicts):
         - name, cca2
         - hues: palette hues (uint8 0..255) for tiebreaker
         - paste_x, paste_y
         - label_map: (h_resized, w_resized) int16, -1 for transparent,
                      else palette index 0..(palette_colors-1)
    """
    N = len(flags)
    rows, cols = best_grid(N, canvas_size, canvas_size)
    cell_w = canvas_size // cols
    cell_h = canvas_size // rows

    pad = (int(gray), int(gray), int(gray))
    mosaic = Image.new("RGBA", (canvas_size, canvas_size), pad + (255,))
    flag_id_map = np.full((canvas_size, canvas_size), -1, dtype=np.int32)
    per_flag = []

    i = 0
    for r in range(rows):
        for c in range(cols):
            if i >= N:
                break
            info = flags[i]
            path = info["local"]
            try:
                flag = Image.open(path).convert("RGBA")
            except Exception:
                per_flag.append(dict(name=info["name"], cca2=info["cca2"], hues=np.array([], dtype=np.uint8),
                                     paste_x=0, paste_y=0, label_map=np.zeros((0,0), dtype=np.int16)))
                i += 1
                continue

            max_w = max(1, cell_w - 2 * margin)
            max_h = max(1, cell_h - 2 * margin)
            fw, fh = flag.size
            scale = min(max_w / fw, max_h / fh)
            new_w = max(1, int(round(fw * scale)))
            new_h = max(1, int(round(fh * scale)))
            flag_resized = flag.resize((new_w, new_h), Image.LANCZOS)

            paste_x = c * cell_w + (cell_w - new_w) // 2
            paste_y = r * cell_h + (cell_h - new_h) // 2

            # Composite onto mosaic
            mosaic.alpha_composite(flag_resized, (paste_x, paste_y))

            # Flag-id map (alpha>0)
            alpha = np.array(flag_resized.split()[-1], dtype=np.uint8)
            mask = alpha > 0
            if mask.any():
                yy, xx = np.nonzero(mask)
                fy = paste_y + yy
                fx = paste_x + xx
                ok = (fy >= 0) & (fy < canvas_size) & (fx >= 0) & (fx < canvas_size)
                flag_id_map[fy[ok], fx[ok]] = i

            # Quantize to get per-pixel palette indices
            qimg = flag_resized.convert("RGB").quantize(colors=palette_colors, method=Image.MEDIANCUT)
            label_map = np.array(qimg, dtype=np.int16)  # 0..K-1 indices over full rect
            # Set -1 where flag is transparent
            label_map[~mask] = -1

            # Palette hues for tiebreaker
            palette = qimg.getpalette()[:palette_colors*3]
            pal = np.array(palette, dtype=np.uint8).reshape(-1, 3)
            pr, pg, pb = pal[:,0].astype(np.float32)/255.0, pal[:,1].astype(np.float32)/255.0, pal[:,2].astype(np.float32)/255.0
            pmax = np.maximum.reduce([pr, pg, pb])
            pmin = np.minimum.reduce([pr, pg, pb])
            pc = pmax - pmin
            ph = np.zeros_like(pmax, dtype=np.float32)
            maskc = pc > 1e-12
            rc = np.zeros_like(pmax); gc = np.zeros_like(pmax); bc = np.zeros_like(pmax)
            rc[maskc] = (pmax[maskc] - pr[maskc]) / pc[maskc]
            gc[maskc] = (pmax[maskc] - pg[maskc]) / pc[maskc]
            bc[maskc] = (pmax[maskc] - pb[maskc]) / pc[maskc]
            mr = maskc & (pr >= pg) & (pr >= pb)
            mg = maskc & (pg > pr) & (pg >= pb)
            mb = maskc & (pb > pr) & (pb > pg)
            ph[mr] = (bc[mr] - gc[mr]) / 6.0
            ph[mg] = (2.0 + (rc[mg] - bc[mg])) / 6.0
            ph[mb] = (4.0 + (gc[mb] - rc[mb])) / 6.0
            ph = ph % 1.0
            pal_h8 = np.floor(ph * 255.0 + 0.5).astype(np.uint8)

            per_flag.append(dict(name=info["name"], cca2=info["cca2"], hues=pal_h8,
                                 paste_x=paste_x, paste_y=paste_y, label_map=label_map))
            i += 1

    return mosaic.convert("RGB"), flag_id_map, per_flag

# -----------------------------
# HSVY helpers
# -----------------------------
def rgb_to_yhc_u8(r, g, b):
    r16 = r.astype(np.uint16); g16 = g.astype(np.uint16); b16 = b.astype(np.uint16)
    cmax = np.maximum(np.maximum(r16, g16), b16)
    cmin = np.minimum(np.minimum(r16, g16), b16)
    delta = (cmax - cmin).astype(np.uint8)
    Y = ((54 * r16 + 183 * g16 + 19 * b16 + 128) >> 8).astype(np.uint8)  # Rec709-ish

    rf = r16.astype(np.float32); gf = g16.astype(np.float32); bf = b16.astype(np.float32)
    cmaxf = cmax.astype(np.float32); deltaf = (cmax - cmin).astype(np.float32)
    hue = np.zeros_like(cmaxf, dtype=np.float32)
    nz = deltaf > 0
    mask_r = nz & (cmax == r16)
    hue[mask_r] = (60.0 * ((gf[mask_r] - bf[mask_r]) / deltaf[mask_r])) % 360.0
    mask_g = nz & (cmax == g16)
    hue[mask_g] = 60.0 * (2.0 + (bf[mask_g] - rf[mask_g]) / deltaf[mask_g])
    mask_b = nz & (cmax == b16)
    hue[mask_b] = 60.0 * (4.0 + (rf[mask_b] - gf[mask_b]) / deltaf[mask_b])
    hue = np.where(hue < 0, hue + 360.0, hue)
    H = np.floor(hue * (255.0 / 360.0) + 0.5).astype(np.uint8)
    return Y, H, delta

def make_hsvy_key(Y, H, C):
    return (Y.astype(np.uint32) << 24) | (H.astype(np.uint32) << 16) | (C.astype(np.uint32) << 8)

def hue_circ_dist8(a8, b8):
    d = np.abs(a8.astype(np.int16) - b8.astype(np.int16)).astype(np.int16)
    return np.minimum(d, 256 - d).astype(np.uint8)

def rng_for_label(label: str):
    h = hashlib.blake2b(label.encode("utf-8"), digest_size=8).digest()
    return np.random.default_rng(int.from_bytes(h, "little"))

# -----------------------------
# Build with background + flags + per-field shuffle
# -----------------------------
def build_allrgb_palette_aware(target_rgb, flag_id_map, per_flag, out_png_path, bg_gray=UNIFORM_GRAY):
    W = H = CANVAS_SIZE
    assert target_rgb.size == (W, H)

    arr = np.array(target_rgb, dtype=np.uint8)
    flat = arr.reshape(-1, 3)
    tr, tg, tb = flat[:,0], flat[:,1], flat[:,2]

    # Background mask
    bgR = np.uint8(bg_gray); bgG = np.uint8(bg_gray); bgB = np.uint8(bg_gray)
    bg_mask = (tr == bgR) & (tg == bgG) & (tb == bgB)
    K = int(bg_mask.sum())
    print(f"Background pixels: {K:,d} / {flat.shape[0]:,d}")

    # All 24-bit colors
    N = 1 << 24
    codes = np.arange(N, dtype=np.uint32)
    r_all = (codes >> 16).astype(np.uint8)
    g_all = ((codes >> 8) & 255).astype(np.uint8)
    b_all = (codes & 255).astype(np.uint8)

    print("Precomputing Y,H,C for all colors…")
    Y_all, H_all, C_all = rgb_to_yhc_u8(r_all, g_all, b_all)

    # -------- Phase A: background = lowest-C, Y≈bgGray ----------
    print("Selecting lowest-chroma colors for background…")
    if K > 0:
        idx_lowC = np.argpartition(C_all, K - 1)[:K]
        bgY = np.uint8(bg_gray)
        Ydiff = np.abs(Y_all[idx_lowC].astype(np.int16) - int(bgY)).astype(np.uint8)
        key_bg = (C_all[idx_lowC].astype(np.uint32) << 24) | (Ydiff.astype(np.uint32) << 16) | (H_all[idx_lowC].astype(np.uint32) << 8) | (codes[idx_lowC] & 0xFF)
        order_bg = np.argsort(key_bg, kind="stable")
        color_idx_bg = idx_lowC[order_bg]
    else:
        color_idx_bg = np.array([], dtype=np.int64)

    px_idx_all = np.arange(flat.shape[0], dtype=np.uint32)
    px_idx_bg = px_idx_all[bg_mask]
    assert px_idx_bg.size == color_idx_bg.size, "Background selection mismatch."

    out_r = np.empty(N, dtype=np.uint8)
    out_g = np.empty(N, dtype=np.uint8)
    out_b = np.empty(N, dtype=np.uint8)

    # Place background colors (we'll shuffle them later within background)
    out_r[px_idx_bg] = r_all[color_idx_bg]
    out_g[px_idx_bg] = g_all[color_idx_bg]
    out_b[px_idx_bg] = b_all[color_idx_bg]

    # -------- Phase B: foreground via HSVY + palette-hue tiebreak ----------
    remain_mask_pixels = ~bg_mask
    px_idx_fg = px_idx_all[remain_mask_pixels]

    taken = np.zeros(N, dtype=bool)
    taken[color_idx_bg] = True
    color_idx_fg = np.flatnonzero(~taken)
    del taken

    Yt, Ht, Ct = rgb_to_yhc_u8(tr[remain_mask_pixels], tg[remain_mask_pixels], tb[remain_mask_pixels])
    tkey = make_hsvy_key(Yt, Ht, Ct)

    print("Computing palette-aware tiebreaker…")
    flag_ids_flat = flag_id_map.reshape(-1)[remain_mask_pixels]
    pal_delta = np.full(flag_ids_flat.shape, 128, dtype=np.uint8)

    unique_flags = np.unique(flag_ids_flat)
    for fid in unique_flags:
        if fid < 0:
            continue
        hues = per_flag[fid]["hues"]
        idx = np.nonzero(flag_ids_flat == fid)[0]
        if idx.size == 0 or hues.size == 0:
            continue
        h_local = Ht[idx]
        mind = np.full(idx.size, 255, dtype=np.uint8)
        for hp in hues:
            d = hue_circ_dist8(h_local, np.uint8(hp))
            mind = np.minimum(mind, d)
        pal_delta[idx] = mind

    tidx = np.arange(px_idx_fg.size, dtype=np.uint32)
    target_order = np.lexsort((tidx, pal_delta.astype(np.uint32), tkey))

    Yc = Y_all[color_idx_fg]; Hc = H_all[color_idx_fg]; Cc = C_all[color_idx_fg]
    ckey = make_hsvy_key(Yc, Hc, Cc)
    color_order = np.lexsort((color_idx_fg, ckey))

    sorted_px = px_idx_fg[target_order]
    sorted_colors = color_idx_fg[color_order]

    out_r[sorted_px] = r_all[sorted_colors]
    out_g[sorted_px] = g_all[sorted_colors]
    out_b[sorted_px] = b_all[sorted_colors]

    # -------- NEW: shuffle within color fields (not whole flags) ----------
    print("Shuffling within individual color fields of each flag…")

    # Background region shuffle (all background as one region)
    def shuffle_region(px_idx, label):
        if px_idx.size <= 1:
            return
        rng = rng_for_label(label)
        order = np.arange(px_idx.size)
        rng.shuffle(order)
        rr = out_r[px_idx].copy(); gg = out_g[px_idx].copy(); bb = out_b[px_idx].copy()
        out_r[px_idx] = rr[order]; out_g[px_idx] = gg[order]; out_b[px_idx] = bb[order]

    shuffle_region(px_idx_bg, f"background_gray_{bg_gray}")

    # For each flag: shuffle inside each palette label cluster separately
    Hcvs = H  # just to avoid confusion — using globals W,H

    for fid in unique_flags:
        if fid < 0:
            continue
        meta = per_flag[fid]
        name = meta["name"]; px = meta["paste_x"]; py = meta["paste_y"]
        lbl = meta["label_map"]  # (h_res, w_res) int16, -1 transparent
        if lbl.size == 0:
            continue

        h_res, w_res = lbl.shape
        # Map label pixels to canvas linear indices
        yy, xx = np.nonzero(lbl >= 0)
        if yy.size == 0:
            continue
        canvas_y = py + yy
        canvas_x = px + xx
        ok = (canvas_y >= 0) & (canvas_y < H) & (canvas_x >= 0) & (canvas_x < W)
        canvas_y = canvas_y[ok]; canvas_x = canvas_x[ok]
        labels_here = lbl[yy[ok], xx[ok]]

        # For each palette label value present, shuffle within that set
        for k in np.unique(labels_here):
            idx_k = (labels_here == k)
            if not np.any(idx_k):
                continue
            cy = canvas_y[idx_k]; cx = canvas_x[idx_k]
            px_idx = (cy.astype(np.uint32) * W) + cx.astype(np.uint32)
            shuffle_region(px_idx, f"flag_{fid}_{name}_field_{int(k)}")

    # -------- Save + exactness checks ----------
    out = np.stack([out_r, out_g, out_b], axis=1).reshape(H, W, 3)
    del out_r, out_g, out_b, r_all, g_all, b_all, Y_all, H_all, C_all

    print("Verifying perfect 24-bit coverage (checksum + XOR)…")
    packed = (out[...,0].astype(np.uint32) << 16) | (out[...,1].astype(np.uint32) << 8) | out[...,2].astype(np.uint32)

    N24 = 1 << 24
    sum1 = int(packed.sum(dtype=np.uint64))
    expected_sum = (N24 * (N24 - 1)) // 2

    def xor_reduce(u32arr, block=8_000_000):
        xr = np.uint32(0)
        flat = u32arr.ravel()
        for s in range(0, flat.size, block):
            e = min(flat.size, s + block)
            xr ^= np.bitwise_xor.reduce(flat[s:e])
        return int(xr)
    def xor_0_to(m): return [m, 1, m+1, 0][m & 3]

    xor1 = xor_reduce(packed)
    expected_xor = xor_0_to(N24 - 1)
    assert sum1 == expected_sum and xor1 == expected_xor, "Coverage mismatch: not all 24-bit colors used exactly once."

    Image.fromarray(out, mode="RGB").save(out_png_path, format="PNG", compress_level=0)
    print(f"Saved: {out_png_path}")

# -----------------------------
# Main
# -----------------------------
def main():
    print("Fetching countries & flag URLs…")
    countries = fetch_country_list(INCLUDE_UN_OBSERVERS)
    print(f"Fetched {len(countries)} candidates.")

    print("Downloading flag PNGs (cached)…")
    kept = []
    for item in tqdm(countries):
        p = download_flag_png(item)
        if p:
            item["local"] = p
            kept.append(item)
    print(f"Using {len(kept)} flags.")
    if len(kept) == 0:
        raise RuntimeError("No flags downloaded. Check network access or the API.")

    print("Building mosaic + per-flag label maps (uniform gray background)…")
    mosaic, flag_id_map, per_flag = place_flags_mosaic_with_labels(
        kept, gray=UNIFORM_GRAY, canvas_size=CANVAS_SIZE, margin=MARGIN_PX, palette_colors=PALETTE_COLORS
    )

    ts = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
    preview_path = os.path.join(ASSETS_DIR, f"flags_target_uniformgray_{CANVAS_SIZE}_{ts}.png")
    mosaic.save(preview_path, format="PNG")
    print(f"Saved target preview: {preview_path}")

    out_path = os.path.join(ASSETS_DIR, f"allrgb_flags_hsvy_paletteaware_fields_shuffled_{CANVAS_SIZE}_{ts}.png")
    build_allrgb_palette_aware(mosaic, flag_id_map, per_flag, out_path, bg_gray=UNIFORM_GRAY)
    print("Done.")

if __name__ == "__main__":
    np.set_printoptions(suppress=True)
    main()

Point Spread Function v1

2025-09-01T16:43:40+02:00

Made with Chatgpt 5, Python 3, and Google Colab notebook. Source:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Physics-accurate telescope diffraction image (4096×4096) using all 24-bit RGB colors exactly once.

Features
- Pupil model: annulus (central obstruction) + spider vanes → Fraunhofer PSF via FFT
- Aberrations: fringe Zernike terms (defocus, astigmatism 0/45°, coma x/y, spherical)
- Intensity shaping: monotone gamma (does not change rank order)
- Exact-once color usage: rank-match intensity to Rec.709 luma; checksum + XOR proof
- Reserved overlays: center crosshair (darkest colors), neat legend box & ticks (lightest colors)

Requires: numpy, pillow
"""

import time
import numpy as np
from PIL import Image

# -------------------------- Zernike (fringe polynomials) --------------------------
# Fringe (unnormalized) variants often used in engineering optics. Coefficients are in waves.
# theta in radians, rho∈[0,1]
def z_defocus(rho, th):      # Z4 fringe ~ 2ρ^2 - 1
    return 2.0 * rho**2 - 1.0

def z_astig0(rho, th):       # Z2 fringe ~ ρ^2 cos 2θ
    return rho**2 * np.cos(2.0 * th, dtype=np.float32)

def z_astig45(rho, th):      # Z3 fringe ~ ρ^2 sin 2θ
    return rho**2 * np.sin(2.0 * th, dtype=np.float32)

def z_coma_x(rho, th):       # Z7 fringe ~ (3ρ^3 - 2ρ) cos θ
    return (3.0 * rho**3 - 2.0 * rho) * np.cos(th, dtype=np.float32)

def z_coma_y(rho, th):       # Z8 fringe ~ (3ρ^3 - 2ρ) sin θ
    return (3.0 * rho**3 - 2.0 * rho) * np.sin(th, dtype=np.float32)

def z_spherical(rho, th):    # Z11 fringe ~ 6ρ^4 - 6ρ^2 + 1
    return 6.0 * rho**4 - 6.0 * rho**2 + 1.0

# -------------------------- Pupil → PSF (FFT) --------------------------
def aperture_fft_intensity(h, w,
                           epsilon=0.33,        # central obstruction ratio D_inner / D_outer
                           vanes=4,             # number of spider vanes
                           vane_thickness=0.008,# fraction of pupil diameter
                           rotate_deg=15.0,     # orientation of vanes [deg]
                           gamma=0.80,          # intensity^gamma for contrast (monotone)
                           # Aberration coefficients in waves (peak-to-valley-ish)
                           c_defocus = 0.00,
                           c_astig0  = 0.00,
                           c_astig45 = 0.00,
                           c_coma_x  = 0.00,
                           c_coma_y  = 0.00,
                           c_spherical=0.00):
    """
    Build Fraunhofer diffraction intensity from a physical pupil.
    Steps:
      1) Pupil amplitude: annulus minus spider vanes
      2) Pupil phase: exp(i*2π*sum c_k * Z_k(rho, theta))
      3) PSF ∝ |FFT(pupil)|^2  (fftshifted)
    """
    H, W = int(h), int(w)

    # Normalized coordinates in [-1,1]; inscribed pupil radius ≈ 1.0
    yy = np.linspace(-1.0, 1.0, H, dtype=np.float32)
    xx = np.linspace(-1.0, 1.0, W, dtype=np.float32)
    X, Y = np.meshgrid(xx, yy, indexing="xy")
    R = np.hypot(X, Y, dtype=np.float32)
    TH = np.arctan2(Y, X, dtype=np.float32)

    # Annulus mask (slightly underfilled to avoid hard edge touching frame)
    outer_R = 0.98
    inner_R = outer_R * np.float32(epsilon)
    outer = (R <= outer_R).astype(np.float32)
    inner = (R <= inner_R).astype(np.float32)
    annulus = outer - inner

    # Rotate vane coordinates
    th = np.deg2rad(np.float32(rotate_deg))
    c, s = np.cos(th), np.sin(th)
    Xr =  c * X + s * Y
    Yr = -s * X + c * Y

    pupil = annulus.copy()
    if vanes > 0 and vane_thickness > 0.0:
        t = np.float32(vane_thickness)
        for k in range(vanes):
            phi = np.float32(k) * (np.pi / np.float32(vanes))
            cp, sp = np.cos(phi), np.sin(phi)
            u =  cp * Xr + sp * Yr
            v = -sp * Xr + cp * Yr
            vane = (np.abs(v) <= (t / 2.0)).astype(np.float32)
            # remove vane only where within outer pupil
            pupil *= (1.0 - vane) + (1.0 - outer)

    # Phase from Zernike aberrations (fringe set). Coeffs are in waves → 2π factor to radians.
    if any(abs(x) > 1e-12 for x in [c_defocus, c_astig0, c_astig45, c_coma_x, c_coma_y, c_spherical]):
        phase_waves = (c_defocus   * z_defocus(R/outer_R, TH) +
                       c_astig0    * z_astig0 (R/outer_R, TH) +
                       c_astig45   * z_astig45(R/outer_R, TH) +
                       c_coma_x    * z_coma_x (R/outer_R, TH) +
                       c_coma_y    * z_coma_y (R/outer_R, TH) +
                       c_spherical * z_spherical(R/outer_R, TH)).astype(np.float32)
        phase = (2.0 * np.pi * phase_waves).astype(np.float32)
        pupil = pupil * np.exp(1j * phase, dtype=np.complex64)
    else:
        pupil = pupil.astype(np.complex64)

    # FFT → PSF
    F = np.fft.fft2(pupil)
    I = np.fft.fftshift(np.abs(F)**2).astype(np.float32)

    # Normalize + gamma (monotone)
    I -= I.min()
    m = I.max()
    if m > 0:
        I /= m
    if gamma != 1.0:
        I = np.power(I, np.float32(gamma), dtype=np.float32)
    return I

# -------------------------- Exact-once mapping with reserved overlays --------------------------
def stable_argsort(a):
    try:
        return np.argsort(a, kind='stable')
    except TypeError:
        return np.argsort(a, kind='mergesort')

def map_allrgb_with_overlays(intensity,
                             use_crosshair=True,
                             use_legend=True,
                             invert=False,
                             legend_box=(32, 4096-32-120, 480, 120),  # (x,y,w,h) bottom-left by default
                             legend_thick=2,
                             ticks=9, tick_len=16, tick_thick=2):
    """
    Map all 24-bit colors exactly once with optional reserved overlays:
      - Crosshair (center horizontal+vertical lines) uses the darkest colors.
      - Legend box (corner rectangle with ticks) uses the lightest colors.
    The remaining pixels are filled by rank-matching intensity with color luma.
    """
    H, W = intensity.shape
    N = H * W

    # 1) Build overlay mask: 0=free, 1=dark-reserved (crosshair), 2=light-reserved (legend)
    mask = np.zeros((H, W), dtype=np.uint8)

    # Crosshair pixels (avoid double-count at center)
    cross_idx = []
    if use_crosshair:
        cy, cx = H // 2, W // 2
        # horizontal
        mask[cy, :] = 1
        # vertical
        mask[:, cx] = np.maximum(mask[:, cx], 1)
        # collect linear indices
        y = np.full(W, cy, dtype=np.int64)
        x = np.arange(W, dtype=np.int64)
        cross_idx.extend((y * W + x).tolist())
        y = np.arange(H, dtype=np.int64)
        x = np.full(H, cx, dtype=np.int64)
        cross_idx.extend((y * W + x).tolist())
        # remove the center double-count
        cross_idx = sorted(set(cross_idx))

    # Legend rectangle (border only) with ticks
    legend_idx = []
    if use_legend:
        lx, ly, lw, lh = legend_box
        lx = int(np.clip(lx, 0, W-1)); ly = int(np.clip(ly, 0, H-1))
        lw = int(np.clip(lw, 1, W - lx)); lh = int(np.clip(lh, 1, H - ly))
        t  = int(max(1, legend_thick))
        # borders
        # top/bottom
        mask[ly:ly+t, lx:lx+lw] = 2
        mask[ly+lh-t:ly+lh, lx:lx+lw] = 2
        # left/right
        mask[ly:ly+lh, lx:lx+t] = 2
        mask[ly:ly+lh, lx+lw-t:lx+lw] = 2

        # ticks along bottom border inside the box (evenly spaced)
        if ticks > 0:
            for i in range(ticks+1):
                tx = lx + int(round(i * (lw-1) / ticks))
                ty0 = ly + lh - t - tick_len
                ty1 = ly + lh - t
                ty0 = max(ly + t, ty0)
                ty1 = min(ly + lh - 1, ty1)
                mask[ty0:ty1, tx:tx+tick_thick] = 2

        legend_idx = np.flatnonzero(mask == 2).tolist()

    # 2) Compute pixel order among FREE pixels only
    flat_I = intensity.ravel()
    free_lin = np.flatnonzero(mask.ravel() == 0)
    free_order = stable_argsort(flat_I[free_lin])
    if invert:
        free_order = free_order[::-1]
    free_lin_sorted = free_lin[free_order]
    del free_order, free_lin

    # 3) Build global color ordering by perceived brightness (Rec.709 luma, fixed-point)
    c = np.arange(N, dtype=np.uint32)
    R = (c >> 16) & 0xFF
    G = (c >> 8)  & 0xFF
    B = (c      ) & 0xFF
    Y256 = (54 * R + 183 * G + 19 * B).astype(np.uint32)
    color_order = stable_argsort(Y256)  # dark→bright
    del Y256, R, G, B

    # Reserve darkest for crosshair, lightest for legend
    D_dark  = len(cross_idx)
    D_light = len(legend_idx)
    if D_dark + D_light > N:
        raise RuntimeError("Overlay area exceeds total pixels.")

    darkest_ids  = color_order[:D_dark].astype(np.uint32, copy=False)
    lightest_ids = color_order[-D_light:].astype(np.uint32, copy=False) if D_light > 0 else np.array([], dtype=np.uint32)
    remain_ids   = color_order[D_dark: N - D_light].astype(np.uint32, copy=False)
    del color_order

    # 4) Assemble output
    img_flat = np.empty((N, 3), dtype=np.uint8)

    # Fill FREE pixels with remaining colors by intensity rank
    co = remain_ids
    img_flat[free_lin_sorted, 0] = (co >> 16).astype(np.uint8)
    img_flat[free_lin_sorted, 1] = ((co >> 8) & 0xFF).astype(np.uint8)
    img_flat[free_lin_sorted, 2] = (co & 0xFF).astype(np.uint8)
    del co

    # Paint crosshair with darkest colors (center-out radial gradient along both axes)
    if D_dark > 0:
        # Sort crosshair indices by distance from center for a nice gradient
        cross_idx_arr = np.array(cross_idx, dtype=np.int64)
        ys = (cross_idx_arr // W).astype(np.int32)
        xs = (cross_idx_arr %  W).astype(np.int32)
        cy, cx = H // 2, W // 2
        d = np.hypot(xs - cx, ys - cy).astype(np.float32)
        order = np.argsort(d, kind='mergesort')  # stable
        ci = cross_idx_arr[order]
        cd = darkest_ids  # dark→less dark
        img_flat[ci, 0] = ((cd >> 16) & 0xFF).astype(np.uint8)
        img_flat[ci, 1] = ((cd >> 8)  & 0xFF).astype(np.uint8)
        img_flat[ci, 2] = ( cd        & 0xFF).astype(np.uint8)
        del cross_idx_arr, ys, xs, d, order, ci, cd

    # Paint legend with lightest colors (simple sequential assignment)
    if D_light > 0:
        li = np.array(legend_idx, dtype=np.int64)
        ld = lightest_ids
        img_flat[li, 0] = ((ld >> 16) & 0xFF).astype(np.uint8)
        img_flat[li, 1] = ((ld >> 8 ) & 0xFF).astype(np.uint8)
        img_flat[li, 2] = ( ld        & 0xFF).astype(np.uint8)
        del li, ld

    img = img_flat.reshape(H, W, 3)
    del img_flat

    # 5) Integrity checks — prove every color used exactly once
    packed = (img[...,0].astype(np.uint32) << 16) | \
             (img[...,1].astype(np.uint32) << 8)  | \
             (img[...,2].astype(np.uint32))
    sum1 = int(packed.sum(dtype=np.uint64))
    xors = np.bitwise_xor.reduce(packed.ravel().astype(np.uint64)).item()
    del packed

    exp_sum1 = N * (N - 1) // 2
    assert sum1 == exp_sum1 and xors == 0, "Color coverage mismatch."

    return img

# -------------------------- Driver --------------------------
def build_image(size=4096,
                invert=False,
                # Pupil + FFT parameters
                epsilon=0.33, vanes=4, vane_thickness=0.008, rotate_deg=15.0, gamma=0.80,
                # Aberration waves (try small values like 0.05–0.20 for visible but tasteful effects)
                c_defocus=0.00, c_astig0=0.00, c_astig45=0.00, c_coma_x=0.00, c_coma_y=0.00, c_spherical=0.00,
                # Overlays
                use_crosshair=True, use_legend=True,
                legend_box=(32, 4096-32-120, 480, 120), legend_thick=2, ticks=9, tick_len=16, tick_thick=2,
                out_path=None):
    H = W = int(size)
    print(f"Image: {W}×{H}  (pixels: {H*W:,})")

    print("Computing aperture FFT intensity (annulus + spider vanes + optional aberrations)...")
    I = aperture_fft_intensity(H, W,
                               epsilon=epsilon, vanes=vanes, vane_thickness=vane_thickness,
                               rotate_deg=rotate_deg, gamma=gamma,
                               c_defocus=c_defocus, c_astig0=c_astig0, c_astig45=c_astig45,
                               c_coma_x=c_coma_x, c_coma_y=c_coma_y, c_spherical=c_spherical)

    print("Mapping all 24-bit colors with reserved overlays (crosshair & legend)...")
    img = map_allrgb_with_overlays(I,
                                   use_crosshair=use_crosshair,
                                   use_legend=use_legend,
                                   invert=invert,
                                   legend_box=legend_box,
                                   legend_thick=legend_thick,
                                   ticks=ticks, tick_len=tick_len, tick_thick=tick_thick)

    ts = time.strftime("%Y%m%d-%H%M%S")
    if out_path is None:
        suffix = f"eps{epsilon:.2f}_v{vanes}_t{vane_thickness:.3f}_rot{rotate_deg:.0f}_g{gamma:.2f}"
        ab = f"d{c_defocus:.2f}_a0{c_astig0:.2f}_a45{c_astig45:.2f}_cx{c_coma_x:.2f}_cy{c_coma_y:.2f}_s{c_spherical:.2f}"
        out_path = f"telescope_psf_allRGB_{W}x{H}_{suffix}_{ab}_{'inv' if invert else 'norm'}_{ts}.png"

    Image.fromarray(img, mode="RGB").save(out_path, compress_level=0, optimize=False)
    print(f"Done. Saved: {out_path}")
    return img

if __name__ == "__main__":
    # Tasteful defaults; tweak freely (all monotone/gamma and optical changes preserve exact-once mapping).
    build_image(
        size=4096,
        invert=False,          # True puts vivid colors onto the dark spikes/rings
        # Pupil
        epsilon=0.33,          # 0.10..0.40 typical; larger → bigger central hole → stronger rings
        vanes=4,               # 3,4,6 common; controls number of spikes
        vane_thickness=0.008,  # 0.006..0.012 looks good
        rotate_deg=25.0,
        gamma=0.80,            # 0.75..0.95: lower → more visible rings/spikes

        # Aberrations (in waves). Try small nonzero for personality:
        c_defocus=0.08,
        c_astig0=0.05,
        c_astig45=0.00,
        c_coma_x=0.06,
        c_coma_y=-0.04,
        c_spherical=0.03,

        # Overlays
        use_crosshair=True,
        use_legend=True,
        legend_box=(32, 4096-32-120, 480, 120),  # x,y,w,h (place near bottom-left)
        legend_thick=2,
        ticks=9, tick_len=16, tick_thick=2,
    )

FULL ROTATIONS v6

2025-08-20T14:24:54+02:00

FULL ROTATIONS v6

Smooth version
Color wheel style

Each of 16 frames has got 16,777,216 unique colors

FULL ROTATIONS v5

2025-08-20T13:49:14+02:00

FULL ROTATIONS v5

Each of 16 frames has got 16,777,216 unique colors

Interlaced 16 colors

2025-08-20T13:41:07+02:00

From allrgb.com/16-colors

One of the biggest difficulties was to get all the 16 colors pieces in the same quantity
16 * 4096 pieces = 65536 pieces

In the same collection :
Interlaced 2 colors
Interlaced 3 colors (RGB)
Interlaced 8 colors v1
Interlaced 8 colors v2
Interlaced 16 colors v2

Interlaced 8 colors v2

2025-08-17T21:28:48+02:00

v1 : patterns

v2 : image
One of the biggest difficulties was to get all the 8 colors pieces in the same quantity
8 * 8192 pieces = 65536 pieces

In the same collection :
Interlaced 2 colors
Interlaced 3 colors (RGB)
Interlaced 8 colors v1
Interlaced 8 colors v2
Interlaced 16 colors v2

16 colors

2025-08-15T10:27:35+02:00

16 colors

CHALLENGE GAME FOR GEEKS #28

2025-08-15T10:22:18+02:00

Challenge n°28 : Mastermind v2 (16 colors)

Find the good combination !
No colors repeated

WELL placed / BAD placed :
0 / 1
0 / 1
0 / 1
1 / 0
0 / 1
0 / 1
0 / 1
0 / 1
0 / 1
1 / 0
0 / 1
0 / 1
0 / 1
1 / 0
0 / 1
0 / 1

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

CHALLENGE GAME FOR GEEKS #27

2025-08-14T16:20:38+02:00

Challenge n°27 : Mastermind v1 (easy !)

Find the good combination !
No colors repeated / No colors well placed
(In other words : each index clue line is 0 - ?)

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

Penrose Diagram v3

2025-08-14T13:22:25+02:00

I took another stab at generating a Penrose diagram using Chatgpt 5. The resulting Python script was executed in a Google Colab notebook:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Penrose (conformal) diagram using every 24-bit RGB color exactly once.

This version includes:
  • STIX Two Math auto-download & use for all labels (covers ? and en dashes).
  • Superscripts (+, −, 0) composed with font metrics (no clipping, no tofu).
  • MANY semantic labels (?±, i±/i0, H± along horizons, ER bridge, etc.).
  • Crisp dark outline around the Penrose diamond (|x'| + |y'| = 1).
  • EVEN, matched r=const curves in all four regions (II/IV mirror I/III).
  • Center-bright radial gradients per region + low-chroma ripple background.
  • Sub-pixel horizon margin (no offsets).
  • Strict exclusive layer partitioning ⇒ exact all-RGB accounting.

Maximally extended Schwarzschild spacetime (Kruskal–Szekeres), units G=c=1, M=1.
"""

import os, time, math, pathlib
from datetime import datetime
import numpy as np
from PIL import Image, ImageDraw, ImageFont, ImageFilter, Image as PILImage

# Optional network fetch for font (works in Colab)
try:
    import requests
except Exception:
    requests = None  # graceful fallback if blocked

# ----------------------------
# Canvas & appearance
# ----------------------------
W = H = 4096
MARGIN_FRAC = 0.06
LINE_PX = 4             # horizons/singularities thickness
GRID_LINE_PX = 2
FRAME_PX = 6            # dark outline around the diamond
SING_MARGIN_FRAC = 0.08
LABEL_FONT_SIZE = 48
LABEL_STROKE_PIX = 2
VERIFY_UNIQUENESS = True
OUTPUT_DIR = "."

# ----------------------------
# Grid controls
# ----------------------------
DRAW_GRID = True
GRID_SAMPLES = 1700
KRUSKAL_K = 0.60

# r=const families
N_R_EXT = 14             # r>2 (Regions I & III)
N_R_INT = N_R_EXT        # r<2 (Regions II & IV), must match exterior
Y_REF_INT = 0.50         # interior reference level (|y'|), mid-wedge for robust spread

# Constant-t lines
N_T = 13
THETA_MAX_DEG = 42.0

# Optional non-radial null geodesics (OFF by default)
DRAW_CURVED_NULL = False
GEO_CURVE_PX = 2
GEODESIC_IMPACT_PARAMS = [5.6, 6.5, 8.0, 11.0, 16.0]
GEODESIC_RMAX = 60.0
GEODESIC_SAMPLES = 1800
COMPACT_K_NULL = 0.40

# Region hue personalities
REGION_HUE_PREFS = {
    "I":   [(210, 300)],          # blue–violet
    "III": [(20,  70)],           # orange–yellow
    "II":  [(300, 360), (0, 20)], # magenta–red
    "IV":  [(70,  200)],          # green–cyan
}
MIN_CHROMA_FOR_REGIONS = 25.0

# ----------------------------
# sRGB → LAB helpers (D65)
# ----------------------------
def srgb_to_linear(c):
    a = 0.055
    return np.where(c <= 0.04045, c/12.92, ((c + a) / (1 + a))**2.4)

def rgb01_to_lab(rgb01):
    M = np.array([[0.4124564, 0.3575761, 0.1804375],
                  [0.2126729, 0.7151522, 0.0721750],
                  [0.0193339, 0.1191920, 0.9503041]])
    Xn, Yn, Zn = 0.95047, 1.0, 1.08883
    lin = srgb_to_linear(rgb01)
    XYZ = np.dot(lin, M.T)
    X = XYZ[...,0] / Xn
    Y = XYZ[...,1] / Yn
    Z = XYZ[...,2] / Zn
    eps = (6/29)**3
    kappa = (29/3)**2/3
    def f(t): return np.where(t > eps, np.cbrt(t), (kappa*t + 16)/116)
    fX, fY, fZ = f(X), f(Y), f(Z)
    L = 116*fY - 16
    a = 500*(fX - fY)
    b = 200*(fY - fZ)
    return L, a, b

def atan2_deg(y, x):
    ang = np.degrees(np.arctan2(y, x))
    return np.where(ang < 0, ang + 360.0, ang)

# ----------------------------
# Palette allocator (64^3 bins; 64 colors/bin)
# ----------------------------
class BinPalette:
    def __init__(self):
        rb = np.arange(64, dtype=np.uint16)
        gb = np.arange(64, dtype=np.uint16)
        bb = np.arange(64, dtype=np.uint16)
        Rb, Gb, Bb = np.meshgrid(rb, gb, bb, indexing='ij')

        Rc = (Rb*4 + 2).astype(np.float32)
        Gc = (Gb*4 + 2).astype(np.float32)
        Bc = (Bb*4 + 2).astype(np.float32)
        rgb01 = np.stack([Rc, Gc, Bc], axis=-1) / 255.0

        L, a, b = rgb01_to_lab(rgb01)
        C = np.sqrt(a*a + b*b)
        h = atan2_deg(b, a)

        self.L = L.ravel(); self.C = C.ravel(); self.h = h.ravel()
        self.bin_count = 64**3
        self.consumed = np.zeros(self.bin_count, dtype=np.uint8)

        # intra-bin sequence (Morton-like) to spread subcolors
        offs = []
        for dr in range(4):
            for dg in range(4):
                for db in range(4):
                    morton = ((dr & 1) | ((dg & 1) << 1) | ((db & 1) << 2)
                              | (((dr>>1)&1) << 3) | (((dg>>1)&1) << 4) | (((db>>1)&1) << 5))
                    offs.append((morton, dr, dg, db))
        offs.sort(key=lambda t: t[0])
        self.intra = np.array([[dr,dg,db] for _,dr,dg,db in offs], dtype=np.uint8)

        self._rb = np.repeat(np.arange(64, dtype=np.uint16), 64*64)
        self._gb = np.tile(np.repeat(np.arange(64, dtype=np.uint16), 64), 64)
        self._bb = np.tile(np.arange(64, dtype=np.uint16), 64*64)

        self._dark_bins  = np.argsort(self.L)
        self._light_bins = np.argsort(-self.L)
        self._gray_bins  = np.lexsort((self.L, self.C))

    def _bin_base_rgb(self, bin_id):
        return np.array([int(self._rb[bin_id])*4,
                         int(self._gb[bin_id])*4,
                         int(self._bb[bin_id])*4], dtype=np.uint16)

    def _take_from_bin(self, bin_id, n):
        used = int(self.consumed[bin_id])
        if used >= 64: return None
        take = min(n, 64 - used)
        base = self._bin_base_rgb(bin_id)
        sl = self.intra[used:used+take].astype(np.uint16)
        cols = (base[None,:] + sl).astype(np.uint8)
        self.consumed[bin_id] = used + take
        return cols

    def allocate_from_bins(self, order, count):
        out = np.empty((count,3), dtype=np.uint8); filled = 0
        for bin_id in order:
            if filled >= count: break
            got = self._take_from_bin(bin_id, count - filled)
            if got is None: continue
            n = got.shape[0]; out[filled:filled+n] = got; filled += n
        if filled != count:
            for bin_id in range(self.bin_count):
                if filled >= count: break
                got = self._take_from_bin(bin_id, count - filled)
                if got is None: continue
                n = got.shape[0]; out[filled:filled+n] = got; filled += n
        assert filled == count, f"Allocator shortage: {filled}/{count}"
        return out

    def allocate_dark(self, count):       return self.allocate_from_bins(self._dark_bins,  count)
    def allocate_light(self, count):      return self.allocate_from_bins(self._light_bins, count)
    def allocate_low_chroma(self, count): return self.allocate_from_bins(self._gray_bins,  count)

    def bins_by_hue_preference(self, ranges, min_chroma=0.0):
        h, C, L = self.h, self.C, self.L
        def dist_to_ranges(hv):
            best = 180.0
            for a,b in ranges:
                if a<=b:
                    if a<=hv<=b: return 0.0
                    best = min(best, min(abs(hv-a), abs(hv-b)))
                else:
                    if (hv>=a) or (hv<=b): return 0.0
                    d1 = (a - hv) % 360.0; d2 = (hv - b) % 360.0
                    best = min(best, min(d1, d2))
            return best
        d = np.vectorize(dist_to_ranges)(h)
        order = np.lexsort((np.abs(L-50.0), -C, d))
        if min_chroma>0:
            hi = np.where(C[order] >= min_chroma)[0]
            lo = np.where(C[order] <  min_chroma)[0]
            order = np.concatenate([order[hi], order[lo]])
        return order

# ----------------------------
# Geometry & masks (diamond + regions + horizons)
# ----------------------------
def make_coordinate_grids(w, h, margin_frac):
    y, x = np.mgrid[0:h, 0:w].astype(np.float32)
    cx, cy = (w - 1) / 2.0, (h - 1) / 2.0
    half = min(w, h) * (0.5 - margin_frac)
    xp = (x - cx) / half
    yp = (cy - y) / half
    return xp, yp, half, cx, cy

def make_masks(w, h, margin_frac, line_px, sing_margin_frac):
    xp, yp, half, cx, cy = make_coordinate_grids(w, h, margin_frac)
    diamond = (np.abs(xp) + np.abs(yp) <= 1.0)
    s1 = yp - xp; s2 = yp + xp
    t = line_px / half

    horizons = ((np.abs(s1) <= t) | (np.abs(s2) <= t)) & diamond

    reg_II  = (s1 >  t) & (s2 >  t) & diamond
    reg_IV  = (s1 < -t) & (s2 < -t) & diamond
    reg_I   = (s1 < -t) & (s2 >  t) & diamond
    reg_III = (s1 >  t) & (s2 <  t) & diamond

    y_top =  1.0 - sing_margin_frac
    y_bot = -1.0 + sing_margin_frac
    singular = ((np.abs(yp - y_top) <= t) | (np.abs(yp - y_bot) <= t)) & diamond

    outside = ~diamond

    return {
        "diamond": diamond,
        "I": reg_I, "II": reg_II, "III": reg_III, "IV": reg_IV,
        "horizons": horizons, "singular": singular, "outside": outside,
        "xp": xp, "yp": yp, "half": half, "cx": cx, "cy": cy
    }

# ----------------------------
# Font: STIX Two Math (auto-download) + robust fallbacks
# ----------------------------
STIX_MATH_URLS = [
    # CTAN mirrors hosting the OTF
    "https://mirrors.ibiblio.org/pub/mirrors/CTAN/fonts/stix2-otf/STIXTwoMath-Regular.otf",
    "https://ftp.jaist.ac.jp/pub/CTAN/fonts/stix2-otf/STIXTwoMath-Regular.otf",
    "https://mirrors.ctan.org/fonts/stix2-otf/otf/STIXTwoMath-Regular.otf",
]

def ensure_stix_two_math_otf(local_dir="fonts", filename="STIXTwoMath-Regular.otf"):
    """Download STIX Two Math OTF if missing; return filesystem path."""
    pdir = pathlib.Path(local_dir); pdir.mkdir(parents=True, exist_ok=True)
    fpath = pdir / filename
    if fpath.exists() and fpath.stat().st_size > 0:
        return str(fpath)
    if requests is None:
        raise RuntimeError("requests not available to fetch STIXTwoMath-Regular.otf")
    last_err = None
    for url in STIX_MATH_URLS:
        try:
            r = requests.get(url, stream=True, timeout=30)
            r.raise_for_status()
            with open(fpath, "wb") as out:
                for chunk in r.iter_content(1 << 14):
                    if chunk: out.write(chunk)
            if fpath.stat().st_size > 0:
                return str(fpath)
        except Exception as e:
            last_err = e
    raise RuntimeError(f"Could not fetch STIXTwoMath-Regular.otf. Last error: {last_err}")

def load_font_main(size):
    """Prefer STIX Two Math (download if needed), then robust fallbacks."""
    try:
        path = ensure_stix_two_math_otf()
        return ImageFont.truetype(path, size)
    except Exception:
        for p in [
            "/usr/share/fonts/opentype/stix-two/STIXTwoMath-Regular.otf",
            "/usr/share/fonts/truetype/noto/NotoSansMath-Regular.ttf",
            "/usr/share/fonts/opentype/xits-math/XITSMath-Regular.otf",
            "/usr/share/fonts/opentype/lm-math/LatinModernMath-Regular.otf",
            "/usr/share/fonts/truetype/freefont/FreeSerif.ttf",
            "/usr/share/fonts/truetype/dejavu/DejaVuSerif.ttf",
            "DejaVuSerif.ttf",
        ]:
            try:
                return ImageFont.truetype(p, size)
            except Exception:
                continue
        return ImageFont.load_default()

# ----------------------------
# Labels → fill & stroke masks (rotations + composed superscripts)
# ----------------------------
def place_labels_masks(w, h, masks, font_size=48, stroke_px=2):
    """Return (fill_mask, stroke_mask) as boolean arrays, using STIX Two Math."""
    img = Image.new("L", (w, h), 0)
    drw = ImageDraw.Draw(img)
    font_main = load_font_main(font_size)
    cx, cy, half = masks["cx"], masks["cy"], masks["half"]

    def xy_from_norm(xp, yp):
        return (int(round(cx + xp * half)), int(round(cy - yp * half)))

    def draw_text(text, xp, yp, anchor="mm", angle=0, font=None):
        """Plain run (no superscript composition)."""
        if font is None: font = font_main
        if angle == 0:
            drw.text(xy_from_norm(xp, yp), text, fill=255, font=font, anchor=anchor)
        else:
            pad = max(12, int(0.45 * font.size))
            tw = drw.textlength(text, font=font)
            a, d = font.getmetrics()
            th = a + d
            tmp = Image.new("L", (int(tw)+2*pad, int(th)+2*pad), 0)
            ImageDraw.Draw(tmp).text((pad, pad + a), text, fill=255, font=font, anchor="ls")
            tmp = tmp.rotate(angle, expand=1, resample=Image.NEAREST)
            x, y = xy_from_norm(xp, yp); bx, by = tmp.size[0]//2, tmp.size[1]//2
            img.paste(tmp, (x - bx, y - by), tmp)

    def draw_with_superscript(base_txt, super_txt, xp, yp, tail_txt="",
                              angle=0, anchor="mm",
                              base_size=font_size, super_scale=0.72, super_raise=0.55, gap_px=0,
                              base_font=None, super_font=None, tail_font=None):
        """
        Compose (base)(superscript)(tail) with proper metrics so nothing clips.
        All runs use STIX Two Math (or fallbacks).
        """
        base_font = base_font or load_font_main(int(round(base_size)))
        super_font = super_font or load_font_main(int(round(base_size*super_scale)))
        tail_font = tail_font or base_font

        pad = max(12, int(0.45 * base_size))

        # widths
        canvas = Image.new("L", (2,2), 0)
        meas = ImageDraw.Draw(canvas)
        w_base = meas.textlength(base_txt, font=base_font) if base_txt else 0
        w_sup  = meas.textlength(super_txt, font=super_font) if super_txt else 0
        w_tail = meas.textlength(tail_txt, font=tail_font) if tail_txt else 0

        a_b, d_b = base_font.getmetrics()
        a_s, d_s = super_font.getmetrics()

        # vertical sizing so the superscript never clips
        raise_px = int(round(base_size * super_raise))
        top_over = max(0, (raise_px + a_s) - a_b)         # extra above baseline
        height = a_b + d_b + top_over

        Wtmp = int(math.ceil(w_base + (gap_px if super_txt else 0) + w_sup + w_tail)) + 2*pad
        Htmp = height + 2*pad
        tmp = Image.new("L", (max(1, Wtmp), max(1, Htmp)), 0)
        tdr = ImageDraw.Draw(tmp)

        # baselines
        y_base = pad + top_over + a_b
        x = pad
        if base_txt:
            tdr.text((x, y_base), base_txt, fill=255, font=base_font, anchor="ls")
            x += w_base
        if super_txt:
            tdr.text((x + gap_px, y_base - raise_px), super_txt, fill=255, font=super_font, anchor="ls")
            x += gap_px + w_sup
        if tail_txt:
            tdr.text((x, y_base), tail_txt, fill=255, font=tail_font, anchor="ls")

        if angle != 0:
            tmp = tmp.rotate(angle, expand=1, resample=Image.NEAREST)

        X, Y = xy_from_norm(xp, yp); bx, by = tmp.size[0]//2, tmp.size[1]//2
        img.paste(tmp, (X - bx, Y - by), tmp)

    # ---------------- Labels ----------------
    # Regions
    draw_text("Region I (exterior)",    0.67,  0.00)
    draw_text("Region III (exterior)", -0.67,  0.00)
    draw_text("Region II (black hole interior, r < 2M)",  0.00,  0.67)
    draw_text("Region IV (white hole interior, r < 2M)",  0.00, -0.67)

    # Singularities
    draw_text("Spacelike singularity  r = 0", 0.00,  1.0 - SING_MARGIN_FRAC + 0.03)
    draw_text("Spacelike singularity  r = 0", 0.00, -1.0 + SING_MARGIN_FRAC - 0.03)

    # Horizons / bifurcation sphere
    draw_text("Event horizons  r = 2M", 0.00, 0.00)
    draw_text("Bifurcation 2-sphere",   0.00, 0.08)

    # Rotated horizon labels H^±
    draw_with_superscript("H", "+",  0.38,  0.38, angle=-45)
    draw_with_superscript("H", "−", -0.38, -0.38, angle=-45)
    draw_with_superscript("H", "+", -0.38,  0.38, angle=+45)
    draw_with_superscript("H", "−",  0.38, -0.38, angle=+45)

    # ?^± with tail text
    draw_with_superscript("?", "+",  0.58,  0.46, tail_txt=" (future null infinity)", angle=-45)
    draw_with_superscript("?", "−",  0.58, -0.46, tail_txt=" (past null infinity)",   angle=+45)
    draw_with_superscript("?", "+", -0.58,  0.46, angle=+45)
    draw_with_superscript("?", "−", -0.58, -0.46, angle=-45)

    # Timelike/spacelike infinities: i^±, i^0
    draw_with_superscript("i", "+",  0.00,  1.02)
    draw_with_superscript("i", "−",  0.00, -1.02)
    draw_with_superscript("i", "0",  1.02,  0.00)
    draw_with_superscript("i", "0", -1.02,  0.00)

    # Asymptotically flat directions
    draw_text("r → ∞",  0.90, 0.00)
    draw_text("r → ∞", -0.90, 0.00)

    # ER bridge — note the en dash “–”
    draw_text("t = 0  (Einstein–Rosen bridge)", 0.00, -0.06)

    # Build masks
    fill_mask = (np.array(img, dtype=np.uint8) > 0)

    # Stroke = dilation of glyphs minus fill
    rad = max(1, int(round(stroke_px)))
    size = 2*rad + 1
    dilated = img.filter(ImageFilter.MaxFilter(size))
    stroke_mask = (np.array(dilated, dtype=np.uint8) > 0) & (~fill_mask)

    return fill_mask, stroke_mask

# ----------------------------
# Kruskal relations & compactification
# ----------------------------
def C_of_r(r):   # (1 - r/2) e^{r/2}
    return (1.0 - 0.5*r) * math.exp(0.5*r)

def compactify_UV_to_xy(U, V, k=KRUSKAL_K):
    Uc = (2.0/np.pi) * np.arctan(k * U)
    Vc = (2.0/np.pi) * np.arctan(k * V)
    xprime = 0.5*(Vc - Uc)
    yprime = 0.5*(Vc + Uc)
    return xprime, yprime

# ----------------------------
# EVEN spacing helpers for r-curves
# ----------------------------
def r_from_xprime_exterior(xp_target, k=KRUSKAL_K):
    # Exterior (I,III): ensure each r>2 curve hits y'=0 at evenly spaced x'.
    X_target = math.tan(0.5*math.pi * xp_target) / k
    S = X_target * X_target
    lo = 2.0 + 1e-8; hi = 6.0
    def g(r): return C_of_r(r) + S  # want C(r) = -S
    while g(hi) > 0.0:
        hi *= 1.7
        if hi > 1e6: raise RuntimeError("r_from_xprime_exterior bracket fail")
    for _ in range(80):
        mid = 0.5*(lo+hi)
        if g(mid) > 0: lo = mid
        else:          hi = mid
    return 0.5*(lo+hi)

def xprime_at_y_for_r(r, y_ref, k=KRUSKAL_K):
    """
    For r in (0,2), find x'(r) at the compactified horizontal level y'=y_ref (|y_ref|<1):
      arctan(kU) + arctan(kV) = y_ref * π, with UV = C(r) > 0.
    """
    C = C_of_r(r)
    A = y_ref * math.pi
    TA = math.tan(A)
    S = (TA / k) * (1.0 - (k*k) * C)
    disc = S*S - 4.0*C
    if disc <= 0:
        return None
    rt = math.sqrt(disc)
    U1 = 0.5*(S + rt)
    U2 = 0.5*(S - rt)
    def pick(U):
        V = S - U
        # y_ref>0 (II): U,V < 0 ; y_ref<0 (IV): U,V > 0
        sgn = -1.0 if y_ref > 0 else +1.0
        if (U*sgn > 0) and (V*sgn > 0):
            Uc = (2.0/np.pi) * math.atan(k * U)
            Vc = (2.0/np.pi) * math.atan(k * V)
            return 0.5*(Vc - Uc)
        return None
    x1 = pick(U1); x2 = pick(U2)
    if x1 is None and x2 is None:
        return None
    return x1 if x1 is not None else x2

def interior_r_list_even_x(n_int, y_ref_mag=Y_REF_INT, k=KRUSKAL_K, scan_pts=1200, edge_trim=0.06):
    """
    Build r<2 list by scanning x'(r; +y_ref_mag) over r∈(0,2), then invert by interpolation
    to place n_int curves at evenly spaced x' across the achievable band.
    """
    y_ref = float(np.clip(y_ref_mag, 0.05, 0.90))
    rmin, rmax = 1e-7, 2.0 - 1e-7
    rs = np.linspace(rmin, rmax, scan_pts)
    xs = np.array([xprime_at_y_for_r(float(r), +y_ref, k) for r in rs], dtype=np.float64)
    ok = ~np.isnan(xs)
    rs, xs = rs[ok], xs[ok]
    if xs.size < 16:
        # Fallback: evenly spaced by C in (0,2)
        Cs = np.linspace(0.95, 0.05, n_int)
        return [invert_C_to_r(float(C)) for C in Cs]
    order = np.argsort(xs)
    xs = xs[order]; rs = rs[order]
    x_lo, x_hi = xs[0], xs[-1]
    span = x_hi - x_lo
    if span < 0.2:
        Cs = np.linspace(0.95, 0.05, n_int)
        return [invert_C_to_r(float(C)) for C in Cs]
    x_lo2 = x_lo + edge_trim * span
    x_hi2 = x_hi - edge_trim * span
    x_targets = np.linspace(x_lo2, x_hi2, n_int)
    r_targets = np.interp(x_targets, xs, rs)
    for i in range(1, len(r_targets)):
        if not (r_targets[i] > r_targets[i-1] + 1e-8):
            r_targets[i] = r_targets[i-1] + 1e-6
    return list(map(float, r_targets))

def invert_C_to_r(C):
    # Monotone on (0,2): bisection
    lo, hi = 1e-10, 2.0 - 1e-10
    def f(r): return C_of_r(r) - C
    for _ in range(80):
        mid = 0.5*(lo+hi)
        if f(mid) > 0: lo = mid
        else:          hi = mid
    return 0.5*(lo+hi)

def choose_even_r_lists(n_ext, n_int, k=KRUSKAL_K, edge_xp=0.06, y_ref_int=Y_REF_INT):
    # Exterior r>2 via even x' at y'=0
    x_targets_ext = np.linspace(edge_xp, 1.0 - edge_xp, n_ext, dtype=np.float64)
    r_ext = [r_from_xprime_exterior(float(xp), k=k) for xp in x_targets_ext]
    # Interior r<2 via robust monotonic inversion at mid-wedge
    r_int = interior_r_list_even_x(n_int, y_ref_mag=y_ref_int, k=k)
    return r_ext, r_int

# ----------------------------
# Constant-t list (even “angle”)
# ----------------------------
def build_even_t_list(n_t, theta_max_deg=THETA_MAX_DEG):
    if n_t <= 0: return []
    th_max = math.radians(theta_max_deg)
    thetas = np.linspace(-th_max, th_max, n_t)
    out = []
    for th in thetas:
        m = math.tan(th)
        if abs(m) >= 1.0:
            m = math.copysign(0.999999, m)
        t = 4.0 * np.arctanh(m)
        out.append(float(t))
    return out

# ----------------------------
# Grid rasterization (sub-pixel horizon margin)
# ----------------------------
def make_coord_grid_mask(masks, line_px, n_samples,
                         r_ext_list, r_int_list, t_list, k_scale=KRUSKAL_K,
                         eps_hor_uc=1e-6, eps_inf_uc=0.003):
    """
    eps_hor_uc: tiny exclusion around U=0 in compactified Uc units (sub-pixel).
    eps_inf_uc: exclusion near |Uc|=1 to avoid degeneracy near corners.
    """
    xp_grid, yp_grid, half, cx, cy = masks["xp"], masks["yp"], masks["half"], masks["cx"], masks["cy"]
    H, W = xp_grid.shape

    img = PILImage.new("L", (W, H), 0)
    draw = ImageDraw.Draw(img)

    def to_px(xp, yp):
        x = np.rint(cx + xp * half).astype(np.int32)
        y = np.rint(cy - yp * half).astype(np.int32)
        return x, y

    def draw_parametric_from_Uc(Uc_lo, Uc_hi, V_from_U, keep_region=None):
        # Chebyshev nodes → denser near ends
        t = np.linspace(0.0, 1.0, n_samples)
        Uc = 0.5*((Uc_hi+Uc_lo) + (Uc_hi-Uc_lo)*np.cos((1.0 - t)*math.pi))
        U = (1.0/k_scale) * np.tan(0.5*np.pi * Uc)
        V = V_from_U(U)
        if keep_region:
            uv = U * V
            ok = (uv < 0.0) if keep_region == "ext" else (uv > 0.0)
            U = U[ok]; V = V[ok]
        finite = np.isfinite(U) & np.isfinite(V)
        U, V = U[finite], V[finite]
        if U.size < 2: return
        xp, yp = compactify_UV_to_xy(U, V, k=k_scale)
        keep = (np.abs(xp) + np.abs(yp) <= 1.02)
        if np.count_nonzero(keep) < 2: return
        xpx, ypx = to_px(xp[keep].astype(np.float32), yp[keep].astype(np.float32))
        pts = list(map(tuple, np.stack([xpx, ypx], axis=1)))
        if len(pts) >= 2:
            draw.line(pts, fill=255, width=line_px, joint="curve")

    # Constant-r hyperbolae: UV = C(r)
    for r in r_ext_list:  # I and III (C<0)
        C = C_of_r(r)
        draw_parametric_from_Uc(-1.0+eps_inf_uc, -eps_hor_uc, lambda U: C / U)  # Region I
        draw_parametric_from_Uc( eps_hor_uc,  1.0-eps_inf_uc, lambda U: C / U)  # Region III

    for r in r_int_list:  # II and IV (C>0)
        C = C_of_r(r)
        draw_parametric_from_Uc(-1.0+eps_inf_uc, -eps_hor_uc, lambda U: C / U)  # Region II
        draw_parametric_from_Uc( eps_hor_uc,  1.0-eps_inf_uc, lambda U: C / U)  # Region IV

    # Constant-t (region-aware)
    for t in t_list:
        eta = math.exp(0.5*t)
        draw_parametric_from_Uc(-1.0+eps_inf_uc, -eps_hor_uc, lambda U: -eta*U, keep_region="ext")  # I
        draw_parametric_from_Uc( eps_hor_uc,  1.0-eps_inf_uc, lambda U: -eta*U, keep_region="ext")  # III
        draw_parametric_from_Uc(-1.0+eps_inf_uc, -eps_hor_uc, lambda U:  eta*U, keep_region="int")  # II
        draw_parametric_from_Uc( eps_hor_uc,  1.0-eps_inf_uc, lambda U:  eta*U, keep_region="int")  # IV

    return (np.array(img, dtype=np.uint8) > 0) & masks["diamond"]

# ----------------------------
# Optional: sparse curved non-radial null rays
# ----------------------------
def r_star_of_r(r):  return r + 2.0 * np.log(abs(r/2.0 - 1.0))
def f_null_radial_factor(b, r): return 1.0 - (1.0 - 2.0/r) * (b*b) / (r*r)
def dt_dr(b, r):
    f = f_null_radial_factor(b, r)
    return 1.0 / ((1.0 - 2.0/r) * np.sqrt(np.maximum(f, 1e-16)))

def find_turning_radius(b, r_hi=2000.0):
    lo, hi = 3.0, r_hi
    def f(r): return f_null_radial_factor(b, r)
    if f(hi) <= 0: raise RuntimeError("Failed to bracket turning radius")
    if f(lo) > 0: lo = 3.0001
    for _ in range(80):
        mid = 0.5*(lo + hi)
        if f(mid) <= 0: lo = mid
        else:           hi = mid
    return 0.5*(lo+hi)

def compactify_uv_to_xy(u, v, k=COMPACT_K_NULL):
    Uc = (2.0/np.pi) * np.arctan(k * u)
    Vc = (2.0/np.pi) * np.arctan(k * v)
    xprime = 0.5*(Vc - Uc); yprime = 0.5*(Vc + Uc)
    return xprime, yprime

def make_curved_null_mask(masks, width_px, b_list, rmax, samples, k_scale):
    if not b_list:
        return np.zeros_like(masks["diamond"], dtype=bool)
    xp_grid, yp_grid, half, cx, cy = masks["xp"], masks["yp"], masks["half"], masks["cx"], masks["cy"]
    H, W = xp_grid.shape
    img = PILImage.new("L", (W, H), 0)
    draw = ImageDraw.Draw(img)

    def to_px(xp, yp):
        x = np.rint(cx + xp * half).astype(np.int32)
        y = np.rint(cy - yp * half).astype(np.int32)
        return x, y

    for b in b_list:
        r_turn = find_turning_radius(b, r_hi=max(rmax, 100.0))
        y = np.linspace(0.0, 1.0, samples, dtype=np.float64)
        r_half = r_turn + (rmax - r_turn) * (y**2)
        integrand = dt_dr(b, r_half)
        t_half = np.cumsum(0.5*(integrand[1:] + integrand[:-1]) * (r_half[1:] - r_half[:-1]))
        t_half = np.concatenate(([0.0], t_half))
        rstar_half = r_star_of_r(r_half)
        rstar_in  = rstar_half[::-1];  t_in  = -t_half[::-1]
        rstar_out = rstar_half;        t_out =  t_half
        rstar = np.concatenate([rstar_in, rstar_out[1:]])
        t     = np.concatenate([t_in,     t_out[1:]])
        u = t - rstar; v = t + rstar
        xp, yp = compactify_uv_to_xy(u, v, k=k_scale)
        keep = (np.abs(xp) + np.abs(yp) <= 1.02)
        xp = xp[keep]; yp = yp[keep]
        if xp.size < 2: continue
        xpx, ypx = to_px(xp.astype(np.float32), yp.astype(np.float32))
        pts = list(map(tuple, np.stack([xpx, ypx], axis=1)))
        draw.line(pts, fill=255, width=width_px, joint="curve")

    return (np.array(img, dtype=np.uint8) > 0) & masks["diamond"]

# ----------------------------
# Region gradients (lightest at region centers)
# ----------------------------
def region_focal_points():
    return {
        "I":   ( +0.50,  0.00),
        "III": ( -0.50,  0.00),
        "II":  (  0.00, +0.50),
        "IV":  (  0.00, -0.50),
    }

def lab_L_for_rgb(cols):
    rgb01 = cols.astype(np.float32) / 255.0
    L, _, _ = rgb01_to_lab(rgb01)
    return L

def assign_region_gradient(flat, idxs, cols, xp, yp, focus_xy):
    if len(idxs) == 0: return
    h, w = yp.shape
    yy, xx = np.divmod(idxs, w)
    xps = xp[yy, xx]; yps = yp[yy, xx]
    fx, fy = focus_xy
    d = np.hypot(xps - fx, yps - fy)
    wts = 1.0 - np.clip(d, 0.0, 1.2) / 1.2
    wts = wts**1.2
    order_pix = np.argsort(-wts)          # closest first
    Ls = lab_L_for_rgb(cols)
    order_col = np.argsort(-Ls)           # brightest first
    flat[idxs[order_pix]] = cols[order_col]

# ----------------------------
# Background (outside diamond): low-chroma ripples
# ----------------------------
def assign_background_pattern(flat, idxs, cols, xp, yp):
    if len(idxs) == 0: return
    h, w = yp.shape
    yy, xx = np.divmod(idxs, w)
    xps = xp[yy, xx]; yps = yp[yy, xx]
    r1 = np.abs(xps) + np.abs(yps)                # diamond radius
    ang = np.arctan2(yps, xps)
    key = r1 + 0.020*np.sin(18.0*r1 + 4.0*ang)    # subtle ripple
    order_pix = np.argsort(key)
    rgb01 = cols.astype(np.float32) / 255.0
    L, a, b = rgb01_to_lab(rgb01)
    C = np.sqrt(a*a + b*b)
    order_col = np.lexsort((np.abs(L-55.0), C))   # prefer lower chroma, mid L
    flat[idxs[order_pix]] = cols[order_col]

# ----------------------------
# Fill helper
# ----------------------------
def fill_indices(img_flat, idxs, colors):
    assert colors.shape[0] == idxs.shape[0]
    img_flat[idxs] = colors

# ----------------------------
# Main
# ----------------------------
def main():
    t0 = time.time()

    masks = make_masks(W, H, MARGIN_FRAC, LINE_PX, SING_MARGIN_FRAC)
    xp, yp, half = masks["xp"], masks["yp"], masks["half"]

    # Base masks (exclusivity comes later)
    label_fill_mask, label_stroke_mask = place_labels_masks(W, H, masks, LABEL_FONT_SIZE, LABEL_STROKE_PIX)
    line_mask_base = (masks["horizons"] | masks["singular"])  # within diamond already
    frame_band = (np.abs(np.abs(xp) + np.abs(yp) - 1.0) <= (FRAME_PX / half))  # diamond outline band

    # Grid / t-lines
    if DRAW_GRID:
        r_ext_list, r_int_list = choose_even_r_lists(N_R_EXT, N_R_INT, k=KRUSKAL_K, y_ref_int=Y_REF_INT)
        t_list = build_even_t_list(N_T, THETA_MAX_DEG)
        grid_mask_raw = make_coord_grid_mask(
            masks, GRID_LINE_PX, GRID_SAMPLES,
            r_ext_list, r_int_list, t_list,
            k_scale=KRUSKAL_K,
            eps_hor_uc=1e-6,    # sub-pixel near horizons
            eps_inf_uc=0.003    # tight near corners
        )
    else:
        grid_mask_raw = np.zeros_like(masks["diamond"], dtype=bool)

    # Optional non-radial null geodesics
    if DRAW_CURVED_NULL:
        geo_mask_raw = make_curved_null_mask(
            masks, width_px=GEO_CURVE_PX,
            b_list=GEODESIC_IMPACT_PARAMS,
            rmax=GEODESIC_RMAX,
            samples=GEODESIC_SAMPLES,
            k_scale=COMPACT_K_NULL
        )
    else:
        geo_mask_raw = np.zeros_like(masks["diamond"], dtype=bool)

    # Region base fills and outside
    reg_I_base, reg_II_base = masks["I"], masks["II"]
    reg_III_base, reg_IV_base = masks["III"], masks["IV"]
    bg_base = masks["outside"]

    # -------- Exclusive partition (TOP → DOWN) --------
    occupied = np.zeros((H, W), dtype=bool)

    def take(mask):
        m = mask & (~occupied)
        occupied[:] = occupied | m
        return m

    # Visual precedence: labels → frame → lines → grid → geo → regions → background
    m_label_fill = take(label_fill_mask)
    m_label_stk  = take(label_stroke_mask)
    m_frame      = take(frame_band)
    m_line       = take(line_mask_base)
    m_grid       = take(grid_mask_raw)
    m_geo        = take(geo_mask_raw)
    m_I          = take(reg_I_base)
    m_II         = take(reg_II_base)
    m_III        = take(reg_III_base)
    m_IV         = take(reg_IV_base)
    m_bg         = take(bg_base)

    assert occupied.all(), "Partition left some pixels unassigned"

    # Pixel counts
    n_label_fill = int(np.count_nonzero(m_label_fill))
    n_label_stk  = int(np.count_nonzero(m_label_stk))
    n_frame      = int(np.count_nonzero(m_frame))
    n_line       = int(np.count_nonzero(m_line))
    n_grid       = int(np.count_nonzero(m_grid))
    n_geo        = int(np.count_nonzero(m_geo))
    n_I          = int(np.count_nonzero(m_I))
    n_II         = int(np.count_nonzero(m_II))
    n_III        = int(np.count_nonzero(m_III))
    n_IV         = int(np.count_nonzero(m_IV))
    n_bg         = int(np.count_nonzero(m_bg))

    total = (n_label_fill + n_label_stk + n_frame + n_line + n_grid + n_geo
             + n_I + n_II + n_III + n_IV + n_bg)
    assert total == W*H, f"Mask coverage error: {total} vs {W*H}"

    print("Pixel budget (exclusive):")
    print(f"  Label fill   : {n_label_fill:,} (lightest)")
    print(f"  Label stroke : {n_label_stk:,} (darkest)")
    print(f"  Frame        : {n_frame:,} (diamond outline)")
    print(f"  Lines        : {n_line:,} (horizons + singularities)")
    print(f"  Grid         : {n_grid:,} (even r- and t-lines)")
    print(f"  Geo          : {n_geo:,} (optional non-radial null)")
    print(f"  Regions I-IV : {n_I:,}, {n_II:,}, {n_III:,}, {n_IV:,}")
    print(f"  Background   : {n_bg:,}")
    print(f"  TOTAL        : {total:,}")

    # Palette
    pal = BinPalette()

    # LIGHTEST → label fill
    cols_label_fill = pal.allocate_light(n_label_fill)
    # DARKEST → label outline, frame, horizons/singularities, grid, optional null
    cols_label_stk  = pal.allocate_dark(n_label_stk)
    cols_frame      = pal.allocate_dark(n_frame)
    cols_lines      = pal.allocate_dark(n_line)
    cols_grid       = pal.allocate_dark(n_grid)
    cols_geo        = pal.allocate_dark(n_geo)
    # Low-chroma → background (patterned)
    cols_bg = pal.allocate_low_chroma(n_bg)

    # Region colors (sorted by hue preferences)
    bins_I   = pal.bins_by_hue_preference(REGION_HUE_PREFS["I"],   MIN_CHROMA_FOR_REGIONS)
    bins_III = pal.bins_by_hue_preference(REGION_HUE_PREFS["III"], MIN_CHROMA_FOR_REGIONS)
    bins_II  = pal.bins_by_hue_preference(REGION_HUE_PREFS["II"],  MIN_CHROMA_FOR_REGIONS)
    bins_IV  = pal.bins_by_hue_preference(REGION_HUE_PREFS["IV"],  MIN_CHROMA_FOR_REGIONS)
    cols_I   = pal.allocate_from_bins(bins_I,   n_I)
    cols_III = pal.allocate_from_bins(bins_III, n_III)
    cols_II  = pal.allocate_from_bins(bins_II,  n_II)
    cols_IV  = pal.allocate_from_bins(bins_IV,  n_IV)

    # Assemble
    img = np.empty((H, W, 3), dtype=np.uint8)
    flat = img.reshape(-1, 3)

    def idx(mask): return np.flatnonzero(mask.ravel())

    idx_label_fill = idx(m_label_fill)
    idx_label_stk  = idx(m_label_stk)
    idx_frame      = idx(m_frame)
    idx_line       = idx(m_line)
    idx_grid       = idx(m_grid)
    idx_geo        = idx(m_geo)
    idx_I          = idx(m_I)
    idx_II         = idx(m_II)
    idx_III        = idx(m_III)
    idx_IV         = idx(m_IV)
    idx_bg         = idx(m_bg)

    # Background (outside diamond): patterned, subdued
    assign_background_pattern(flat, idx_bg, cols_bg, xp, yp)

    # Region gradients (lightest at region centers)
    foc = region_focal_points()
    assign_region_gradient(flat, idx_I,   cols_I,   xp, yp, foc["I"])
    assign_region_gradient(flat, idx_III, cols_III, xp, yp, foc["III"])
    assign_region_gradient(flat, idx_II,  cols_II,  xp, yp, foc["II"])
    assign_region_gradient(flat, idx_IV,  cols_IV,  xp, yp, foc["IV"])

    # Overlays (exclusive masks, order doesn't change totals)
    fill_indices(flat, idx_grid,        cols_grid)
    fill_indices(flat, idx_geo,         cols_geo)
    fill_indices(flat, idx_line,        cols_lines)
    fill_indices(flat, idx_frame,       cols_frame)
    fill_indices(flat, idx_label_stk,   cols_label_stk)
    fill_indices(flat, idx_label_fill,  cols_label_fill)

    if VERIFY_UNIQUENESS:
        packed = (img[...,0].astype(np.uint32) << 16) | (img[...,1].astype(np.uint32) << 8) | img[...,2].astype(np.uint32)
        uniq = np.unique(packed)
        assert uniq.size == 256*256*256, f"Uniqueness failed: {uniq.size} unique colors"
        print("Verified: all 16,777,216 colors used exactly once.")

    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
    out_path = os.path.join(OUTPUT_DIR, f"penrose_allrgb_{W}x{H}_{ts}.png")
    PILImage.fromarray(img, mode="RGB").save(out_path, compress_level=0)
    print(f"Saved: {out_path}  (elapsed {time.time() - t0:.1f}s)")

if __name__ == "__main__":
    main()

Standard Test Images v2

2025-08-11T19:11:37+02:00

I used Chatgpt 5 to take another stab at a standard test images algorithm. (See Standard Test images v1 for the version made with Chatgpt o4.) After some back and forth, I’m quite please with the result.

CHALLENGE GAME FOR GEEKS #26

2025-08-11T16:32:07+02:00

Challenge n°26 : Coloring 3 colors

Fill the :
Y boxes with Yellow
R boxes with Red
B boxes with Black

Preview :

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

The Promptocrat

2025-08-10T20:55:55+02:00

In 2022, I started a side-project called The Promptocrat. It’s an Instagram profile where I post ai generated images, using many different concepts and (diffusion) models, and I always add the exact prompt I used in the description. Its avatar/logo is a portrait of Kim Kardashian depicted as a Hindu goddess in a mixed style of Alphonse Mucha and Gustav Klimt. Why? Because #metamodernism.

Since I’ve been creating a lot of allrgb images with help of large language models lately, I figured it would be fun to do a crossover where I use a diffusion model (in this case Google Imagen 4.0) to generate an instance of the Promptocrat avatar, use another diffusion model to scale it up, and then use a large language model (in this case Chatgpt 5) to write code that converts the image in one that uses all 24-bit rgb colors exactly once, executed on a Google Colab notebook.

In true Promptocrat fashion, here is the initial prompt:

Beautiful portrait of Kim Kardashian as a Hindu Goddess, by Alphonse Mucha and Gustav Klimt. Very detailed, art nouveau, jugendstil, vibrant colors, intrinsic detail, very realistic, centered. Facing the camera.

RGB channels

2025-08-10T12:48:29+02:00

Splited & joined the 3 RGB channels

Hydrogenic Orbitals v1

2025-08-09T23:46:52+02:00

Made with Chatgpt 5, Python 3, Google Colab notebook, and DajaVu Sans.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Orbitals up to n = 8 (204 states), square tiles + fixed 24px DejaVu Sans labels with AA,
with TOP_MARGIN and ROW_SPACING controls, using all 24-bit RGB colors exactly once.
"""

import math, time, numpy as np
from PIL import Image, ImageDraw, ImageFont

# ----------------------------
# Layout controls
# ----------------------------
WIDTH, HEIGHT = 4096, 4096
GRID_COLS, GRID_ROWS = 17, 12
TOP_MARGIN   = 40   # px – adds empty space at the very top
ROW_SPACING  = 20   # px – uniform gap between rows (affects whitespace areas)

# ----------------------------
# Physics / render controls
# ----------------------------
N_MAX = 8
Z_SAMPLES = 17
GAMMA = 0.70
BLOCK_SIZE = 262144
SEED = 1337

# Typography (fixed)
FONT_SIZE = 24
FONT_PATHS = [
    "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
    "/usr/local/share/fonts/DejaVuSans.ttf",
    "/usr/share/fonts/truetype/dejavu/DejaVuSans-Book.ttf",
    "DejaVuSans.ttf",
]
LABEL_VERT_PAD   = 3    # top padding inside the label band
LABEL_SIDE_PAD   = 8    # horizontal padding (still centered)
LABEL_BOX_HEIGHT = 36   # fixed label band height (fits 24px + pads)
LABEL_GAP        = 6    # gap between tile bottom and label band

np.random.seed(SEED)

# ----------------------------
# Math (no SciPy)
# ----------------------------
def double_factorial(n: int) -> int:
    if n <= 0: return 1
    res = 1
    for k in range(n, 0, -2): res *= k
    return res

def assoc_legendre(l: int, m: int, x: np.ndarray) -> np.ndarray:
    m = abs(m)
    if l < m: return np.zeros_like(x, np.float32)
    x = x.astype(np.float32)
    Pmm = ((-1)**m) * double_factorial(2*m - 1) * (1.0 - x*x)**(0.5*m)
    if l == m: return Pmm
    Pm1m = x * (2*m + 1) * Pmm
    if l == m+1: return Pm1m
    p2, p1 = Pmm, Pm1m
    for L in range(m+2, l+1):
        p = ((2*L-1)*x*p1 - (L+m-1)*p2) / (L-m)
        p2, p1 = p1, p
    return p1

def real_sph_harm_sq(l: int, m: int, cos_theta: np.ndarray, phi: np.ndarray) -> np.ndarray:
    mabs = abs(m)
    num = math.factorial(l - mabs); den = math.factorial(l + mabs)
    Nlm = math.sqrt((2*l + 1)/(4*math.pi) * (num/den))
    Plm = assoc_legendre(l, mabs, cos_theta)
    if m == 0:
        Y = Nlm * Plm
    else:
        fac = math.sqrt(2.0) * Nlm * Plm
        Y = fac * (np.cos(mabs*phi) if m>0 else np.sin(mabs*phi))
    return (Y*Y).astype(np.float32)

def radial_envelope(n: int, l: int, r: np.ndarray) -> np.ndarray:
    rr = np.clip(r, 0.0, 1.0).astype(np.float32)
    nr = max(0, n - l - 1)
    cent = np.power(rr + 1e-6, 2*l)
    k = 3.0 / max(1, n)
    expo = np.exp(-2.0 * k * rr)
    nodes = np.cos(np.pi * nr * rr)**2 if nr>0 else 1.0
    return (cent * expo * nodes).astype(np.float32)

def tile_orbital_intensity(n: int, l: int, m: int, side: int, z_samples: int) -> np.ndarray:
    xs = np.linspace(-1.0, 1.0, side, dtype=np.float32)
    ys = np.linspace(-1.0, 1.0, side, dtype=np.float32)
    X, Y = np.meshgrid(xs, ys)
    intensity = np.zeros((side, side), dtype=np.float32)
    zs = np.linspace(-1.0, 1.0, z_samples, dtype=np.float32)
    XY2 = X*X + Y*Y
    phi = (np.arctan2(Y, X) + 2*np.pi) % (2*np.pi)
    for z in zs:
        r2 = XY2 + z*z
        inside = r2 <= 1.0
        r = np.sqrt(np.maximum(r2, 1e-9))
        cos_theta = np.zeros_like(r, np.float32); cos_theta[inside] = z / r[inside]
        A = np.zeros_like(r, np.float32); A[inside] = real_sph_harm_sq(l, m, cos_theta[inside], phi[inside])
        R = np.zeros_like(r, np.float32); R[inside] = radial_envelope(n, l, r[inside])
        intensity += A * R
    if intensity.max() > 0: intensity /= intensity.max()
    return intensity.astype(np.float32)

# ----------------------------
# Font + AA helpers
# ----------------------------
def load_dejavu(size: int) -> ImageFont.FreeTypeFont:
    last_err = None
    for p in FONT_PATHS:
        try:
            f = ImageFont.truetype(p, size)
            if hasattr(f, "getmetrics"):
                return f
        except Exception as e:
            last_err = e
            continue
    raise RuntimeError(
        "DejaVu Sans not found. Install DejaVuSans.ttf and update FONT_PATHS. "
        f"Last error: {last_err}"
    )

def render_text_alpha(text: str, max_w: int, max_h: int, side_pad: int, top_pad: int) -> np.ndarray:
    """Fixed 24px rendering; top-aligned inside the label band. Returns uint8 alpha array."""
    font = load_dejavu(FONT_SIZE)
    # measure
    scratch = Image.new("L", (max_w, max_h), 0)
    drw = ImageDraw.Draw(scratch)
    bbox = drw.textbbox((0, 0), text, font=font, anchor="lt")
    w = bbox[2] - bbox[0]
    # horizontal center; vertical top align
    x = max(0, (max_w - w)//2)
    y = max(0, top_pad)
    img = Image.new("L", (max_w, max_h), 0)
    drw = ImageDraw.Draw(img)
    drw.text((x, y), text, fill=255, font=font)
    return np.array(img, dtype=np.uint8)

# ----------------------------
# Layout helpers
# ----------------------------
def split_evenly(total: int, parts: int):
    base = total // parts; rem = total % parts
    return [base + 1 if i < rem else base for i in range(parts)]

def enumerate_orbitals(n_max: int):
    for n in range(1, n_max+1):
        for l in range(0, n):
            for m in range(-l, l+1):
                yield (n, l, m)

# ----------------------------
# Color space + matching
# ----------------------------
def rgb_cube_arrays():
    r = np.repeat(np.arange(256, dtype=np.uint16), 256*256)
    g = np.tile(np.repeat(np.arange(256, dtype=np.uint16), 256), 256)
    b = np.tile(np.arange(256, dtype=np.uint16), 256*256)
    Y = (0.2126*r + 0.7152*g + 0.0722*b).astype(np.float32)
    rf = (r/255.0).astype(np.float32); gf = (g/255.0).astype(np.float32); bf = (b/255.0).astype(np.float32)
    maxc = np.maximum(np.maximum(rf, gf), bf); minc = np.minimum(np.minimum(rf, gf), bf)
    v = maxc; delta = maxc - minc
    s = np.zeros_like(v); nz = v > 0; s[nz] = delta[nz] / v[nz]
    h = np.zeros_like(v); mask = delta > 1e-20
    mr = mask & (maxc == rf); mg = mask & (maxc == gf); mb = mask & (maxc == bf)
    h[mr] = ((gf[mr] - bf[mr]) / delta[mr]) % 6.0
    h[mg] = ((bf[mg] - rf[mg]) / delta[mg]) + 2.0
    h[mb] = ((rf[mb] - gf[mb]) / delta[mb]) + 4.0
    h = (h / 6.0) % 1.0
    return r.astype(np.uint8), g.astype(np.uint8), b.astype(np.uint8), h, s, v, Y

def circ_dist(a: np.ndarray, b: float) -> np.ndarray:
    d = np.abs(a - b); return np.minimum(d, 1.0 - d)

def pref_metric_for_group(h: np.ndarray, s: np.ndarray, L: int) -> np.ndarray:
    if L == 0: return (s + 0.02 * circ_dist(h, 0.5)).astype(np.float32)
    centers = {1:[0.00,0.08,0.17], 2:[0.33,0.45], 3:[0.66,0.83]}.get(L, [0.25,0.58,0.92])
    d = circ_dist(h, centers[0])
    for c in centers[1:]: d = np.minimum(d, circ_dist(h, c))
    return (d - 0.05*s).astype(np.float32)

# ----------------------------
# Build intensities + masks + label alpha (with TOP_MARGIN & ROW_SPACING)
# ----------------------------
def build_canvas_intensity_masks_labels():
    # Column widths stay evenly split
    col_widths = split_evenly(WIDTH, GRID_COLS)
    x_off = np.cumsum([0] + col_widths[:-1])

    # Row heights with explicit top margin and fixed spacing
    BOTTOM_MARGIN = ROW_SPACING  # guarantee at least this much
    usable_height = HEIGHT - TOP_MARGIN - BOTTOM_MARGIN - ROW_SPACING * (GRID_ROWS - 1)
    row_heights = split_evenly(usable_height, GRID_ROWS)

    # y offsets: start at TOP_MARGIN, then add row height + spacing per row
    y_off = [TOP_MARGIN]
    for rh in row_heights[:-1]:
      y_off.append(y_off[-1] + rh + ROW_SPACING)
    y_off = np.array(y_off)


    # Square tile side must fit width and (row height - label band - gap)
    side_by_row = [max(1, rh - LABEL_BOX_HEIGHT - LABEL_GAP) for rh in row_heights]
    side = min(min(side_by_row), min(col_widths))

    I = np.zeros((HEIGHT, WIDTH), np.float32)
    Lgroup = np.full((HEIGHT, WIDTH), 255, np.uint8)      # ℓ for tiles
    tile_mask = np.zeros((HEIGHT, WIDTH), bool)
    label_alpha = np.zeros((HEIGHT, WIDTH), np.uint8)     # AA for labels

    orbitals = list(enumerate_orbitals(N_MAX))
    assert len(orbitals) == GRID_COLS * GRID_ROWS

    idx = 0
    for r in range(GRID_ROWS):
        for c in range(GRID_COLS):
            n, l, m = orbitals[idx]
            rh = row_heights[r]; cw = col_widths[c]
            y0, y1 = y_off[r], y_off[r] + rh
            x0, x1 = x_off[c], x_off[c] + cw

            # Tile packed at the TOP of the row area
            ys = y0
            ye = ys + side
            xs = x0 + (cw - side)//2
            xe = xs + side

            # Orbital intensity
            tile = tile_orbital_intensity(n, l, m, side, Z_SAMPLES)
            I[ys:ye, xs:xe] = tile
            Lgroup[ys:ye, xs:xe] = l
            tile_mask[ys:ye, xs:xe] = True

            # Label band directly under the tile
            lbl_y0 = ye + LABEL_GAP
            lbl_y1 = lbl_y0 + LABEL_BOX_HEIGHT
            text = f"n={n} ℓ={l} m={m if m>=0 else '−'+str(abs(m))}"
            alpha = render_text_alpha(
                text=text,
                max_w=cw,
                max_h=LABEL_BOX_HEIGHT,
                side_pad=LABEL_SIDE_PAD,
                top_pad=LABEL_VERT_PAD
            )
            la = label_alpha[lbl_y0:lbl_y1, x0:x1]
            label_alpha[lbl_y0:lbl_y1, x0:x1] = np.maximum(la, alpha)

            idx += 1

    # Normalize/gamma over tile pixels only
    tile_vals = I[tile_mask]; vmax = tile_vals.max() if tile_vals.size else 0.0
    if vmax > 0: I[tile_mask] = (tile_vals / vmax) ** GAMMA
    return I, Lgroup, tile_mask, label_alpha, side

# ----------------------------
# Color assignment (labels → orbitals → whitespace)
# ----------------------------
def rgb_match_and_render(I: np.ndarray, Lgroup: np.ndarray, tile_mask: np.ndarray, label_alpha: np.ndarray):
    H, W = I.shape; N = H*W
    I_flat = I.reshape(-1); L_flat = Lgroup.reshape(-1)
    tmask = tile_mask.reshape(-1); la = label_alpha.reshape(-1)

    lbl_idx = np.nonzero(la > 0)[0]
    orb_idx = np.nonzero(tmask)[0]
    wht_idx = np.nonzero(~(tmask | (la > 0)))[0]
    N_lbl, N_orb, N_wht = len(lbl_idx), len(orb_idx), len(wht_idx)
    print(f"Orbital pixels: {N_orb:,} | Label pixels: {N_lbl:,} | Whitespace: {N_wht:,}")

    rC, gC, bC, hC, sC, vC, YC = rgb_cube_arrays()
    assert rC.size == N

    col_order = np.argsort(YC, kind="stable")

    # Labels: darkest → highest alpha (AA)
    col_lbl = col_order[:N_lbl]
    rest = col_order[N_lbl:]
    sort_lbl = np.argsort(-la[lbl_idx], kind="stable")
    lbl_sorted = lbl_idx[sort_lbl]
    outR = np.empty(N, np.uint8); outG = np.empty(N, np.uint8); outB = np.empty(N, np.uint8)
    outR[lbl_sorted] = rC[col_lbl]; outG[lbl_sorted] = gC[col_lbl]; outB[lbl_sorted] = bC[col_lbl]

    # Orbitals: global intensity → luminance with ℓ-hue nudges
    col_orb = rest[:N_orb]; col_wht = rest[N_orb:]
    orb_sorted = orb_idx[np.argsort(I_flat[orb_idx], kind="stable")]

    blocks = (N_orb + BLOCK_SIZE - 1) // BLOCK_SIZE
    for bi in range(blocks):
        s = bi*BLOCK_SIZE; e = min((bi+1)*BLOCK_SIZE, N_orb); Lb = e - s
        pix_block = orb_sorted[s:e]; cols_block = col_orb[s:e]
        groups = L_flat[pix_block]; h_block = hC[cols_block]; s_block = sC[cols_block]
        used = np.zeros(Lb, bool); chosen = {}
        uniq, counts = np.unique(groups, return_counts=True)
        for L in uniq[np.argsort(-counts)]:
            need = counts[uniq==L][0]; avail = np.where(~used)[0]
            P = pref_metric_for_group(h_block[avail], s_block[avail], int(L))
            chosen_rel = avail[np.argpartition(P, min(need-1, len(avail)-1))[:need]]
            used[chosen_rel] = True; chosen[int(L)] = chosen_rel
        assert used.all()
        for L in uniq:
            rel = chosen[int(L)]; cols_g = cols_block[rel]; pix_g = pix_block[groups==L]
            if pix_g.size>1: pix_g = pix_g[np.argsort(I_flat[pix_g], kind="stable")]
            if cols_g.size>1: cols_g = cols_g[np.argsort(YC[cols_g], kind="stable")]
            outR[pix_g] = rC[cols_g]; outG[pix_g] = gC[cols_g]; outB[pix_g] = bC[cols_g]

        if (bi+1)%8==0 or bi==blocks-1:
            print(f"  Blocks {bi+1}/{blocks} ({100*(bi+1)/blocks:.1f}%)")

    # Whitespace: leftover colors, shuffled (noise)
    cols_wht_shuf = col_wht[np.random.permutation(len(col_wht))]
    outR[wht_idx] = rC[cols_wht_shuf]; outG[wht_idx] = gC[cols_wht_shuf]; outB[wht_idx] = bC[cols_wht_shuf]

    img = np.stack([outR, outG, outB], axis=1).reshape(HEIGHT, WIDTH, 3)
    return img

# ----------------------------
# Main
# ----------------------------
def main():
    print("Building intensities, masks, and label AA with margins/spacings...")
    I, Lgroup, tile_mask, label_alpha, side = build_canvas_intensity_masks_labels()
    print(f"Tile side = {side}px | Label alpha pixels = {int((label_alpha>0).sum()):,}")

    print("Assigning colors (labels → orbitals → whitespace)...")
    img = rgb_match_and_render(I, Lgroup, tile_mask, label_alpha)

    expected_sum = 65536 * (255 * 256 // 2)  # 2,137,014,272
    chsum = img.reshape(-1, 3).sum(axis=0, dtype=np.uint64)
    print(f"Channel sums R,G,B = {tuple(int(x) for x in chsum)}; expected {expected_sum}")

    ts = time.strftime("%Y%m%d_%H%M%S")
    outfile = f"orbitals_n8_204_allRGB_labels24_margins_{ts}.png"
    print(f"Saving {outfile} ...")
    Image.fromarray(img, "RGB").save(outfile, compress_level=0)
    print("Done.")

if __name__ == "__main__":
    main()

M87 Black Hole

2025-08-09T19:52:08+02:00

I asked Chatgpt 5 to write a Python script that replicates the First Image of a Black Hole, but using all 24-bit rgb colors. The result is not at all what I expected, but I like it a lot and so I decided to publish it.

It even gave a little explanation as to why this image is accurate. I like how it mentions the number 42. Who knows, maybe it stumbled upon something meaningful.

#!/usr/bin/env python3
"""
M87* all-RGB image (4096×4096), scientifically-informed crescent.

What this does
--------------
1) Builds a physically-motivated intensity map I(x,y):
   - Thin Gaussian ring ("photon ring" scale) with a strong SOUTHERN brightness
     asymmetry (relativistic beaming) and a deep central brightness depression.
   - Parameters guided by EHT measurements (ring diameter ~42 μas, thin ring).
     Refs: EHT 2019 reports; PRIMO 2023 sharper ring; 2024 multi-epoch ring
     with southerly brightness. See citations in the chat message.

2) Uses ALL 24-bit RGB colors exactly once:
   - Total pixels = 4096×4096 = 16,777,216.
   - Selects exactly as many “ring pixels” as needed by a geometric ring mask.
   - Assigns the most chromatic colors to the ring (ordered by hue along angle).
   - Assigns the remaining colors to all other pixels, dark-to-bright to match I.

Design choices
--------------
* Ring geometry:
  - r0_frac ~ 0.29 (radius as fraction of image size), thin width.
  - Southern bright sector via a Doppler-like factor A(θ) = (1+k cos(θ-θ0))^p,
    with θ0 = south (−π/2) in image coordinates (y down).
* Exact-use guarantee:
  - Colors are split into two non-overlapping pools (ring vs non-ring).
  - Each pool is strictly permutation-assigned to its pixel set.
  - A final uniqueness assertion checks we used every RGB exactly once.

Runtime & memory
----------------
This is heavy by design (tens to hundreds of MB of RAM and big sorts).
For lower RAM, you can chunk some steps, but this single-pass version
is easiest to verify for exact color accounting.

Outputs
-------
- PNG named: M87_allrgb_.png
- Console prints: counts & verification.
"""

import numpy as np
from PIL import Image
import time
import math

# ------------------------- parameters you might tweak -------------------------

SIZE = 4096  # image width=height; must be 4096 to match 16,777,216 colors
SAVE_TIMESTAMP = time.strftime("%Y%m%d_%H%M%S")
OUTFILE = f"M87_allrgb_{SAVE_TIMESTAMP}.png"

# Ring geometry (fraction of SIZE)
r0_frac    = 0.29   # ring radius
ring_band  = 96.0   # half-thickness of the ring band in pixels (visual ring thickness)
sigma_px   = 28.0   # Gaussian radial sigma controlling the ring profile thickness

# Beaming (brightness asymmetry, brightest toward south)
theta0     = -math.pi/2       # south (in image coords: +y down)
k_beam     = 0.65             # 0..1 strength of cosine beaming
p_beam     = 2.2              # raises contrast of beaming

# Background/contrast shaping
bg_envelope_strength = 0.25   # faint background glow
shadow_sharpness     = 8.0    # higher -> steeper dark center

# -----------------------------------------------------------------------------

# --- 1) Build coordinate grid and physically-motivated intensity I(x,y) ---

H = W = SIZE
yy, xx = np.indices((H, W), dtype=np.float32)
cx = (W - 1) * 0.5
cy = (H - 1) * 0.5

# Pixel-space radius & angle (θ measured from +x to -y for "image up")
dx = xx - cx
dy = yy - cy
r = np.hypot(dx, dy)
theta = np.arctan2(-dy, dx)  # so that -pi/2 points downward (south) in the image

r0 = r0_frac * SIZE

# Radial "thin ring": Gaussian around r0
I_rad = np.exp(-0.5 * ((r - r0) / sigma_px) ** 2)

# Doppler-like beaming: brightest near theta0 (south)
beam = 1.0 + k_beam * np.cos(theta - theta0)
beam = np.clip(beam, 0.0, None) ** p_beam

# Deep central depression (shadow) via a sharp logistic around r ~ r0 - a few sigmas
# This suppresses the interior brightness by >10:1 relative to ring.
inner_edge = r0 - 2.2 * sigma_px
shadow = 1.0 / (1.0 + np.exp(-(r - inner_edge) / (sigma_px / shadow_sharpness)))

# Faint background envelope to avoid a totally flat outer region
bg = bg_envelope_strength * np.exp(- (r / (0.42 * SIZE)) ** 2)

# Combine and normalize
I = (I_rad * beam * shadow) + bg
I -= I.min()
I /= (I.max() + 1e-12)

# --- ring mask: geometric band around r0 (uses band, not intensity threshold) ---
ring_mask = (np.abs(r - r0) <= ring_band) & (I > 0.02)
ring_idx = np.flatnonzero(ring_mask)
non_idx  = np.flatnonzero(~ring_mask)

N_total = SIZE * SIZE
N_ring  = ring_idx.size
N_non   = non_idx.size
assert N_ring + N_non == N_total

# Order ring pixels around azimuth, starting at theta0 (south) and going CCW
phi = (theta - theta0) % (2.0 * np.pi)
phi_ring = phi.flat[ring_idx]
order_ring_pixels = ring_idx[np.argsort(phi_ring, kind='mergesort')]

# Order non-ring pixels by intensity (dark -> bright)
I_non = I.flat[non_idx]
order_non_pixels = non_idx[np.argsort(I_non, kind='mergesort')]

# --- 2) Generate ALL 24-bit colors (no repeats), then split into two pools ---

# Colors as uint8 channels via bit tricks; stable and memory-light(ish)
N = 1 << 24  # 16,777,216
ids = np.arange(N, dtype=np.uint32)
R = ((ids >> 16) & 0xFF).astype(np.uint8)
G = ((ids >>  8) & 0xFF).astype(np.uint8)
B = ( ids        & 0xFF).astype(np.uint8)

# "Chromaticity" metric to pick the most colorful colors for the ring:
# Using max(R,G,B) - min(R,G,B) (channel spread). This equals (S*V)*255 in sRGB scale.
maxc = np.maximum(np.maximum(R, G), B).astype(np.int16)
minc = np.minimum(np.minimum(R, G), B).astype(np.int16)
spread = (maxc - minc).astype(np.int16)   # 0..255

# Select EXACTLY N_ring "most chromatic" colors for the ring
# (Tie-breaking handled by argpartition+argsort for determinism.)
if N_ring > 0:
    part_idx = np.argpartition(spread, -N_ring)[-N_ring:]
    # Now order those ring colors by hue for a smooth hue cycle around the ring
    # Compute hue ONLY for the selected subset to save memory/time.
    r_f = R[part_idx].astype(np.float32) / 255.0
    g_f = G[part_idx].astype(np.float32) / 255.0
    b_f = B[part_idx].astype(np.float32) / 255.0

    mx = np.maximum(np.maximum(r_f, g_f), b_f)
    mn = np.minimum(np.minimum(r_f, g_f), b_f)
    df = mx - mn
    # Hue in [0,1)
    h = np.zeros_like(mx, dtype=np.float32)
    mask = df > 0
    # Avoid division by zero; compute hue sectors
    r_is_max = (mx == r_f) & mask
    g_is_max = (mx == g_f) & mask
    b_is_max = (mx == b_f) & mask

    # Note: vectorized hue (0..6) then /6
    h[r_is_max] = ( (g_f[r_is_max] - b_f[r_is_max]) / df[r_is_max] ) % 6.0
    h[g_is_max] = ( (b_f[g_is_max] - r_f[g_is_max]) / df[g_is_max] ) + 2.0
    h[b_is_max] = ( (r_f[b_is_max] - g_f[b_is_max]) / df[b_is_max] ) + 4.0
    h *= (1.0 / 6.0)

    order_ring_colors_local = np.argsort(h, kind='mergesort')
    ring_color_ids = part_idx[order_ring_colors_local]
else:
    ring_color_ids = np.array([], dtype=np.uint32)

# The remaining colors go to non-ring pixels, ordered by luminance (dark -> bright).
# Integer luma approximation: Y ≈ 0.2126R + 0.7152G + 0.0722B, scaled by 10,000 for integers.
if N_non > 0:
    used_mask = np.zeros(N, dtype=bool)
    used_mask[ring_color_ids] = True
    non_color_ids = np.flatnonzero(~used_mask)

    # Luma as integer to avoid huge float arrays
    Yint = (2126 * R[non_color_ids].astype(np.uint32) +
            7152 * G[non_color_ids].astype(np.uint32) +
             722 * B[non_color_ids].astype(np.uint32))  # 0..2,550,000

    order_non_local = np.argsort(Yint, kind='mergesort')
    nonring_color_ids = non_color_ids[order_non_local]
else:
    nonring_color_ids = np.array([], dtype=np.uint32)

# --- 3) Assemble the final image buffer (bijective mapping) ---

img = np.empty((N_total, 3), dtype=np.uint8)

# Assign ring: pixels ordered by azimuth, colors ordered by hue
if N_ring > 0:
    Rc = (ring_color_ids >> 16) & 0xFF
    Gc = (ring_color_ids >>  8) & 0xFF
    Bc = (ring_color_ids      ) & 0xFF
    img[order_ring_pixels, 0] = Rc.astype(np.uint8)
    img[order_ring_pixels, 1] = Gc.astype(np.uint8)
    img[order_ring_pixels, 2] = Bc.astype(np.uint8)

# Assign non-ring: pixels ordered by intensity (dark->bright), colors ordered by luma
if N_non > 0:
    Rn = (nonring_color_ids >> 16) & 0xFF
    Gn = (nonring_color_ids >>  8) & 0xFF
    Bn = (nonring_color_ids      ) & 0xFF
    img[order_non_pixels, 0] = Rn.astype(np.uint8)
    img[order_non_pixels, 1] = Gn.astype(np.uint8)
    img[order_non_pixels, 2] = Bn.astype(np.uint8)

# Reshape and save
img = img.reshape((H, W, 3))
Image.fromarray(img, mode="RGB").save(OUTFILE, compress_level=0)

# --- 4) Verify exact usage of all 16,777,216 colors ---
packed = (img[...,0].astype(np.uint32) << 16) | (img[...,1].astype(np.uint32) << 8) | img[...,2].astype(np.uint32)
uniq = np.unique(packed)
assert uniq.size == (1 << 24), f"Color count mismatch: {uniq.size}"
print("Success!")
print(f"Ring pixels: {N_ring:,} | Non-ring pixels: {N_non:,}")
print(f"Saved: {OUTFILE}")

Why this maps to the real M87*

The ring with a southern bright sector and deep central depression mirrors what EHT reported (ring diameter ≈ 42 μas, strong azimuthal asymmetry consistent with relativistic beaming). The 2023 PRIMO reconstruction tightened the ring width; we emulate a thin band. The 2024 multi-epoch analysis again found a southerly brightness distribution and a ring size consistent with 42 μas.

Cosmic Microwave Background v2

2025-08-09T12:50:08+02:00

The successor of Cosmic Microwave Background v1. Made with Chatgpt 5, which yielded a much better result much more quickly.

#!/usr/bin/env python3
"""
Generate a 4096×4096 image of the Cosmic Microwave Background (CMB) that uses
EVERY 24-bit RGB color exactly once, using real Planck data (Planck 2018 PR3).

Colab-friendly version:
- No argparse (hardcoded settings below)
- Uses os.getcwd() instead of __file__
- Automatically downloads from working IRSA URLs with fallback options

Requires:
    pip install numpy healpy astropy pillow
"""

import os
import sys
import math
import time
import urllib.request
import numpy as np
from urllib.error import HTTPError
from PIL import Image
import healpy as hp
from astropy.io import fits

# ---------- Settings ----------
W = H = 4096
CHUNK_ROWS = 256

# Output file
OUT_FILE = "cmb_allrgb_4096.png"

# FITS file path (empty = auto-download)
FITS_PATH = ""  # leave blank for auto-download

# URLs (working IRSA paths, component-maps/cmb/)
BASE_URL = "https://irsa.ipac.caltech.edu/data/Planck/release_3/all-sky-maps/maps/component-maps/cmb/"
CANDIDATES = [
    "COM_CMB_IQU-smica-nosz_2048_R3.00_full.fits",  # preferred (no tSZ)
    "COM_CMB_IQU-smica_2048_R3.00_full.fits",       # with tSZ
    "COM_CMB_IQU-commander_2048_R3.00_full.fits",   # alternative
]

# ---------- Download & FITS Reading ----------
def download_with_fallback(local_path: str):
    for fname in CANDIDATES:
        url = BASE_URL + fname
        try:
            print(f"Attempting download: {url}")
            urllib.request.urlretrieve(url, local_path)
            print(f"Downloaded successfully: {local_path}")
            return local_path
        except HTTPError as e:
            print(f"Failed: {e}")
    raise RuntimeError("All download attempts failed.")

def detect_ordering_nest_from_fits(path: str, extname="I_STOKES") -> bool:
    with fits.open(path, memmap=True) as hdul:
        hdu = None
        for h in hdul:
            if (h.header.get("EXTNAME", "").strip().upper() == extname) or (h.name.strip().upper() == extname):
                hdu = h
                break
        if hdu is None:
            hdu = hdul[1] if len(hdul) > 1 else hdul[0]
        ordering = (hdu.header.get("ORDERING", "") or hdu.header.get("ORDER", "")).strip().upper()
        if ordering in ("NESTED", "NEST"):
            return True
        elif ordering in ("RING",):
            return False
        return False

def read_smica_temperature_map(path: str, force_nest: bool | None = None):
    if force_nest is None:
        is_nest = detect_ordering_nest_from_fits(path, extname="I_STOKES")
    else:
        is_nest = bool(force_nest)
    m = hp.read_map(path, field=0, nest=is_nest, dtype=np.float64, verbose=False)
    unseen = hp.UNSEEN
    if np.any(~np.isfinite(m)) or np.any(m == unseen):
        good = np.isfinite(m) & (m != unseen)
        med = np.median(m[good])
        m = m.copy()
        m[~good] = med
    return m, is_nest

# ---------- Sampling & Color Ordering ----------
def sample_cmb_to_square(map_1d: np.ndarray, is_nest: bool, w: int = W, h: int = H) -> np.ndarray:
    out = np.empty((h, w), dtype=np.float32)
    xs = (np.arange(w, dtype=np.float64) + 0.5) / w
    phi = xs * (2.0 * math.pi)
    for y0 in range(0, h, CHUNK_ROWS):
        y1 = min(y0 + CHUNK_ROWS, h)
        ys = (np.arange(y0, y1, dtype=np.float64) + 0.5) / h
        theta = ys[:, None] * math.pi
        phi_grid = np.broadcast_to(phi[None, :], (y1 - y0, w))
        theta_grid = np.broadcast_to(theta, (y1 - y0, w))
        vals = hp.get_interp_val(map_1d, theta_grid.ravel(), phi_grid.ravel(), nest=is_nest)
        out[y0:y1, :] = vals.reshape((y1 - y0, w)).astype(np.float32)
        print(f"Sampled rows {y0:4d}–{y1-1:4d} / {h}")
    return out

def build_color_order_indices(N: int) -> np.ndarray:
    c = np.arange(N, dtype=np.uint32)
    r = (c >> 16) & 0xFF
    g = (c >> 8)  & 0xFF
    b = c & 0xFF
    r_i = r.astype(np.int16)
    g_i = g.astype(np.int16)
    b_i = b.astype(np.int16)
    score_primary = (r_i - b_i).astype(np.int32)
    score_secondary = (r_i + g_i + b_i).astype(np.int32)
    score_tertiary = np.abs(g_i - r_i).astype(np.int32)
    idx = np.lexsort((score_secondary, score_tertiary, score_primary))
    return idx.astype(np.uint32)

def assign_allrgb_by_rank(vals2d: np.ndarray, color_order_idx: np.ndarray) -> np.ndarray:
    h, w = vals2d.shape
    N = h * w
    assert N == 256 * 256 * 256, "Image must have exactly 16,777,216 pixels."
    flat = vals2d.ravel()
    print("Sorting CMB values…")
    pix_order = np.argsort(flat, kind="mergesort").astype(np.uint32)
    c_sorted = color_order_idx
    out = np.empty((N, 3), dtype=np.uint8)
    r = (c_sorted >> 16).astype(np.uint8)
    g = ((c_sorted >> 8) & 0xFF).astype(np.uint8)
    b = (c_sorted & 0xFF).astype(np.uint8)
    out[pix_order, 0] = r
    out[pix_order, 1] = g
    out[pix_order, 2] = b
    return out.reshape((h, w, 3))

# ---------- Main ----------
def main():
    t0 = time.time()

    fits_path = FITS_PATH.strip()
    if not fits_path:
        fname = CANDIDATES[0]  # smica-nosz preferred
        fits_path = os.path.join(os.getcwd(), fname)
        if not os.path.exists(fits_path):
            download_with_fallback(fits_path)

    print("Reading Planck map…")
    cmb_map, is_nest = read_smica_temperature_map(fits_path)
    print(f"  nside={hp.get_nside(cmb_map)}, ordering={'NESTED' if is_nest else 'RING'}")

    print(f"Sampling to {W}×{H} grid (equirectangular)…")
    vals = sample_cmb_to_square(cmb_map, is_nest, W, H)
    vals -= np.mean(vals, dtype=np.float64)

    print("Preparing color ordering (all 16,777,216 colors)…")
    color_idx = build_color_order_indices(W * H)

    print("Assigning colors by CMB rank…")
    img = assign_allrgb_by_rank(vals, color_idx)

    Image.fromarray(img, mode="RGB").save(OUT_FILE, optimize=True)
    t1 = time.time()
    print(f"Done → {OUT_FILE}   ({(t1 - t0):.1f}s)")
    print("Pixels used:", img.shape[0] * img.shape[1])

if __name__ == "__main__":
    main()

🏳️‍🌈 v2

2025-08-09T12:00:03+02:00

Successor of 🏳️‍🌈 v1 (obviously). Made with Chatgpt 5, which came to a much better result, much more quickly. The Python source was executed in Google Colab.

#!/usr/bin/env python3
import numpy as np
from PIL import Image
from datetime import datetime

# ============================================================
# Progress Pride — all 24-bit RGB colors exactly once
#  - Stripes allocated FIRST
#  - Size: 8192x2048 (2:1)
#  - Timestamped filename
# ============================================================

H, W = 2048, 8192
TOTAL = H * W  # 16,777,216

# ------------------------------
# Geometry: stripes + chevron
# ------------------------------
y = np.arange(H, dtype=np.int32)
x = np.arange(W, dtype=np.int32)
Y, X = np.meshgrid(y, x, indexing='ij')

# Six equal-height horizontal stripes (R,O,Y,G,B,V)
stripe_idx = (Y * 6) // H  # 0..5

# Chevron bands as nested 45° "V" shapes from the hoist
y_mid = (H - 1) / 2.0
t = X.astype(np.float32) + np.abs(Y.astype(np.float32) - y_mid)
# Set chevron total width to H so it occupies ~25% of the 2:1 flag width
W_total = float(H)
bands = 5
band_w = W_total / bands

# Order at the hoist: black, brown, light blue, pink, white
chev_levels = [(i * band_w, (i + 1) * band_w) for i in range(bands)]
chev_masks = []
for i in range(bands):
    lo, hi = chev_levels[i]
    m = (t < hi) & (t >= lo)
    chev_masks.append(m)

# Mask for any chevron pixel (overlays stripes)
chev_any = np.zeros((H, W), dtype=bool)
for m in chev_masks:
    chev_any |= m

# Stripe masks excluding chevron overlay
stripe_masks = []
for s in range(6):
    stripe_masks.append((stripe_idx == s) & (~chev_any))

# ------------------------------
# Color pool: all unique RGBs
# ------------------------------
# Deterministic order: r major, then g, then b
r = np.repeat(np.arange(256, dtype=np.uint8), 256 * 256)
g = np.tile(np.repeat(np.arange(256, dtype=np.uint8), 256), 256)
b = np.tile(np.arange(256, dtype=np.uint8), 256 * 256)
colors = np.stack([r, g, b], axis=1)  # (16777216, 3), uint8

# Normalize to [0,1] float32 for HSV computations
rf = colors[:, 0].astype(np.float32) / 255.0
gf = colors[:, 1].astype(np.float32) / 255.0
bf = colors[:, 2].astype(np.float32) / 255.0

# Vectorized RGB->HSV (H in [0,1), S,V in [0,1])
maxc = np.maximum(np.maximum(rf, gf), bf)
minc = np.minimum(np.minimum(rf, gf), bf)
v = maxc
c = maxc - minc
s = np.where(maxc > 0.0, c / np.maximum(maxc, 1e-12), 0.0)

h = np.zeros_like(v, dtype=np.float32)
mask = c > 1e-12
rc = np.zeros_like(v); gc = np.zeros_like(v); bc = np.zeros_like(v)
rc[mask] = (maxc[mask] - rf[mask]) / c[mask]
gc[mask] = (maxc[mask] - gf[mask]) / c[mask]
bc[mask] = (maxc[mask] - bf[mask]) / c[mask]
mr = (mask & (rf >= gf) & (rf >= bf))
mg = (mask & (gf > rf) & (gf >= bf))
mb = (mask & (bf > rf) & (bf > gf))
h[mr] = (bc[mr] - gc[mr]) / 6.0
h[mg] = (2.0 + (rc[mg] - bc[mg])) / 6.0
h[mb] = (4.0 + (gc[mb] - rc[mb])) / 6.0
h = h % 1.0

# Luma (Rec.709), useful for dark/light targeting
luma = 0.2126 * rf + 0.7152 * gf + 0.0722 * bf

# ------------------------------
# Region pixel counts
# ------------------------------
def count(mask: np.ndarray) -> int:
    return int(np.count_nonzero(mask))

region_defs = {
    # Stripes first
    "stripe_red":    stripe_masks[0],
    "stripe_orange": stripe_masks[1],
    "stripe_yellow": stripe_masks[2],
    "stripe_green":  stripe_masks[3],
    "stripe_blue":   stripe_masks[4],
    "stripe_violet": stripe_masks[5],
    # Chevron after
    "chev_black": chev_masks[0],
    "chev_brown": chev_masks[1],
    "chev_lblue": chev_masks[2],
    "chev_pink":  chev_masks[3],
    "chev_white": chev_masks[4],
}
region_names = list(region_defs.keys())
region_sizes = {name: count(region_defs[name]) for name in region_names}
assert sum(region_sizes.values()) == TOTAL, "Masking error: pixel total mismatch."

# ------------------------------
# Selection helpers
# ------------------------------
rng = np.random.default_rng(42)  # deterministic shuffles
unused = np.ones(TOTAL, dtype=bool)  # color availability tracker

def circular_hue_distance(hval, hcenter):
    d = np.abs(hval - hcenter)
    return np.minimum(d, 1.0 - d)

def take_best(k: int, score: np.ndarray) -> np.ndarray:
    avail_idx = np.nonzero(unused)[0]
    if avail_idx.size < k:
        raise RuntimeError("Not enough remaining colors to satisfy allocation.")
    s_local = score[avail_idx]
    pick_local = np.argpartition(s_local, kth=k-1)[:k]
    pick_local = pick_local[np.argsort(s_local[pick_local], kind='mergesort')]
    chosen = avail_idx[pick_local]
    unused[chosen] = False
    return chosen

# ------------------------------
# Scoring per region
# ------------------------------
scores = {}

# Stripe targeting — vibrant, stripe-specific hue centers, good V:
scores["stripe_red"]    = (circular_hue_distance(h,   0/360) * 2.0 + (1.0 - s) + 0.4 * (0.75 - v) ** 2)
scores["stripe_orange"] = (circular_hue_distance(h,  30/360) * 2.0 + (1.0 - s) + 0.4 * (0.75 - v) ** 2)
scores["stripe_yellow"] = (circular_hue_distance(h,  60/360) * 2.0 + (1.0 - s) + 0.4 * (0.90 - v) ** 2)
scores["stripe_green"]  = (circular_hue_distance(h, 120/360) * 2.0 + (1.0 - s) + 0.4 * (0.75 - v) ** 2)
scores["stripe_blue"]   = (circular_hue_distance(h, 240/360) * 2.0 + (1.0 - s) + 0.4 * (0.70 - v) ** 2)
scores["stripe_violet"] = (circular_hue_distance(h, 285/360) * 2.0 + (1.0 - s) + 0.4 * (0.70 - v) ** 2)

# Chevron targeting (from remaining colors after stripes):
scores["chev_black"] = v  # darker is better
scores["chev_brown"] = (circular_hue_distance(h, 30/360) * 2.0
                        + 0.7 * np.abs(s - 0.5)
                        + 3.0 * (v - 0.35) ** 2)
scores["chev_lblue"] = (circular_hue_distance(h, 200/360) * 2.0
                        + 1.2 * (1.0 - s)
                        + 0.6 * (1.0 - v))
scores["chev_pink"]  = (circular_hue_distance(h, 330/360) * 2.0
                        + 1.2 * (1.0 - s)
                        + 0.6 * (1.0 - v))
scores["chev_white"] = (1.0 - v) + s  # bright and desaturated

# ------------------------------
# Allocate colors to regions
# ------------------------------
region_color_indices = {}

# 1) Allocate to stripes FIRST
for key in ["stripe_red", "stripe_orange", "stripe_yellow",
            "stripe_green", "stripe_blue", "stripe_violet"]:
    k = region_sizes[key]
    idx = take_best(k, scores[key])
    region_color_indices[key] = idx

# 2) Allocate to chevron from remaining pool
for key in ["chev_black", "chev_brown", "chev_lblue", "chev_pink", "chev_white"]:
    k = region_sizes[key]
    idx = take_best(k, scores[key])
    region_color_indices[key] = idx

# All colors must be consumed exactly once
assert not np.any(unused), "Not all colors were used exactly once."

# ------------------------------
# Paint the image
# ------------------------------
img = np.empty((H, W, 3), dtype=np.uint8)

# Helper to paint a region with a deterministic shuffle
def paint_region(name, mask):
    pix = np.column_stack(np.nonzero(mask))  # (N, 2)
    order = np.arange(pix.shape[0])
    seed = (abs(hash(name)) % (2**32))
    rng_reg = np.random.default_rng(seed)
    rng_reg.shuffle(order)
    chosen_colors = colors[region_color_indices[name]][order]
    img[pix[:, 0], pix[:, 1]] = chosen_colors

# Stripes underlay
for k in ["stripe_red", "stripe_orange", "stripe_yellow",
          "stripe_green", "stripe_blue", "stripe_violet"]:
    paint_region(k, region_defs[k])

# Chevron overlay
for k in ["chev_black", "chev_brown", "chev_lblue", "chev_pink", "chev_white"]:
    paint_region(k, region_defs[k])

# ------------------------------
# Final verifications
# ------------------------------
flat = img.reshape(-1, 3)
packed = (flat[:, 0].astype(np.uint32) << 16) | (flat[:, 1].astype(np.uint32) << 8) | flat[:, 2].astype(np.uint32)
uniq = np.unique(packed)
assert uniq.size == TOTAL, f"Color uniqueness failed: {uniq.size} != {TOTAL}"

# Optional (heavy) full-set check:
# all24 = (r.astype(np.uint32) << 16) | (g.astype(np.uint32) << 8) | b.astype(np.uint32)
# assert np.array_equal(np.sort(all24), uniq), "Used colors are not the full 24-bit set."

# ------------------------------
# Save with timestamp
# ------------------------------
ts = datetime.now().strftime("%Y%m%d-%H%M%S")
filename = f"progress_pride_allrgb_8192x2048_{ts}.png"
Image.fromarray(img, mode="RGB").save(filename, compress_level=0)
print(f"Done: {filename}")

TriMyrthe

2025-08-08T15:15:14+02:00

Hommage to the mother of my children. Inspired by the trinity of Brahma, Vishnu, en Shiva. Created with Google ai Studio, and Chatgpt

Ten of Nine

2025-08-08T15:13:31+02:00

Hommage to the mother of my children. Inspired by Andy Warhol’s Shot Marilyns, Samuel35’s Update new montage 8 colors, and Star Trek’s Seven of Nine. Created with Google ai Studio and Google Colab.

SpandAU v2

2025-08-06T23:10:12+02:00

Basically the same thing as Spandau, but applied to a photo (of my baby momma wearing a golden necklace with my given names).

CAR (speed + windscreen wiper)

2025-07-31T19:15:32+02:00

GO GO GO !!!

Each of 16 frames has got 16,777,216 unique colors

FULL ROTATIONS v4

2025-07-31T13:32:21+02:00

FULL ROTATIONS v4

Each of 16 frames has got 16,777,216 unique colors

Sundial clock 60

2025-07-31T13:28:34+02:00

60 frames
60 rotations
60 seconds
60 minutes

Each of 60 frames has got 16,777,216 unique colors

FULL ROTATIONS v3

2025-07-31T13:28:20+02:00

FULL ROTATIONS v3

Each of 16 frames has got 16,777,216 unique colors

8-bit Tangram Arrangements

2025-07-29T20:36:48+02:00

256 different combinations of 8-bit tangrams, each piece being either dark or bright. The colors are shuffled and separated into 2 groups based on sum of RGB values.

FULL ROTATIONS v2

2025-07-29T20:29:34+02:00

FULL ROTATIONS v2

Each of 16 frames has got 16,777,216 unique colors

Double Spiral

2025-07-29T09:17:56+02:00

Colors are arranged in a 2D path that spiral to the center then back outwards. Starts at the top left.

FULL ROTATIONS v1

2025-07-28T22:18:25+02:00

FULL ROTATIONS v1

Each of 16 frames has got 16,777,216 unique colors

Bit Depth Sort

2025-07-28T12:27:38+02:00

Each pixel is passed to a mapping formula that determines, for each RGB channel, the minimum bit depth it takes to display it (or in other words, 8 minus log2 of the lowest base 2 divisor of the RGB values – f(113) = 8, f(212) = 6, f(32) = 3, f(128) = 1). The results are used to sort the pixels, combining the RGB values. In 4 different ways: - Frame 1 (Maximum): max(f(R), f(G), f(B)) - Frame 2 (Minimum): min(f(R), f(G), f(B)) - Frame 3 (Sum): f(R) + f(G) + f(B) - Frame 4 (Combinations): f(R) * 81 + f(G) * 9 + f(B)

SPACE

2025-07-28T12:25:01+02:00

SPACE

BOY

2025-07-28T12:24:43+02:00

BOY

GREEN HULK

2025-07-28T12:21:46+02:00

GREEN HULK

WORLD FAMOUS PLACES

2025-07-25T11:42:31+02:00

WORLD FAMOUS PLACES

Colors types 2/2

2025-07-24T00:18:00+02:00

Colors types 2/2

TABLE TENNIS v3

2025-07-20T21:37:37+02:00

TABLE TENNIS v3

Update new montage 8 colors

2025-07-19T11:06:07+02:00

Improvement of my custom method combining 8 colors into a photo collage

animated FULL COLORIZATION

2025-07-18T21:13:43+02:00

--> fading "NO COLOR" to MONOCHROME
--> fading MONOCHROME to GRAYSCALE
--> fading GRAYSCALE to COLORS

Each of 42 frames has got 16,777,216 unique colors

Colors types 1/2

2025-07-17T12:03:29+02:00

Colors types 1/2

TABLE TENNIS v2 (full)

2025-07-12T20:00:10+02:00

Huge improvement of v1 : "Custom art RGB ping-pong girl"

My best "full image" in my opinion
(without using any software convertor/generator, algorithms, codes, ...)

animated only one color ?

2025-07-12T08:20:51+02:00

only RED ?
only GREEN ?
only BLUE ?

Each of 3 frames has got 16,777,216 unique colors

RGB to HSL

2025-07-12T08:18:58+02:00

animated MATRIX

2025-07-10T11:55:22+02:00

The Matrix has me

Each of 16 frames has got 16,777,216 unique colors

MATHEMATICS - Collection visual formulas

2025-07-09T17:54:53+02:00

Sorted by ...

ADDITION
SUBTRACTION 1
SUBTRACTION 2
MULTIPLICATION
DIVISION
AVERAGE
MINIMUM
MAXIMUM
POWER
STANDARD DEVIATION 1
STANDARD DEVIATION 2

If you have another interesting formulas in mind : I can add frames

Each of 11 frames has got 16,777,216 unique colors
(delay 3 seconds each)

Pokédex 1–1024 v1

2025-07-09T09:21:47+02:00

Which Pokémon is this?

Made with Chatgpt, Google Gemini, Google Colab and Google Drive. (Not sponsored.)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Comprehensive script for generating an image with all 16,777,216 unique 24-bit RGB colors,
while embedding Pokémon sprites that closely resemble their originals.

Key Features:
- **All Colors Exactly Once:** Ensures every possible 24-bit RGB color is present exactly once.
- **GPU-Accelerated Shuffle:** Utilizes CuPy for fast initial color permutation if a GPU is available,
  with an automatic fallback to NumPy on CPU if not.
- **Optimized Sprite Embedding:** A Numba JIT-accelerated core loop embeds sprite pixels:
    - Prioritizes using the sprite's exact original color if available.
    - If the original color is taken, it searches for the *closest available* color in RGB space
      (using Euclidean distance) within a specified radius (MAX_RAD=3 by default).
      This greatly improves sprite visual fidelity compared to a simple "first available" search.
    - Performs an efficient 1:1 color swap, ensuring the total color count remains exact.
- **Sprite Caching:** Fetches Pokémon sprites from PokeAPI, resizes them to 128x128,
  and caches them to Google Drive to speed up subsequent runs.
- **Memory Management Logging:** Provides insights into RAM usage at different stages.
- **Robust Google Drive Integration:** Mounts Google Drive to the standard `/content/drive` path
  and correctly sets up persistent caches within 'My Drive'.

Dependencies:
    pip install numpy pillow requests tqdm psutil numba cupy-cuda12x

Usage in Google Colab:
1. Save this script as a .py file (e.g., `pokemon_color_image.py`) in your Google Drive.
   A good location might be `My Drive/Colab_Scripts/pokemon_color_image.py`.
2. In a Colab notebook cell, first mount your Google Drive:
   This step will prompt for authorization.
   Example code for mounting:
   from google.colab import drive
   drive.mount('/content/drive')
   print("Google Drive mounted successfully!")
3. In a *separate* Colab notebook cell, run your script:
   Example code for running the script:
   import os
   # Ensure NUMBA_CACHE_DIR is set *before* your script starts to compile Numba functions.
   # It points to a directory *within* your mounted Google Drive.
   os.environ['NUMBA_CACHE_DIR'] = "/content/drive/MyDrive/numba_cache"

   # Define the path to your script on Google Drive
   script_path = "/content/drive/MyDrive/Colab_Scripts/pokemon_color_image.py"

   # Run the script using the Python interpreter.
   !python "$script_path"
   The script will then create necessary directories (`numba_cache`, `pokemon_sprites`) inside your Google Drive if they don't exist.
"""
import os
import logging
import psutil
from io import BytesIO

import numpy as np
from PIL import Image
import requests
from tqdm import tqdm
from numba import njit, prange # prange allows for parallel compilation within Numba if configured

# --- Configuration Section ---
# Standard Google Drive mount point in Colab
GOOGLE_DRIVE_MOUNT_POINT = "/content/drive"

# Numba Caching Setup: Specify where Numba should store compiled functions.
# This path is *relative to your mounted Google Drive's "My Drive"*
# Example: /content/drive/MyDrive/numba_cache
NUMBA_CACHE_ROOT = os.path.join(GOOGLE_DRIVE_MOUNT_POINT, "MyDrive", "numba_cache")

# Image Generation Parameters
IMAGE_SIZE = 4096 # The final image will be IMAGE_SIZE x IMAGE_SIZE pixels
TOTAL_PIXELS = IMAGE_SIZE * IMAGE_SIZE # Total possible 24-bit colors: 2^24 = 16,777,216
SEED = 42 # Random seed for initial color shuffling (for reproducibility)

# Sprite Parameters
POKE_COUNT = 1024 # Number of Pokémon sprites to fetch (from 1 to POKE_COUNT)
TILE_SIZE = IMAGE_SIZE // 32 # Size (width/height) of each individual sprite tile in pixels (e.g., 4096/32 = 128)
# Directory within your mounted Google Drive to cache fetched Pokémon sprites.
# Example: /content/drive/MyDrive/pokemon_sprites
SPRITE_CACHE_DIR = os.path.join(GOOGLE_DRIVE_MOUNT_POINT, "MyDrive", "pokemon_sprites")

# Output File
OUTPUT_FILE = "all_colors_with_pokemon.png" # Name of the final output image file.
# This will be saved in the Colab instance's /content/ directory, which you can download.

# Color Remapping Parameters
MAX_RAD = 3 # Maximum Chebyshev search radius for finding nearest free colors.
            # A larger radius means potentially better color matches but more computation.

# --- Logging Setup ---
logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logger = logging.getLogger(__name__)

# --- GPU (CuPy) Detection ---
USE_GPU = True
try:
    import cupy as cp
    # Test if CuPy can allocate memory to ensure a CUDA device is actually available.
    _ = cp.array([1])
except (ImportError, cp.cuda.runtime.CudaError):
    USE_GPU = False
    print("CuPy not available or CUDA device not found. Falling back to CPU for shuffling.")

# --- Helper Functions ---

def log_mem(stage: str):
    """Logs current memory usage."""
    vm = psutil.virtual_memory()
    logger.info(f"[{stage}] RAM {vm.used//(1024*1024)}MB/{vm.total//(1024*1024)}MB")


def precompute_euclidean_sorted_offsets(max_radius: int) -> np.ndarray:
    """
    Precomputes all (dr,dg,db) offsets within a Chebyshev cube of 'max_radius'
    and sorts them by their squared Euclidean distance from the origin.
    This ensures that when iterating through these offsets, colors closer in RGB space
    are checked first, leading to better visual matches for the sprites.
    """
    offsets_set = set() # Use a set to store unique (dr, dg, db) tuples
    for dr in range(-max_radius, max_radius + 1):
        for dg in range(-max_radius, max_radius + 1):
            for db in range(-max_radius, max_radius + 1):
                if dr == 0 and dg == 0 and db == 0:
                    continue # The (0,0,0) offset corresponds to the original color, handled separately.
                offsets_set.add((dr, dg, db))

    # Convert to a list of tuples and sort them based on their squared Euclidean distance.
    # Sorting ensures we check closest neighbors first.
    sorted_offsets = sorted(list(offsets_set), key=lambda x: x[0]**2 + x[1]**2 + x[2]**2)
    return np.array(sorted_offsets, dtype=np.int16)


def fetch_and_process_sprites(
    poke_count: int, tile_size: int, image_size: int, cache_dir: str
) -> tuple[np.ndarray, np.ndarray]:
    """
    Fetches Pokémon sprites from PokeAPI, caches them, resizes them, and
    extracts opaque pixel positions and their original 24-bit colors.
    
    Args:
        poke_count (int): The number of Pokémon sprites to fetch (by ID from 1 to poke_count).
        tile_size (int): The target size (width and height) for each sprite.
        image_size (int): The overall dimension of the final output image.
        cache_dir (str): Directory path to cache the downloaded sprites.

    Returns:
        tuple[np.ndarray, np.ndarray]: A tuple containing two NumPy arrays:
            - sprite_pixel_positions (np.int32): Global 1D indices in the final image
                                                  where sprite pixels will be placed.
            - original_colors (np.uint32): The original 24-bit integer color of each
                                           corresponding sprite pixel.
    """
    # Ensure the sprite cache directory exists on Google Drive
    os.makedirs(cache_dir, exist_ok=True)
    
    sprite_data_collector = [] # Temporarily store (global_pixel_index, color_id) tuples

    for pid in tqdm(range(1, poke_count + 1), desc="Fetching and processing sprites"):
        path = os.path.join(cache_dir, f"{pid}.png")
        img = None
        source_log = "" # To store the source of the sprite

        # Try loading from cache first
        if os.path.exists(path):
            try:
                img = Image.open(path)
                source_log = "from cache (Drive)"
            except IOError:
                logger.warning(f"Could not open cached sprite {path}. Attempting to re-fetch.")
                img = None # Force re-fetch if cache file is corrupt

        # If not loaded from cache or cache failed, fetch from API
        if img is None:
            try:
                # Fetch Pokémon data from PokeAPI
                r = requests.get(f"https://pokeapi.co/api/v2/pokemon/{pid}/", timeout=15)
                r.raise_for_status() # Raise an exception for HTTP errors (4xx or 5xx)
                data = r.json()
                
                # Get the URL for the front_default sprite
                url = data.get('sprites', {}).get('front_default')

                if not url:
                    logger.debug(f"No 'front_default' sprite URL found for Pokémon ID {pid}. Skipping.")
                    continue
                
                # Fetch sprite image content
                img_content = requests.get(url, timeout=15).content
                img = Image.open(BytesIO(img_content))
                img.save(path) # Save fetched image to cache
                source_log = "from PokeAPI"

            except requests.exceptions.RequestException as e:
                logger.warning(f"Network error fetching Pokémon ID {pid}: {e}. Skipping.")
                continue
            except KeyError:
                logger.warning(f"Unexpected data structure from PokeAPI for Pokémon ID {pid}. Skipping.")
                continue
            except Exception as e: # Catch any other unexpected errors during fetch/save
                logger.warning(f"An unexpected error occurred while fetching/saving Pokémon ID {pid}: {e}. Skipping.")
                continue

        if img is None: # If after all attempts, image is still not loaded
            continue

        # Log the source of the sprite, especially for the first one
        if pid == 1:
            logger.info(f"Pokémon ID {pid} sprite loaded {source_log}.")

        # Convert to RGBA and resize
        if img.mode != 'RGBA':
            img = img.convert('RGBA')
        
        # Resize using NEAREST to maintain pixel art quality
        img = img.resize((tile_size, tile_size), Image.NEAREST)
        arr = np.array(img)

        # Identify opaque pixels (alpha channel == 255)
        mask = arr[..., 3] == 255
        ys, xs = np.nonzero(mask) # Get local (y, x) coordinates of opaque pixels

        # Calculate the top-left corner of the current Pokémon's tile
        row, col = divmod(pid - 1, image_size // tile_size)
        y0, x0 = row * tile_size, col * tile_size

        # Collect global pixel positions and their original colors
        for y_local, x_local in zip(ys, xs):
            global_pixel_idx = (y0 + y_local) * image_size + (x0 + x_local)
            # Extract RGB components and combine into a single uint32 color ID
            r, g, b = arr[y_local, x_local, :3].astype(np.uint32)
            color_id = (r << 16) | (g << 8) | b
            sprite_data_collector.append((global_pixel_idx, color_id))
    
    if not sprite_data_collector:
        logger.warning("No opaque sprite pixels were collected. The output image might not contain sprites.")
        return np.array([], dtype=np.int32), np.array([], dtype=np.uint32)

    # Convert the collected list of tuples into two separate NumPy arrays
    positions = np.array([item[0] for item in sprite_data_collector], dtype=np.int32)
    orig_colors = np.array([item[1] for item in sprite_data_collector], dtype=np.uint32)

    log_mem("After sprite fetch and processing")
    return positions, orig_colors

@njit(cache=True) # Numba caching enabled. NUMBA_CACHE_DIR is set in the environment.
def embed_swaps_numba(
    perm: np.ndarray,
    pos_of_color: np.ndarray,
    positions: np.ndarray,
    orig_colors: np.ndarray,
    euclidean_sorted_offsets: np.ndarray
) -> np.ndarray:
    """
    Numba JIT-accelerated function to embed sprite colors into the permutation
    array using a nearest-neighbor search for occupied colors.
    Modifies perm and pos_of_color in-place.
    
    This version prioritizes the closest available color in RGB space for better
    sprite resemblance.
    """
    # Create a boolean array to track which of the 16,777,216 colors have been "used"
    # This array is directly indexed by the 24-bit color integer.
    used_colors = np.zeros(TOTAL_PIXELS, dtype=np.bool_)

    n_sprite_pixels = positions.shape[0]

    # Iterate over each sprite pixel. prange enables Numba's parallel execution for this loop
    # if Numba is configured to use multiple threads (e.g., via OMP_NUM_THREADS).
    for i in prange(n_sprite_pixels):
        p = positions[i]             # The global pixel index in the final image where this sprite pixel belongs
        orig_rgb_int = orig_colors[i] # The original 24-bit integer color of the sprite pixel

        chosen_color = -1 # Initialize with an invalid value

        # Attempt 1: Try to use the exact original color of the sprite pixel.
        if not used_colors[orig_rgb_int]:
            chosen_color = orig_rgb_int
            used_colors[chosen_color] = True
        else:
            # Attempt 2: Search for the closest available color in RGB space.
            # We convert the original 24-bit integer color back to its R, G, B components.
            r0 = (orig_rgb_int >> 16) & 0xFF
            g0 = (orig_rgb_int >> 8) & 0xFF
            b0 = orig_rgb_int & 0xFF
            
            # Iterate through pre-computed offsets. Since they are sorted by Euclidean distance,
            # the first available color found will be the closest.
            for j in range(euclidean_sorted_offsets.shape[0]):
                dr, dg, db = euclidean_sorted_offsets[j]
                
                r = r0 + dr # Candidate Red component
                g = g0 + dg # Candidate Green component
                b = b0 + db # Candidate Blue component
                
                # Check if the candidate color's components are within valid RGB bounds (0-255).
                if 0 <= r < 256 and 0 <= g < 256 and 0 <= b < 256:
                    # Reconstruct the 24-bit integer color ID for the candidate.
                    candidate_color = (r << 16) | (g << 8) | b
                    # Check if this candidate color has not been used by another sprite pixel yet.
                    if not used_colors[candidate_color]:
                        chosen_color = candidate_color # This is our chosen color
                        used_colors[chosen_color] = True # Mark it as used
                        break # Found the closest available neighbor, so we can stop searching.
            
            if chosen_color == -1: # If chosen_color is still -1, it means no neighbor within MAX_RAD was found.
                # Fallback: Search linearly for *any* unused color.
                # This is a last resort to guarantee the 1:1 mapping constraint is met.
                # This should be very rare with a reasonable MAX_RAD and sufficient free colors.
                for cand_linear in range(TOTAL_PIXELS): # Iterate through all possible colors (0 to 2^24-1)
                    if not used_colors[cand_linear]:
                        chosen_color = cand_linear
                        used_colors[chosen_color] = True
                        break
                # If after this loop chosen_color is still -1, it's a critical error implying
                # that all 16M colors are already used, which should not be possible unless
                # the number of sprite pixels exceeds TOTAL_PIXELS (which it does not).
                if chosen_color == -1:
                    pass # Placeholder: In a production system, consider raising an error or logging a critical failure.

        # Now, perform the crucial 1:1 swap in the permutation array (`perm`) and update
        # the reverse lookup table (`pos_of_color`).
        
        # 1. Get the current position (index in `perm`) where the `chosen_color` currently resides.
        src_pos_of_chosen_color = pos_of_color[chosen_color]
        
        # 2. Get the color that is currently at the target sprite pixel position `p`.
        color_at_sprite_target_pos = perm[p]

        # 3. Place the `chosen_color` (the one we want for the sprite pixel) at `p`.
        perm[p] = chosen_color
        
        # 4. Move the `color_at_sprite_target_pos` (the one that was displaced from `p`)
        #    to the position where `chosen_color` used to be.
        perm[src_pos_of_chosen_color] = color_at_sprite_target_pos

        # 5. Update the reverse lookup table (`pos_of_color`) to reflect these swaps.
        #    The chosen_color is now at 'p'.
        pos_of_color[chosen_color] = p
        #    The displaced color (color_at_sprite_target_pos) is now at src_pos_of_chosen_color.
        pos_of_color[color_at_sprite_target_pos] = src_pos_of_chosen_color
    
    return used_colors # Returning the mask can be useful for debugging or further analysis


def initialize_permutation_and_lookup(total_pixels: int, seed: int) -> tuple[np.ndarray, np.ndarray]:
    """
    Initializes the 24-bit color permutation array and its reverse lookup table.
    Prioritizes GPU shuffling with CuPy for speed, falling back to CPU NumPy if CuPy is unavailable or fails.
    """
    if USE_GPU:
        try:
            logger.info("Attempting initial color shuffle using CuPy on GPU...")
            rng = cp.random.RandomState(seed)
            # Generate the permutation on GPU, then transfer to CPU for Numba processing.
            perm_gpu = rng.permutation(cp.arange(total_pixels, dtype=cp.uint32))
            perm = cp.asnumpy(perm_gpu) 
            del perm_gpu # Explicitly release CuPy array to free GPU memory
            log_mem("After GPU shuffle (transferred to CPU)")
        except cp.cuda.runtime.CudaError as e:
            logger.warning(f"CuPy CUDA error during shuffle ({e}). Falling back to CPU shuffle.")
            perm = np.random.default_rng(seed).permutation(total_pixels).astype(np.uint32)
            log_mem("After CPU shuffle (fallback)")
        except Exception as e:
            logger.warning(f"Unexpected error with CuPy shuffle ({e}). Falling back to CPU shuffle.")
            perm = np.random.default_rng(seed).permutation(total_pixels).astype(np.uint32)
            log_mem("After CPU shuffle (fallback)")
    else:
        logger.info("Using CPU for initial color shuffle (CuPy not enabled or failed).")
        perm = np.random.default_rng(seed).permutation(total_pixels).astype(np.uint32)
        log_mem("After CPU shuffle")

    # Build reverse lookup: pos_of_color[color_id] = index_in_perm_array
    # This array allows O(1) lookup to find where a specific color is currently located in the `perm` array.
    pos_of_color = np.empty(total_pixels, dtype=np.int32)
    # Using prange for this loop as well, as it can be parallelized by Numba.
    for idx in prange(total_pixels):
        pos_of_color[perm[idx]] = idx
    
    log_mem("After lookup table build")
    return perm, pos_of_color


def build_and_save_image(perm: np.ndarray, positions: np.ndarray, image_size: int, output_file: str):
    """
    Constructs the final RGBA image buffer from the modified permutation array
    and saves it to a PNG file.
    """
    logger.info("Building final RGBA image buffer...")
    
    # Initialize the alpha channel: 128 for background pixels (semi-transparent),
    # and 255 for sprite pixels (fully opaque).
    alpha_channel = np.full(TOTAL_PIXELS, 128, dtype=np.uint8)
    alpha_channel[positions] = 255 # Set alpha for all sprite pixel positions to 255

    # Create the final RGBA buffer. The `perm` array contains the 24-bit color IDs.
    # We extract the R, G, B components using bitwise operations.
    buf = np.empty((TOTAL_PIXELS, 4), dtype=np.uint8)
    buf[:, 0] = (perm >> 16) & 0xFF  # Red channel (most significant 8 bits)
    buf[:, 1] = (perm >> 8) & 0xFF   # Green channel (middle 8 bits)
    buf[:, 2] = perm & 0xFF          # Blue channel (least significant 8 bits)
    buf[:, 3] = alpha_channel        # Alpha channel

    log_mem("After RGBA buffer construction")

    # Reshape the 1D buffer into a 2D image array (IMAGE_SIZE x IMAGE_SIZE x 4)
    # and save it using PIL (Pillow).
    logger.info(f"Saving final image to {output_file}...")
    img = Image.fromarray(buf.reshape((image_size, image_size, 4)), 'RGBA')
    img.save(output_file)
    logger.info(f"Image saved successfully to {output_file}.")
    log_mem("Done saving image")


def main():
    log_mem("Script Start")

    # IMPORTANT: The Google Drive mounting step `drive.mount('/content/drive')`
    # MUST be executed in a separate Colab notebook cell before running this script
    # via `!python`. This script assumes Drive is already mounted at /content/drive.

    # Ensure the Numba cache and sprite cache directories exist on Google Drive.
    # os.makedirs will create them if they don't, but will not delete existing contents.
    # These paths are within the *mounted* Google Drive, so they operate on your Drive.
    os.makedirs(NUMBA_CACHE_ROOT, exist_ok=True)
    os.makedirs(SPRITE_CACHE_DIR, exist_ok=True)
    logger.info(f"Numba cache directory ensured: {NUMBA_CACHE_ROOT}")
    logger.info(f"Sprite cache directory ensured: {SPRITE_CACHE_DIR}")

    # Step 1: Precompute color offsets for optimized nearest-neighbor search
    euclidean_sorted_offsets = precompute_euclidean_sorted_offsets(MAX_RAD)
    logger.info(f"Precomputed {euclidean_sorted_offsets.shape[0]} Euclidean-sorted offsets for color search (radius up to {MAX_RAD}).")

    # Step 2: Initialize the main color permutation array and its reverse lookup table.
    perm, pos_of_color = initialize_permutation_and_lookup(TOTAL_PIXELS, SEED)

    # Step 3: Fetch, process, and collect data for Pokémon sprites.
    positions, orig_colors = fetch_and_process_sprites(POKE_COUNT, TILE_SIZE, IMAGE_SIZE, SPRITE_CACHE_DIR)
    
    if positions.size == 0:
        logger.error("No sprite pixels were collected. Cannot proceed with embedding. Exiting.")
        return

    # Step 4: Embed sprite colors into the permutation array.
    logger.info(f"Embedding {positions.shape[0]} sprite pixels with optimized nearest-neighbor remap...")
    _ = embed_swaps_numba(perm, pos_of_color, positions, orig_colors, euclidean_sorted_offsets)
    log_mem("After embedding sprites into permutation")

    # Step 5: Construct the final RGBA image buffer and save it to a file.
    build_and_save_image(perm, positions, IMAGE_SIZE, OUTPUT_FILE)

    logger.info("Script execution completed successfully!")

if __name__ == '__main__':
    main()

Pokémon, Pokémon names, and Pokémon sprites are trademarks of The Pokémon Company.

L'Origine du monde

2025-07-09T09:09:28+02:00

L'Origine du monde, Gustave Courbet, musée d'Orsay, Paris, France

THIRD v3 (smallest Joconde of the world)

2025-07-08T22:46:00+02:00

The smallest Joconde of the world !

v1 :
WEBP = 176 KB / PNG = 256 KB
v2 :
WEBP = 192 KB / PNG = 268 KB
v3 :
WEBP = 167 KB / PNG = 240 KB

I managed to build an image into 2 RGB channels, instead of 3 RGB channels, which results in considerably reducing the size of the files.

Moreover, I used 3 different methods
Click here to view the comparison between v1 & v2 & v3 :

In the same collection :
FIRST
SECOND v1
SECOND v2
THIRD v1
THIRD v2
THIRD v3

animated TETRIS

2025-07-07T10:44:52+02:00

Each of 61 frames has got 16,777,216 unique colors

allRGB 0.2 MB

2025-07-07T09:51:14+02:00

allRGB 0.2 MB

THIRD v2 (smallest Joconde of the world)

2025-07-07T09:50:47+02:00

In the same collection :
FIRST
SECOND v1
SECOND v2
THIRD v1
THIRD v2
THIRD v3

THIRD v1 (smallest Joconde of the world)

2025-07-07T09:50:32+02:00

In the same collection :
FIRST
SECOND v1
SECOND v2
THIRD v1
THIRD v2
THIRD v3

6 colors brightness 2/2

2025-07-04T19:50:45+02:00

6 colors brightness 2/2

6 colors brightness 1/2

2025-07-04T19:49:42+02:00

FULL PALETTES v3

2025-07-04T08:33:20+02:00

Inspired by this file : 3-bit RGB Palette - Ordered Dithering.png

v1 : Ordered dithering from the original file, same dimensions

v2 : My custom version, smooth dithering, more colors, 1792 boxes color samples

v3 : One random shuffle version, 1792 samples from v2

FULL PALETTES v2

2025-07-04T08:31:44+02:00

FULL PALETTES v1

2025-07-03T21:00:35+02:00

ULTIMATE SHADES

2025-07-03T08:40:18+02:00

This animation contains 6144 different shades of the same image (256x256).
6144 shades of brightness, lightness, darkness, luminosity, contrast, tint, hue, saturation.

All the 24 frames (4096x4096) have got 16,777,216 unique colors
All the 6144 images (256x256) have got 65,536 unique colors

CHALLENGE GAME FOR GEEKS #25

2025-07-02T17:18:14+02:00

Challenge n°25 : Pairs

Among these 32 pairs, find the only one that is not exactly the same

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

African savanna

2025-07-01T21:50:02+02:00

African savanna

animated making 8 colors image

2025-07-01T09:55:52+02:00

Each of 64 frames has got 16,777,216 unique colors

reduced Mario

2025-07-01T09:54:10+02:00

New method for separating the 8 standard colors, with reduced size.

Old version > 50 MB
This new version 1.75 MB

animated GRAFFITI

2025-06-30T12:31:13+02:00

Each of 59 frames has got 16,777,216 unique colors

Additive 8 colors - 3/3 gradient

2025-06-29T10:46:11+02:00

1/3 overlaying :

2/3 crossing interlacing :

3/3 gradient :

In the same collection :
Additive Palette
TRANSPARENCY ! (ALL AROUND COLORS 3/3)
Additive RGB colors v1
Additive RGB colors v2
PURE Additive RGB colors (v3)
Additive clear colors multi-levels 1-2
Additive clear colors multi-levels 2-2
Additive 8 colors - 1/3 overlaying
Additive 8 colors - 2/3 crossing interlacing
Additive 8 colors - 3/3 gradient

Gradient 8 colors

2025-06-29T10:44:24+02:00

Gradient 8 colors, from black to white
So the central colors are "pure" given they don't use "dark/black" & "light/white"

Additive 8 colors - 2/3 crossing interlacing

2025-06-28T21:15:58+02:00

1/3 overlaying :

2/3 crossing interlacing :

3/3 gradient :

Additive 8 colors - 1/3 overlaying

2025-06-28T21:08:49+02:00

1/3 overlaying :

2/3 crossing interlacing :

3/3 gradient :

OPTICAL ILLUSION

2025-06-27T09:49:04+02:00

This is the Adelson's checker shadow illusion into allRGB

background A = background B !

RGBallet

2025-06-26T17:58:47+02:00

This is a remix of Spandau. Created with Chatgpt and Google Colab.

CHROMATIC PHOTOGRAPHIC

2025-06-26T17:02:49+02:00

animated ZOOM v2

2025-06-26T12:32:29+02:00

ULTIMATE VERSION !

11 different levels of zoom :
64 x 64
128 x 128
256 x 256
512 x 512
1024 x 1024
1536 x 1536
2048 x 2048
2560 x 2560
3072 x 3072
3584 x 3584
4096 x 4096

frames * 2 / lookup reverse view zoom-in zoom-out

Each of 22 frames has got 16,777,216 unique colors

animated ZOOM v1

2025-06-25T19:18:26+02:00

Each of 32 frames has got 16,777,216 unique colors

animated burning art

2025-06-25T19:15:11+02:00

Each of 28 frames has got 16,777,216 unique colors

animated TRANSITION v7

2025-06-24T14:15:08+02:00

v1 : Fading transition by interlacing method

Each of 32 frames has got 16,777,216 unique colors

v2 : Fading transition by interlacing method

Each of 32 frames has got 16,777,216 unique colors

v3 : Real fading transition between two images

Each of 16 frames has got 16,777,216 unique colors

v4 : Transition by pixelation style, BIG squares

Each of 64 frames has got 16,777,216 unique colors

v5 : Transition by pixelation style, SMALL squares

Each of 64 frames has got 16,777,216 unique colors

v6 : Transition by sliding diaporama, between six images, exploring the 6 possible RGB channels

Each of 96 frames has got 16,777,216 unique colors

v7 : Transition by zooming allRGB logo

Each of 66 frames has got 16,777,216 unique colors

animated TRANSITION v6

2025-06-24T10:43:35+02:00

v1 : Fading transition by interlacing method

Each of 32 frames has got 16,777,216 unique colors

v2 : Fading transition by interlacing method

Each of 32 frames has got 16,777,216 unique colors

v3 : Real fading transition between two images

Each of 16 frames has got 16,777,216 unique colors

v4 : Transition by pixelation style, BIG squares

Each of 64 frames has got 16,777,216 unique colors

v5 : Transition by pixelation style, SMALL squares

Each of 64 frames has got 16,777,216 unique colors

v6 : Transition by sliding diaporama, between six images, exploring the 6 possible RGB channels

Each of 96 frames has got 16,777,216 unique colors

v7 : Transition by zooming allRGB logo

Each of 66 frames has got 16,777,216 unique colors

animated TRANSITION v5

2025-06-24T10:40:36+02:00

v1 : Fading transition by interlacing method

Each of 32 frames has got 16,777,216 unique colors

v2 : Fading transition by interlacing method

Each of 32 frames has got 16,777,216 unique colors

v3 : Real fading transition between two images

Each of 16 frames has got 16,777,216 unique colors

v4 : Transition by pixelation style, BIG squares

Each of 64 frames has got 16,777,216 unique colors

v5 : Transition by pixelation style, SMALL squares

Each of 64 frames has got 16,777,216 unique colors

v6 : Transition by sliding diaporama, between six images, exploring the 6 possible RGB channels

Each of 96 frames has got 16,777,216 unique colors

v7 : Transition by zooming allRGB logo

Each of 66 frames has got 16,777,216 unique colors

animated TRANSITION v4

2025-06-24T10:02:20+02:00

v1 : Fading transition by interlacing method

Each of 32 frames has got 16,777,216 unique colors

v2 : Fading transition by interlacing method

Each of 32 frames has got 16,777,216 unique colors

v3 : Real fading transition between two images

Each of 16 frames has got 16,777,216 unique colors

v4 : Transition by pixelation style, BIG squares

Each of 64 frames has got 16,777,216 unique colors

v5 : Transition by pixelation style, SMALL squares

Each of 64 frames has got 16,777,216 unique colors

v6 : Transition by sliding diaporama, between six images, exploring the 6 possible RGB channels

Each of 96 frames has got 16,777,216 unique colors

v7 : Transition by zooming allRGB logo

Each of 66 frames has got 16,777,216 unique colors

animated TRANSITION v3

2025-06-24T09:54:53+02:00

v1 : Fading transition by interlacing method

Each of 32 frames has got 16,777,216 unique colors

v2 : Fading transition by interlacing method

Each of 32 frames has got 16,777,216 unique colors

v3 : Real fading transition between two images

Each of 16 frames has got 16,777,216 unique colors

v4 : Transition by pixelation style, BIG squares

Each of 64 frames has got 16,777,216 unique colors

v5 : Transition by pixelation style, SMALL squares

Each of 64 frames has got 16,777,216 unique colors

v6 : Transition by sliding diaporama, between six images, exploring the 6 possible RGB channels

Each of 96 frames has got 16,777,216 unique colors

v7 : Transition by zooming allRGB logo

Each of 66 frames has got 16,777,216 unique colors

GHOSTS

2025-06-22T19:29:03+02:00

GHOSTS

SECOND v2

2025-06-21T10:10:30+02:00

Same concept and description as "FIRST" but full colored and within a pixel-art style. Again very small size !

WEBP = 244 KB / PNG = 434 KB

SECOND v1

2025-06-21T10:04:40+02:00

Same concept and description as "FIRST" but full colored and within a pixel-art style. Again very small size !

WEBP = 246 KB / PNG = 414 KB

Mimesia Icon

2025-06-20T16:27:08+02:00

The Mimesia symbol icon, behaving as a fractal. Created with Chatgpt and Google Colab.

import numpy as np
from PIL import Image

def generate_heart_with_transparent_gray_background(
    levels=3,
    output_path="fractal_heart_transparent_bg.png",
    random_seed=42
):
    """
    Generates a 16^levels × 16^levels fractal heart sprite, using every 24-bit RGB color exactly once,
    with:
      1) A dark 1-px outline (darkest colors) around each smallest sprite.
      2) A light 1-px outline (lightest colors) just outside each sprite.
      3) A smooth hue-gradient fill inside each sprite.
      4) The remaining colors shuffled into the background.
      5) The background rendered at 50% opacity (alpha=128), while the sprite stays fully opaque.
    """
    # 1. Build base 16×16 mask and outlines
    sprite_data = [
        "0000010011000000","0000100100100000","0000100100100000","0000010101000000",
        "0000000100000000","0000000100000000","0022220102222000","0221112021112200",
        "0211111211111200","0211111111111200","0011111111111000","0001111111110000",
        "0000111111100000","0000011111000000","0000001110000000","0000000100000000",
    ]
    rows, cols = 16, 16
    base_flat = np.array([int(c) for row in sprite_data for c in row], dtype=np.uint8)
    base_mask = base_flat.reshape((rows, cols))

    # identify fill, boundary, outside, interior indices
    base_i = np.arange(rows*cols) // cols
    base_j = np.arange(rows*cols) % cols
    fill_base = np.where(base_flat > 0)[0]

    boundary_base = []
    for idx in fill_base:
        i, j = base_i[idx], base_j[idx]
        for di, dj in [(-1,0),(1,0),(0,-1),(0,1)]:
            ni, nj = i+di, j+dj
            if ni<0 or ni>=rows or nj<0 or nj>=cols or base_mask[ni,nj]==0:
                boundary_base.append(idx)
                break
    boundary_base = np.unique(boundary_base)

    outside_base = []
    for idx in range(rows*cols):
        if base_flat[idx] == 0:
            i, j = base_i[idx], base_j[idx]
            for di, dj in [(-1,0),(1,0),(0,-1),(0,1)]:
                ni, nj = i+di, j+dj
                if 0<=ni0:
                    outside_base.append(idx)
                    break
    outside_base = np.unique(outside_base)

    interior_base = np.setdiff1d(fill_base, boundary_base, assume_unique=True)

    # 2. Build 4096×4096 fractal mask
    mask1 = (base_mask>0).astype(np.uint8)
    mask2 = np.kron(mask1, mask1)     # 256×256
    fractal = np.kron(mask2, mask1)   # 4096×4096
    H, W = fractal.shape
    total = H * W
    flat_f = fractal.ravel()

    # block positions for outlines & interior
    block_idxs = np.nonzero(mask2.ravel())[0]
    br = block_idxs // mask2.shape[1]
    bc = block_idxs % mask2.shape[1]
    n_blocks = br.size
    block_offset = br * 16 * W + bc * 16

    # 3. Precompute color metrics
    idxs = np.arange(total, dtype=np.uint32)
    R = ((idxs>>16)&0xFF).astype(np.float32)/255.0
    G = ((idxs>>8 )&0xFF).astype(np.float32)/255.0
    B = ((idxs    )&0xFF).astype(np.float32)/255.0
    lum = 0.299*(R*255) + 0.587*(G*255) + 0.114*(B*255)
    mx, mn = np.maximum.reduce([R,G,B]), np.minimum.reduce([R,G,B])
    d = mx - mn
    S = np.where(mx==0, 0, d/mx)

    # compute hue
    Hh = np.zeros_like(mx)
    nz = d != 0
    mR = (R==mx)&nz; mG = (G==mx)&nz; mB = (B==mx)&nz
    Hh[mR] = ((G[mR]-B[mR])/d[mR]) % 6
    Hh[mG] = ((B[mG]-R[mG])/d[mG]) + 2
    Hh[mB] = ((R[mB]-G[mB])/d[mB]) + 4
    Hh *= 60

    # 4. Segment the palette
    lum_order = np.argsort(lum)  # ascending lum
    # darkest for dark outline
    n_dark = n_blocks * boundary_base.size
    dark_colors = lum_order[:n_dark]
    # lightest for light outline
    n_light = n_blocks * outside_base.size
    light_colors = lum_order[-n_light:]
    # mid palette
    mid = lum_order[n_dark:-n_light]

    # interior fill = highest-sat from mid
    sat_mid = S[mid]
    sat_sorted = mid[np.argsort(-sat_mid)]
    n_int = n_blocks * interior_base.size
    int_colors = sat_sorted[:n_int]
    int_colors = int_colors[np.argsort(Hh[int_colors])]  # sort by hue
    # background = rest
    bg_colors = sat_sorted[n_int:]
    rng = np.random.default_rng(random_seed)
    rng.shuffle(bg_colors)

    # 5. Assign colors + alpha
    assign = np.empty(total, dtype=np.uint32)
    alpha = np.full(total, 128, dtype=np.uint8)  # default 50% for bg

    # dark outline positions
    bi = boundary_base//cols; bj = boundary_base%cols
    pos_dark = (block_offset[:,None] + bi[None,:]*W + bj[None,:]).ravel()
    assign[pos_dark] = dark_colors
    alpha[pos_dark] = 255

    # light outline positions
    bo_i = outside_base//cols; bo_j = outside_base%cols
    pos_light = (block_offset[:,None] + bo_i[None,:]*W + bo_j[None,:]).ravel()
    assign[pos_light] = light_colors
    alpha[pos_light] = 255

    # interior fill positions
    bi3 = interior_base//cols; bj3 = interior_base%cols
    pos_int = (block_offset[:,None] + bi3[None,:]*W + bj3[None,:]).ravel()
    assign[pos_int] = int_colors
    alpha[pos_int] = 255

    # background
    all_bg = np.nonzero(flat_f==0)[0]
    bg_pos = np.setdiff1d(all_bg, pos_light, assume_unique=True)
    assign[bg_pos] = bg_colors
    # alpha remains 128

    # 6. Build RGBA image
    Rf = ((assign>>16)&0xFF).astype(np.uint8).reshape(H,W)
    Gf = ((assign>>8 )&0xFF).astype(np.uint8).reshape(H,W)
    Bf = ((assign    )&0xFF).astype(np.uint8).reshape(H,W)
    Af = alpha.reshape(H,W)
    rgba = np.dstack((Rf, Gf, Bf, Af))

    img = Image.fromarray(rgba, mode='RGBA')
    img.save(output_path)
    print(f"Saved {H}×{W} RGBA image to '{output_path}' with 50%-transparent background.")

if __name__ == "__main__":
    generate_heart_with_transparent_gray_background()

Also see:

Penrose Diagram v2

2025-06-20T14:25:17+02:00

Having fun with Google ai Studio (Gemini Pro 2.5 Preview 05-06).

import numpy as np
from PIL import Image
from scipy.special import lambertw
import math

# Image dimensions
WIDTH = 4096
HEIGHT = 4096

# Schwarzschild radius parameter, 2M. We set 2M=1 for simplicity in formulas.
TWOM = 1.0 
M = TWOM / 2.0 # M = 0.5

# --- Feature Definition Parameters ---
# Thresholds for identifying singularities and horizons based on r-value
R_THRESH_SINGULARITY = 0.03 * TWOM  # r near 0 is singularity-like
R_THRESH_HORIZON = 0.03 * TWOM      # r near 2M (i.e., 1.0 here) is horizon-like

# Parameters for r=const lines
NUM_R_LINES = 10  # Number of r-lines to draw
# Define r-values for these lines, from near singularity to outside horizon
R_LINE_VALS_INNER = np.linspace(R_THRESH_SINGULARITY * 1.5, TWOM - R_THRESH_HORIZON * 1.5, NUM_R_LINES // 2)
R_LINE_VALS_OUTER = np.linspace(TWOM + R_THRESH_HORIZON * 1.5, 3.0 * TWOM, NUM_R_LINES - (NUM_R_LINES // 2) )
R_LINE_VALUES = np.concatenate((R_LINE_VALS_INNER, R_LINE_VALS_OUTER))
R_LINE_WIDTH_PARAM = 0.025 * TWOM # Visual thickness of r-lines (in r-units)

# Parameters for t=const lines
NUM_T_LINES = 24  # Number of t-lines (spokes)
# t-lines are based on normalized effective t or angle. Width is relative.
T_LINE_WIDTH_PARAM = 0.03 # Visual thickness of t-lines (fraction of inter-line spacing)
# --- End Feature Definition Parameters ---

# Helper function to calculate Schwarzschild r from Kruskal-related product P
# P = (1 - r/2M) * exp(r/2M)
def get_r_from_P(P_val):
    # Handle P_val near special points carefully
    if math.isclose(P_val, 0.0): # Horizon (r = 2M)
        return TWOM
    if math.isclose(P_val, 1.0): # Singularity (r = 0 for 2M=1 convention of P)
        return 0.0

    # For r < 2M (Regions II, IV), P_val is in (0, 1]. (1-r/2M) > 0.
    if P_val > 0:
        # We solve (1-x)e^x = P_val where x = r/2M.
        # Let y = 1-x. Then y * e^(1-y) = P_val => y * e * e^(-y) = P_val
        # => y * e^(-y) = P_val / e. So, y = W_0(P_val / e).
        # r/2M = 1 - y  => r = 2M * (1 - W_0(P_val / e))
        # Ensure argument to lambertw is within its domain [-1/e, inf)
        arg_lambert = P_val / np.e
        if arg_lambert < -1.0/np.e: # Clamp if slightly out due to precision
            arg_lambert = -1.0/np.e + 1e-12
        
        y = lambertw(arg_lambert, k=0).real # Principal branch W_0
        r = TWOM * (1.0 - y)
        return np.clip(r, 0, TWOM) # r should be in [0, 2M]

    # For r > 2M (Regions I, III), P_val is < 0. (1-r/2M) < 0.
    else: # P_val < 0
        # We solve (1-x)e^x = P_val where x = r/2M.
        # Let u = x-1 > 0. Then x = u+1.
        # -u * e^(u+1) = P_val => -u * e * e^u = P_val => u * e^u = -P_val / e.
        # u = W_0(-P_val / e).
        # r/2M = 1 + u => r = 2M * (1 + W_0(-P_val / e))
        arg_lambert = -P_val / np.e # This is > 0
        u = lambertw(arg_lambert, k=0).real
        r = TWOM * (1.0 + u)
        return np.clip(r, TWOM, None) # r should be >= 2M


# Helper function to calculate effective Schwarzschild t-like coordinate
def get_t_eff(U_k, V_k, region_id):
    # Avoid division by zero or log of non-positive for edge cases
    if math.isclose(U_k, 0.0) or math.isclose(V_k, 0.0):
        return 0.0 # On a horizon, t is not well-defined this way or is infinite

    # Kruskal T and R coordinates
    T_k = (U_k + V_k) / 2.0
    R_k = (V_k - U_k) / 2.0

    # Regions I, III (exterior, r > 2M, R_k is spacelike, T_k is timelike)
    # Schwarzschild t = 2*(2M) * arctanh(T_k/R_k)
    if region_id == 1 or region_id == 3:
        if math.isclose(R_k, 0.0) : return np.inf * np.sign(T_k) # Approximate
        ratio = T_k / R_k
        # Ratio should be in (-1, 1). Clamp for stability.
        ratio = np.clip(ratio, -1.0 + 1e-9, 1.0 - 1e-9)
        return 2.0 * TWOM * np.arctanh(ratio)

    # Regions II, IV (interior, r < 2M, T_k is spacelike, R_k is timelike)
    # Schwarzschild r (acting as time) = 2*(2M) * arctanh(R_k/T_k)
    # The 't_eff' here is this time-like Schwarzschild r.
    elif region_id == 2 or region_id == 4:
        if math.isclose(T_k, 0.0): return np.inf * np.sign(R_k) # Approximate
        ratio = R_k / T_k
        ratio = np.clip(ratio, -1.0 + 1e-9, 1.0 - 1e-9)
        return 2.0 * TWOM * np.arctanh(ratio)
    
    return 0.0 # Default

# Store pixel properties and sort keys
pixel_data = [] # List of dictionaries

print("Step 1: Calculating pixel properties and sort keys...")
for iy in range(HEIGHT):
    if iy % (max(1, HEIGHT // 20)) == 0: # Print progress roughly 20 times
        print(f"  Processing row {iy+1}/{HEIGHT}...")
    
    for ix in range(WIDTH):
        original_idx = iy * WIDTH + ix # Unique index for each pixel

        # Map pixel (ix, iy) to Penrose coordinates (rho, tau)
        # rho (horizontal) from -π/2 to π/2
        # tau (vertical, increases upwards) from -π/2 to π/2
        rho = (ix / (WIDTH - 1.0)) * np.pi - np.pi / 2.0
        tau = ((HEIGHT - 1.0 - iy) / (HEIGHT - 1.0)) * np.pi - np.pi / 2.0

        # Kruskal U, V from Penrose coordinates:
        # arctan(V_k) = tau + rho, arctan(U_k) = tau - rho
        arg_V = tau + rho
        arg_U = tau - rho
        
        # Epsilon for boundary checks (where tan arguments are ±π/2)
        eps_boundary_arg = 1e-7 
        is_scri = False
        if abs(abs(arg_U) - np.pi/2.0) < eps_boundary_arg or \
           abs(abs(arg_V) - np.pi/2.0) < eps_boundary_arg:
            is_scri = True

        # Clip arguments to tan to avoid infinity, but allow large values near boundaries
        # This makes U_k, V_k large but finite at scri, good enough for r, t calc.
        tan_clip_arg = np.pi/2.0 - eps_boundary_arg 
        U_k = np.tan(np.clip(arg_U, -tan_clip_arg, tan_clip_arg))
        V_k = np.tan(np.clip(arg_V, -tan_clip_arg, tan_clip_arg))

        # Schwarzschild r from -U_k * V_k = (1 - r/2M)e^(r/2M)
        P_val = -U_k * V_k
        r_val = -1.0 # Default to invalid r
        try:
            r_val = get_r_from_P(P_val)
        except (ValueError, OverflowError, ZeroDivisionError): 
            # Catch issues with LambertW or extreme inputs
            if P_val > 1.0 + 1e-6 : r_val = 0.0 # Effectively singularity if P too large
            elif is_scri : r_val = 1000 * TWOM # Large r for scri if P is negative infinite like
            # Other calculation failures might leave r_val = -1

        # Determine region ID based on signs of U_k, V_k (or arg_U, arg_V for robustness)
        # Region I (Exterior, right): V_k > 0, U_k < 0 => arg_V > 0, arg_U < 0 => rho > |tau|
        # Region II (Black Hole, top): V_k > 0, U_k > 0 => arg_V > 0, arg_U > 0 => tau > |rho|
        # Region III (Other Exterior, left): V_k < 0, U_k > 0 => arg_V < 0, arg_U > 0 => rho < -|tau|
        # Region IV (White Hole, bottom): V_k < 0, U_k < 0 => arg_V < 0, arg_U < 0 => tau < -|rho|
        region_id = 0 # Default/Ambiguous
        # Use small epsilon for comparing rho, tau magnitudes to define regions clearly
        eps_region_comp = 1e-6 
        if tau > abs(rho) - eps_region_comp: region_id = 2
        elif rho > abs(tau) - eps_region_comp: region_id = 1
        elif tau < -abs(rho) + eps_region_comp: region_id = 4
        elif rho < -abs(tau) + eps_region_comp: region_id = 3
        
        # Effective Schwarzschild t-like coordinate
        t_eff_val = 0.0
        if r_val >= 0: # Only if r is valid
            try:
                t_eff_val = get_t_eff(U_k, V_k, region_id)
            except (ValueError, OverflowError, ZeroDivisionError):
                 t_eff_val = np.inf if region_id in [1,3] else 0 # Default t based on region behavior

        # --- Identify features for sorting key ---
        is_sing = (r_val >= 0 and r_val < R_THRESH_SINGULARITY)
        is_hor = (r_val >= 0 and abs(r_val - TWOM) < R_THRESH_HORIZON)
        
        # t=const lines
        is_t_line = False
        t_line_idx = 0
        # Normalize t_eff to something periodic or bounded for line checks
        # For simplicity, check against discrete t_eff values if they are somewhat bounded by arctanh
        # Or, use angle in Kruskal plane: angle = np.arctan2(U_k + V_k, V_k - U_k) (for T_k, R_k)
        # This angle ranges -pi to pi.
        kruskal_T_k = (U_k + V_k) / 2.0
        kruskal_R_k = (V_k - U_k) / 2.0
        # Use different angles depending on region (where T or R is timelike)
        if region_id == 1 or region_id == 3: # T_k timelike (effectively)
            line_angle_rad = np.arctan2(kruskal_T_k, kruskal_R_k) if not (math.isclose(kruskal_T_k,0) and math.isclose(kruskal_R_k,0)) else 0
        else: # R_k timelike (effectively)
            line_angle_rad = np.arctan2(kruskal_R_k, kruskal_T_k) if not (math.isclose(kruskal_T_k,0) and math.isclose(kruskal_R_k,0)) else 0

        # Check if current angle is close to one of NUM_T_LINES angles
        target_angles = np.linspace(-np.pi, np.pi, NUM_T_LINES, endpoint=False)
        angle_diff_min = np.pi # Smallest difference to a target angle
        for i, target_ang in enumerate(target_angles):
            diff = abs(line_angle_rad - target_ang)
            diff = min(diff, 2*np.pi - diff) # Account for angle wrap-around
            if diff < angle_diff_min:
                angle_diff_min = diff
                t_line_idx = i
        
        if angle_diff_min < (np.pi / NUM_T_LINES) * T_LINE_WIDTH_PARAM * 5: # Width factor
            is_t_line = True

        # r=const lines
        is_r_line = False
        r_line_idx = 0
        if r_val >= 0: # Only if r is valid
            for i, r_center in enumerate(R_LINE_VALUES):
                if abs(r_val - r_center) < R_LINE_WIDTH_PARAM / 2.0:
                    is_r_line = True
                    r_line_idx = i
                    break
        
        # --- Construct sort key: (priority, param1, param2) ---
        # Lower priority value means "drawn earlier" / gets earlier block of colors.
        priority = 10.0 # Default fill
        param1 = 0.0    # Primary sort within priority group
        param2 = 0.0    # Secondary sort / tie-breaker

        if is_sing:
            priority = 0.0
            param1 = tau # Position along singularity (future vs past via tau)
        elif is_hor:
            priority = 1.0
            param1 = tau # Position along horizon (future vs past via tau)
        elif is_t_line:
            priority = 2.0
            param1 = t_line_idx # Which t-line
            param2 = r_val      # Position along the t-line (by r_val)
        elif is_r_line:
            priority = 3.0
            param1 = r_line_idx # Which r-line
            # Sort along r-line by angle (more consistent than t_eff which can be inf)
            param2 = line_angle_rad 
        elif is_scri:
            priority = 4.0
            # Distinguish scri segments, e.g. using which boundary it is.
            # (tau+rho) near +-pi/2, (tau-rho) near +-pi/2
            # Simplified: sort by tau, then rho.
            param1 = tau 
            param2 = rho
        else: # General region fill
            priority = 5.0 + region_id # Separate fill for each region
            # Shading within region based on r and t (or angle)
            # Example: make r variation primary, angle secondary
            param1 = r_val
            param2 = line_angle_rad
            
        sort_key_tuple = (priority, param1, param2)
        pixel_data.append({'key': sort_key_tuple, 'idx': original_idx})

print("Step 2: Sorting pixel data...")
# Python's sort is stable. If keys are identical, original order (by idx) is preserved.
# This is fine as idx itself is unique.
pixel_data.sort(key=lambda p: p['key'])

print("Step 3: Assigning color ranks...")
# pixel_ranks[original_pixel_idx] stores the final color rank for that pixel.
pixel_ranks = np.empty(WIDTH * HEIGHT, dtype=np.uint32)
for k_rank, p_info in enumerate(pixel_data):
    pixel_ranks[p_info['idx']] = k_rank

print("Step 4: Creating image from color ranks...")
img_array = np.empty((HEIGHT, WIDTH, 3), dtype=np.uint8) # HxWxRGB
total_pixels = WIDTH * HEIGHT

for iy_img in range(HEIGHT):
    if iy_img % (max(1, HEIGHT // 20)) == 0:
        print(f"  Generating image row {iy_img+1}/{HEIGHT}...")
    for ix_img in range(WIDTH):
        original_pixel_idx = iy_img * WIDTH + ix_img
        final_color_rank = pixel_ranks[original_pixel_idx]
        
        # Map final_color_rank (0 to 2^24-1) to unique R,G,B color
        r_byte = (final_color_rank >> 16) & 0xFF
        g_byte = (final_color_rank >> 8) & 0xFF
        b_byte = final_color_rank & 0xFF
        
        img_array[iy_img, ix_img, 0] = r_byte
        img_array[iy_img, ix_img, 1] = g_byte
        img_array[iy_img, ix_img, 2] = b_byte

final_image = Image.fromarray(img_array, 'RGB')
output_filename = "penrose_all_colors_4096.png"
final_image.save(output_filename)
print(f"Image saved as {output_filename}")

print("Done.")

CHALLENGE GAME FOR GEEKS #24

2025-06-20T10:29:09+02:00

Challenge n°24 : Minesweeper

The goal of Minesweeper is to find all the mines (squares), which you have to fill with black. You will finally get a complete picture.
Rules : each digit indicates the number of mines around it + including itself. The remaining are water, you can fill them with white.

Examples :

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

CHALLENGE GAME FOR GEEKS #23

2025-06-20T10:26:28+02:00

Challenge n°23 : Two objectives

Objective n°1 :
Find the double-words, hidden behind the transparent areas

Objective n°2 :
Reduce the image at 6.25 %, with a "pixelated method", in order to display another big hidden word

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

New custom gradient

2025-06-20T10:24:42+02:00

My very smooth new version !

You can compare with other users versions :

Wikipedia

Color Corners

All Colors

Juxtaposition of Blue Color Levels Square on Red-Green Color Levels Array

Rotated Checkerboard (Smoother variant of Color Corners)

256x256x256

Interline Dithered Gradient

The True Colours (Red Blocks)

The True Colours (Blue Spread)

Holes

Alternative versions (by interchanging RGB channels) :

CANVA transparency 2/2

2025-06-20T10:23:24+02:00

a great transparent workspace style

CANVA transparency 1/2

2025-06-20T10:21:17+02:00

a great transparent workspace style

ULTIMATE RGB GRADIENT 2/2

2025-06-19T12:03:09+02:00

Perfectly smoothing and dithering, with RGB colors selection.

+ 12 other variations (by interchanging RGB channels) : here

ULTIMATE RGB GRADIENT 1/2

2025-06-19T12:02:23+02:00

Perfectly smoothing and dithering, with RGB colors selection.

+ 12 other variations (by interchanging RGB channels) : here

RGB without B&W v2

2025-06-19T11:46:06+02:00

RGB average, without black and white
v1 : Full size
v2 : Small size

RGB without B&W v1

2025-06-19T11:43:56+02:00

RGB average, without black and white
v1 : Full size
v2 : Small size

Moreover, the colors are perfectly arranged by brightness intensity
Converted to 1-bit :

animated TRANSITION v2

2025-06-17T10:46:22+02:00

v1 : Fading transition by interlacing method

Each of 32 frames has got 16,777,216 unique colors

v2 : Fading transition by interlacing method

Each of 32 frames has got 16,777,216 unique colors

v3 : Real fading transition between two images

Each of 16 frames has got 16,777,216 unique colors

v4 : Transition by pixelation style, BIG squares

Each of 64 frames has got 16,777,216 unique colors

v5 : Transition by pixelation style, SMALL squares

Each of 64 frames has got 16,777,216 unique colors

v6 : Transition by sliding diaporama, between six images, exploring the 6 possible RGB channels

Each of 96 frames has got 16,777,216 unique colors

v7 : Transition by zooming allRGB logo

Each of 66 frames has got 16,777,216 unique colors

animated TRANSITION v1

2025-06-17T10:44:06+02:00

v1 : Fading transition by interlacing method

Each of 32 frames has got 16,777,216 unique colors

v2 : Fading transition by interlacing method

Each of 32 frames has got 16,777,216 unique colors

v3 : Real fading transition between two images

Each of 16 frames has got 16,777,216 unique colors

v4 : Transition by pixelation style, BIG squares

Each of 64 frames has got 16,777,216 unique colors

v5 : Transition by pixelation style, SMALL squares

Each of 64 frames has got 16,777,216 unique colors

v6 : Transition by sliding diaporama, between six images, exploring the 6 possible RGB channels

Each of 96 frames has got 16,777,216 unique colors

v7 : Transition by zooming allRGB logo

Each of 66 frames has got 16,777,216 unique colors

IMPOSSIBLE ROTATIONS ! (30°) v2

2025-06-16T10:51:53+02:00

v1 : with 3 RGB colors
v2 : with image

Everyone knows that it is impossible to rotate images without losing colors ! (except for right angles 90° / 180° / 270°)
However ... I performed 12 rotations of 30° degrees ! (animated at top-left )

- Each of 12 frames has got 16,777,216 unique colors
- Each of 12 squares has got 262,144 unique colors
- Each of 12 circles has got 205,607 unique colors

IMPOSSIBLE ROTATIONS ! (30°) v1

2025-06-16T10:50:52+02:00

v1 : with 3 RGB colors
v2 : with image

- Each of 12 frames has got 16,777,216 unique colors
- Each of 12 squares has got 262,144 unique colors
- Each of 12 circles has got 205,607 unique colors

Graph Distance

2025-06-15T12:39:48+02:00

Prompt:

Can you analyze the following study:

On the visualization of large-order graph distance matrices

Can you then write Python code that generates a 4,096 by 4,096 pixel image that represents what they're describing in the study, but using all 24-bit RGB colors exactly once.

Rendered with Google Colab.

Run to 2 colors

2025-06-15T11:58:28+02:00

HAIR - aliasing VS anti-aliasing

2025-06-14T22:25:36+02:00

Additive clear colors multi-levels 2/2

2025-06-14T19:27:31+02:00

Additive clear colors multi-levels 1/2

2025-06-14T19:23:57+02:00

Calabi–Yau Manifold

2025-06-14T15:03:40+02:00

Inspired by string theory. Made with Chatgpt and Google Colab.

PURE Additive RGB colors (v3)

2025-06-13T20:05:46+02:00

v1 : FAKE FALSE

v2 : REAL TRUE

v3 : REAL TRUE + PURE additive colors at the center
(My spent time record, several days of work !)

Negative version :

In the same collection :
Additive Palette
PURE COLORS
PURE RGB
PURE GRADIENT
TRANSPARENCY ! (ALL AROUND COLORS 3/3)
Additive RGB colors v1
Additive RGB colors v2
PURE Additive RGB colors (v3)
Additive clear colors multi-levels 1-2
Additive clear colors multi-levels 2-2

Additive RGB colors v2

2025-06-13T10:01:05+02:00

v1 : FAKE FALSE

v2 : REAL TRUE

v3 : REAL TRUE + PURE additive colors at the center
(My spent time record, several days of work !)

double Watermark

2025-06-13T09:54:50+02:00

Attempt of double watermarking, with allRGB logo :
- Foreground (La Joconde) : thin watermark
- Background : thick watermark (50%)

Source : La Gioconda

CHALLENGE GAME FOR GEEKS #22

2025-06-12T08:51:55+02:00

Challenge n°22 : QR CODE v2 (insane)
(v1 : here)

This entry contains 31684 different real QR-codes ! within 31684 different texts inside, but only one contains the winning message.

click here for help

Before being able to scan them, it is highly recommended to first convert :
- the 8,388,608 DARKEST pixels to BLACK
- the 8,388,608 LIGHEST pixels to WHITE
--> Same as CHALLENGE #15
--> Same as CHALLENGE #21

Example :

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

Plane 0

2025-06-11T23:55:30+02:00

The Unicode bmp (Basic Multilingual Plane), represented by gnu Unifont (see reference image). Created with Chatgpt and Google Colab.

#!/usr/bin/env python3
"""
Deterministically recolor 'unifont-16.0.04-acj.png' by:
1. (Optional) median‐filter smoothing of the B/W mask
2. Counting black & white pixels
3. Generating all 24-bit RGB colors, sorting by luminance
4. Taking the darkest N and lightest M colors (no randomization)
5. Sorting each pool by Morton (Z-order) code to group similar colors
6. Rebuilding the image and saving as 'allrgb-plane0.png'
Ignores unknown CLI args (e.g. Jupyter’s -f).
"""

import argparse
import sys
from PIL import Image, ImageFilter

def luminance(color):
    r, g, b = color
    return 0.2126 * r + 0.7152 * g + 0.0722 * b

def morton_code(color):
    """Interleave the 8 bits of R, G, B into a 24-bit Morton (Z-order) code."""
    r, g, b = color
    code = 0
    for bit in range(8):
        # take bit (7-bit) down to 0
        shift = 7 - bit
        code <<= 3
        code |= ((r >> shift) & 1) << 2 \
              | ((g >> shift) & 1) << 1 \
              | ((b >> shift) & 1)
    return code

def parse_args():
    p = argparse.ArgumentParser(
        description="Deterministic recolor of B/W image with Morton-ordering",
        add_help=False
    )
    p.add_argument(
        "--median-filter-size", "-m",
        type=int, default=1,
        help="Size of median filter to smooth B/W mask (1 = no filter)"
    )
    p.add_argument(
        "-h", "--help",
        action="help",
        help="Show this help message and exit"
    )
    # ignore unknown args
    args, _ = p.parse_known_args()
    return args

def main():
    args       = parse_args()
    input_path = "unifont-16.0.04-acj.png"
    output_fn  = "allrgb-plane0.png"

    # Load & B/W convert
    try:
        img = Image.open(input_path)
    except IOError as e:
        print(f"Error opening '{input_path}': {e}", file=sys.stderr)
        sys.exit(1)
    if img.mode != "L":
        img = img.convert("L")

    # Optional median‐filter
    if args.median_filter_size > 1:
        img = img.filter(ImageFilter.MedianFilter(size=args.median_filter_size))

    w, h   = img.size
    pix_bw = img.load()

    # Count black vs. white
    black_count = white_count = 0
    for y in range(h):
        for x in range(w):
            v = pix_bw[x, y]
            if   v ==   0: black_count += 1
            elif v == 255: white_count += 1
            else:
                raise ValueError(f"Non-B/W pixel {v} at {(x,y)}")

    # Generate & sort all 24-bit colors by luminance
    all_colors = [(r, g, b)
                  for r in range(256)
                  for g in range(256)
                  for b in range(256)]
    all_colors.sort(key=luminance)

    # Deterministic pools
    darkest   = all_colors[:black_count]
    lightest  = all_colors[-white_count:] if white_count else []

    # Morton-order each pool to group similar colors
    darkest.sort(key=morton_code)
    lightest.sort(key=morton_code)

    # Rebuild recolored RGB image
    out = Image.new("RGB", (w, h))
    di = iter(darkest)
    li = iter(lightest)

    for y in range(h):
        for x in range(w):
            if pix_bw[x, y] == 0:
                out.putpixel((x, y), next(di))
            else:
                out.putpixel((x, y), next(li))

    out.save(output_fn)
    print(f"Recolored image saved to '{output_fn}'")

if __name__ == "__main__":
    main()

orbit & TRANSPARENCY

2025-06-11T23:52:47+02:00

Same concept as "TRANSPARENCY ! (ALL AROUND COLORS 3/3)" but more complex.
Full and semi-transparency effects

Perhaps I would make an animated version ... one day

The Ruliad

2025-06-11T21:29:25+02:00

This image was inspired by the concept of the ruliad from The Wolfram Physics Project. Created with Chatgpt and Google Colab.

import numpy as np
from PIL import Image, ImageDraw, ImageFont
import networkx as nx
from itertools import product
import random

# --- Enhanced: Generate a 4096×4096 image using every 24-bit RGB color once,
#     with bold labels, a shuffled gray-looking background, and 75% transparent bg.

# --- 1. Build the graph ----------------------------------------

alphabet     = ['A', 'B']
two_letter   = [''.join(p) for p in product(alphabet, repeat=2)]
four_letter  = [''.join(p) for p in product(alphabet, repeat=4)]

G = nx.DiGraph()
G.add_nodes_from(four_letter)
for state in four_letter:
    for i in range(3):
        for tgt in two_letter:
            new_state = state[:i] + tgt + state[i+2:]
            G.add_edge(state, new_state)

from networkx.algorithms.dag import transitive_closure
TC = transitive_closure(G)

# --- 2. Layout -------------------------------------------------

W = H = 4096
pos = nx.circular_layout(TC, scale=min(W, H) * 0.4, center=(W/2, H/2))

# --- 3. Render shapes & text to masks -------------------------

mask_shape = Image.new('1', (W, H), 0)
draw_shape = ImageDraw.Draw(mask_shape)

mask_label = Image.new('1', (W, H), 0)
draw_label = ImageDraw.Draw(mask_label)

# edges
for u, v in TC.edges():
    x1, y1 = pos[u]
    x2, y2 = pos[v]
    draw_shape.line([(x1, y1), (x2, y2)], fill=1)

# nodes
r = 3
for _, (x, y) in pos.items():
    draw_shape.ellipse([x-r, y-r, x+r, y+r], fill=1)

# labels with DejaVuSansBold size 48
try:
    font = ImageFont.truetype("DejaVuSans-Bold.ttf", size=48)
except IOError:
    font = ImageFont.load_default()

for node, (x, y) in pos.items():
    txt = node
    tx, ty = x + r + 5, y - 24
    draw_label.text((tx, ty), txt, font=font, fill=1)

shape_mask = np.array(mask_shape, dtype=bool)
label_mask = np.array(mask_label, dtype=bool)
shape_only  = shape_mask & ~label_mask
bg_mask     = ~(shape_mask | label_mask)

N = W * H
shape_idx = np.flatnonzero(shape_only.ravel())
label_idx = np.flatnonzero(label_mask.ravel())
bg_idx    = np.flatnonzero(bg_mask.ravel())
assert len(shape_idx) + len(label_idx) + len(bg_idx) == N

# --- 4. Prepare color pools --------------------------

all_colors = np.arange(N, dtype=np.uint32)
r_ch = (all_colors >> 16) & 0xFF
g_ch = (all_colors >> 8)  & 0xFF
b_ch =  all_colors        & 0xFF

lum = 0.2126*r_ch + 0.7152*g_ch + 0.0722*b_ch
sorted_idx = np.argsort(lum)

n_shape = len(shape_idx)
n_label = len(label_idx)
# brightest for shapes
bright_pool = sorted_idx[-n_shape:]
# darkest for labels + background
dark_pool   = sorted_idx[: n_label + (N - n_shape - n_label)]
label_colors = dark_pool[:n_label]
bg_colors    = dark_pool[n_label:]

# shuffle background pool for uniform gray appearance
random.shuffle(bg_colors)

# --- 5. Assemble RGBA image ----------------------------

img_arr = np.zeros((H*W, 4), dtype=np.uint8)

def unpack(c):
    return ((c >> 16) & 0xFF, (c >> 8) & 0xFF, c & 0xFF)

# labels: darkest, fully opaque
for i, pix in enumerate(label_idx):
    r_, g_, b_ = unpack(label_colors[i])
    img_arr[pix] = (r_, g_, b_, 255)

# background: next darkest, 75% opacity
alpha_bg = int(0.75 * 255)
for i, pix in enumerate(bg_idx):
    r_, g_, b_ = unpack(bg_colors[i])
    img_arr[pix] = (r_, g_, b_, alpha_bg)

# shapes: brightest, fully opaque
for i, pix in enumerate(shape_idx):
    r_, g_, b_ = unpack(bright_pool[i])
    img_arr[pix] = (r_, g_, b_, 255)

# reshape & save
img_arr = img_arr.reshape((H, W, 4))
img = Image.fromarray(img_arr, 'RGBA')
img.save('reachability_color_graph_4096_v2.png')
print("Saved RGBA 4096×4096 image with every 24-bit RGB color once, bg at 75% opacity.")

TRANSPARENCY ! (ALL AROUND COLORS 3/3)

2025-06-11T20:14:32+02:00

The 8 standard colors grouped into 8 heptagons polygons

v.1/3 : The circles at foreground, the heptagons at background
v.2/3 : The circles at background, the heptagons at foreground
v.3/3 : All the additive colors, with great transparency appearance !

Moreover, the colors are perfectly arranged by brightness intensity
Converted to 1-bit :

ALL AROUND COLORS 2/3

2025-06-11T11:14:00+02:00

E8 v2

2025-06-11T09:48:33+02:00

This is an evolution of E8 v1. Made with Chatgpt and Google Colab.

import numpy as np
import colorsys
import math
import random
from itertools import product
from PIL import Image, ImageDraw, ImageFont

# === Configuration ===
SIZE         = 4096
TOTAL_PIXELS = SIZE * SIZE
TOTAL_COLORS = 2**24            # 16,777,216
ALPHA_BG     = int(255 * 0.25)  # 25% opacity (75% transparent)
ALPHA_FG     = 255              # fully opaque for shapes

# Dot radii per ring (inner → outer)
RADIUS_MAP = [10, 9, 8, 7, 6, 5, 4, 3]

# Simple roots for Coxeter element
simple_roots = np.array([
    [ 1,-1, 0, 0, 0, 0, 0, 0],
    [ 0, 1,-1, 0, 0, 0, 0, 0],
    [ 0, 0, 1,-1, 0, 0, 0, 0],
    [ 0, 0, 0, 1,-1, 0, 0, 0],
    [ 0, 0, 0, 0, 1,-1, 0, 0],
    [ 0, 0, 0, 0, 0, 1,-1, 0],
    [ 0, 0, 0, 0, 0, 0, 1,-1],
    [ .5,.5,.5,.5,.5,.5,.5,-.5]
], dtype=float)

# === 1) Build the 240 E8 roots ===
roots = []
for i in range(8):
    for j in range(i+1, 8):
        v = np.zeros(8)
        v[i], v[j] = 1, -1
        roots.extend([v.copy(), (-v).copy()])
        v[i], v[j] = 1,  1
        roots.extend([v.copy(), (-v).copy()])
for signs in product([1, -1], repeat=8):
    if np.prod(signs) == 1:
        roots.append(np.array(signs, float) * 0.5)
roots = np.vstack(roots)

# === 2) Compute Coxeter element ===
def reflect(alpha):
    α = alpha.reshape(8,1)
    return np.eye(8) - 2 * (α @ α.T) / (α.T @ α)
C = np.eye(8)
for α in simple_roots:
    C = reflect(α) @ C

# === 3) Petrie-plane basis from primitive eigenvector ===
h = 30
eigvals, eigvecs = np.linalg.eig(C)
target = np.exp(2j * np.pi / h)
idx    = np.argmin(np.abs(eigvals - target))
v      = eigvecs[:, idx]
B      = np.vstack([v.real, v.imag]).T  # (8,2)

# === 4) Project to pixel coordinates ===
proj     = roots @ B
margin   = 0.05 * SIZE
scale    = (SIZE/2 - margin) / np.max(np.linalg.norm(proj, axis=1))
coords_f = proj * scale + SIZE/2
coords   = np.round(coords_f).astype(int)

# === 5) Ring assignment ===
angles    = np.angle(proj[:,0] + 1j*proj[:,1]) % (2*np.pi)
exponents = np.array([1,7,11,13,17,19,23,29])
ideal     = (2*np.pi * exponents / h) % (2*np.pi)
ring_idx  = np.argmin(np.abs(angles.reshape(-1,1) - ideal), axis=1).astype(int)

# === 6) Reserve text label pixels first ===
used = np.zeros((SIZE, SIZE), bool)
font = ImageFont.truetype("DejaVuSans.ttf", 48)
label_fill, label_outline = [], []
for k, text in enumerate(["I","II","III","IV","V","VI","VII","VIII"]):
    pts = [coords[i] for i in range(240) if ring_idx[i]==k]
    cx, cy = np.round(np.mean(pts, axis=0)).astype(int)
    mask = Image.new("1", (SIZE, SIZE)); dmask = ImageDraw.Draw(mask)
    dmask.text((cx, cy), text, font=font, fill=1)
    arr = np.array(mask, bool)
    # outline via dilation
    pad = np.pad(arr, ((1,1),(1,1)), mode='constant', constant_values=False)
    dil = np.zeros_like(arr)
    for dy in (-1,0,1):
        for dx in (-1,0,1):
            if dx == 0 and dy == 0: continue
            dil |= pad[1+dy:1+dy+SIZE, 1+dx:1+dx+SIZE]
    out = dil & ~arr
    ys, xs = np.where(out)
    for y, x in zip(ys, xs):
        label_outline.append((x, y)); used[y, x] = True
    ys, xs = np.where(arr)
    for y, x in zip(ys, xs):
        label_fill.append((x, y)); used[y, x] = True

# === 7) Collect shape and background pixels ===
# 7a) Edges, Dots, Halos (same as before)...
# 7b) ...
# 7c) Boundaries – define mid_circle here so it is available
# Midpoint circle algorithm for ring outlines
def mid_circle(cx, cy, r):
    x, y, err = r, 0, 0
    pts = []
    while x >= y:
        for dx, dy in [( x, y),( y, x),(-y, x),(-x, y),(-x,-y),(-y,-x),( y,-x),( x,-y)]:
            pts.append((cx+dx, cy+dy))
        y += 1
        err += 1 + 2*y
        if 2*(err-x) + 1 > 0:
            x -= 1
            err += 1 - 2*x
    return pts

# Now collect shapes and background pixels
line_px, dot_px, halo_px, bound_px = [], [], [], []
# Edges

line_px, dot_px, halo_px, bound_px = [], [], [], []
# Edges
gram = roots @ roots.T
iu, ju = np.where(np.triu(np.isclose(gram, 1.0), k=1))
def bres(x0, y0, x1, y1):
    dx, sx = abs(x1-x0), (1 if x0 -dy: err -= dy; x0 += sx
        if e2 <  dx: err += dx; y0 += sy
    return pts
for i, j in zip(iu, ju):
    for x, y in bres(*coords[i], *coords[j]):
        if not used[y, x]: line_px.append((x, y)); used[y, x] = True
# Dots & halos
circle_off = {k: [(dx, dy)
                  for dy in range(-r, r+1)
                  for dx in range(-int(math.sqrt(r*r-dy*dy)), int(math.sqrt(r*r-dy*dy))+1)]
              for k, r in enumerate(RADIUS_MAP)}
for rid, (x0, y0) in enumerate(coords):
    k = ring_idx[rid]
    for dx, dy in circle_off[k]:
        x, y = x0+dx, y0+dy
        if not used[y, x]: dot_px.append((x, y)); used[y, x] = True
    R = RADIUS_MAP[k] + 1
    for dy in range(-R, R+1):
        dxm = int(math.sqrt(R*R - dy*dy))
        for dx in (-dxm, dxm):
            x, y = x0+dx, y0+dy
            if not used[y, x]: halo_px.append((x, y)); used[y, x] = True
# Boundaries
def mid_circle(cx, cy, r):
    x, y, err = r, 0, 0; pts = []
    while x >= y:
        for dx, dy in [( x, y),( y, x),(-y, x),(-x, y),(-x,-y),(-y,-x),( y,-x),( x,-y)]:
            pts.append((cx+dx, cy+dy))
        y += 1; err += 1 + 2*y
        if 2*(err-x) + 1 > 0: x -= 1; err += 1 - 2*x
    return pts
cx, cy = SIZE//2, SIZE//2
for k in range(8):
    rad = int(round(np.linalg.norm(proj[ring_idx==k], axis=1).mean()*scale))
    for x, y in mid_circle(cx, cy, rad):
        if not used[y, x]: bound_px.append((x, y)); used[y, x] = True
# Background
bg_px = [(x, y) for y in range(SIZE) for x in range(SIZE) if not used[y, x]]

# === 8) Palette slicing & ordering ===
idxs = np.arange(TOTAL_COLORS, dtype=np.uint32)
pal  = np.empty((TOTAL_COLORS, 3), dtype=np.uint8)
pal[:,0] = (idxs >> 16) & 0xFF; pal[:,1] = (idxs >> 8) & 0xFF; pal[:,2] = idxs & 0xFF
hsv = np.array([colorsys.rgb_to_hsv(*(c/255.0)) for c in pal])
v = hsv[:,2]; s = hsv[:,1]
# Label fill: brightest & saturated
fill_idx = np.lexsort((-s, -v))[:len(label_fill)]
# Label outline: darkest
outline_idx = np.argsort(v)[:len(label_outline)]
used_idx = set(fill_idx.tolist() + outline_idx.tolist())
# Remaining sorted for shapes by brightness+sat (bright start)
remaining = [i for i in np.lexsort((-s, -v)) if i not in used_idx]
i = 0
line_idx  = remaining[i:i+len(line_px)]; i += len(line_px)
halo_idx  = remaining[i:i+len(halo_px)]; i += len(halo_px)
dot_idx   = remaining[i:i+len(dot_px)]; i += len(dot_px)
bound_idx = remaining[i:i+len(bound_px)]; i += len(bound_px)
bg_idx    = remaining[i:i+len(bg_px)];    i += len(bg_px)
assert i == len(remaining)
# Extract colors
fill_cols    = pal[fill_idx]; outline_cols = pal[outline_idx]
line_cols    = pal[line_idx]; halo_cols    = pal[halo_idx]
dot_cols     = pal[dot_idx];  bound_cols   = pal[bound_idx]
bg_cols      = pal[bg_idx]
# Completely shuffle background noise-style
pair_bg = list(zip(bg_px, bg_cols)); random.shuffle(pair_bg)
bg_px, bg_cols = zip(*pair_bg)

# === 9) Render layer-by-layer ===
img = Image.new("RGBA", (SIZE, SIZE), (0,0,0,255)); px = img.load()
# 1) background (25% opaque)
for (x, y), (r, g, b) in zip(bg_px, bg_cols): px[x, y] = (r, g, b, ALPHA_BG)
# 2) boundaries
for (x, y), (r, g, b) in zip(bound_px, bound_cols): px[x, y] = (r, g, b, ALPHA_FG)
# 3) lines (bright)
for (x, y), (r, g, b) in zip(line_px, line_cols):   px[x, y] = (r, g, b, ALPHA_FG)
# 4) halos
for (x, y), (r, g, b) in zip(halo_px, halo_cols):   px[x, y] = (r, g, b, int(ALPHA_FG * 0.3))
# 5) dots
for (x, y), (r, g, b) in zip(dot_px, dot_cols):      px[x, y] = (r, g, b, ALPHA_FG)
# 6) label outline
for (x, y), (r, g, b) in zip(label_outline, outline_cols): px[x, y] = (r, g, b, ALPHA_FG)
# 7) label fill (topmost)
for (x, y), (r, g, b) in zip(label_fill, fill_cols):    px[x, y] = (r, g, b, ALPHA_FG)

# === 10) Save ===
img.save("E8_Petrie_exact24bit_final_4096.png")
print("✅ Done: background fully shuffled, labels unobstructed, bright lines, all colors used.")

ALL AROUND COLORS 1/3

2025-06-11T09:47:35+02:00

E8 v1

2025-06-10T17:16:03+02:00

Just like Surfer Dude, this image was inspired by Garrett Lisi’s An Exceptionally Simple Theory of Everything. This one represents an E8 Petrie projection. The Python source was written with Chatgpt, and executed in Google Colab.

import numpy as np
import colorsys
import math
from itertools import product
from PIL import Image

# === Configuration ===
SIZE       = 4096
RADIUS     = 6     # dot radius in pixels
ALPHA_BG   = 128   # 50% opacity for background
ALPHA_FG   = 255   # fully opaque for lines & dots
TOTAL_PIXELS = SIZE * SIZE
TOTAL_COLORS = 2**24  # 16,777,216

# === 1) Generate the 240 E₈ roots in ℝ⁸ ===
roots = []

# A-type: ±e_i ± e_j
for i in range(8):
    for j in range(i+1, 8):
        v = np.zeros(8, dtype=float)
        v[i], v[j] =  1, -1
        roots.append(v.copy());    roots.append((-v).copy())
        v[i], v[j] =  1,  1
        roots.append(v.copy());    roots.append((-v).copy())

# B-type: (±½,…,±½) with product(signs) = +1
for signs in product([1, -1], repeat=8):
    if np.prod(signs) == 1:
        roots.append(np.array(signs, dtype=float) * 0.5)

roots = np.vstack(roots)  # shape (240,8)

# === 2) Project into 2D via PCA/SVD ===
roots_centered = roots - roots.mean(axis=0)
U, S, Vh = np.linalg.svd(roots_centered, full_matrices=False)
proj2d = roots_centered @ Vh.T[:, :2]  # (240,2)

# === 3) Scale & translate into pixel coordinates ===
marg = 0.05 * SIZE
scale = (SIZE/2 - marg) / np.max(np.linalg.norm(proj2d, axis=1))
coords_f = proj2d * scale + SIZE/2  # floats
coords = np.round(coords_f).astype(int)

# === 4) Find all edges (⟨α,β⟩ = 1) ===
gram = roots @ roots.T
i_u, j_u = np.where(np.triu(np.isclose(gram, 1.0), k=1))
edges = list(zip(i_u.tolist(), j_u.tolist()))

# === 5) Bresenham line algorithm ===
def bresenham(x0, y0, x1, y1):
    dx = abs(x1 - x0); sx = 1 if x0 < x1 else -1
    dy = abs(y1 - y0); sy = 1 if y0 < y1 else -1
    err = dx - dy
    pixels = []
    while True:
        pixels.append((x0, y0))
        if x0 == x1 and y0 == y1:
            break
        e2 = 2 * err
        if e2 > -dy:
            err -= dy
            x0 += sx
        if e2 < dx:
            err += dx
            y0 += sy
    return pixels

# === 6) Generate circle mask offsets for dots ===
circle_offsets = []
for dy in range(-RADIUS, RADIUS + 1):
    dx_max = int(math.floor(math.sqrt(RADIUS*RADIUS - dy*dy)))
    for dx in range(-dx_max, dx_max + 1):
        circle_offsets.append((dx, dy))

# === 7) Collect pixel coordinates for lines & dots ===
used = np.zeros((SIZE, SIZE), dtype=bool)
line_pixels = []
for i, j in edges:
    x0, y0 = coords[i]; x1, y1 = coords[j]
    for (x, y) in bresenham(x0, y0, x1, y1):
        if not used[y, x]:
            line_pixels.append((x, y))
            used[y, x] = True

dot_pixels = []
for x0, y0 in coords:
    for dx, dy in circle_offsets:
        x, y = x0 + dx, y0 + dy
        if 0 <= x < SIZE and 0 <= y < SIZE and not used[y, x]:
            dot_pixels.append((x, y))
            used[y, x] = True

N_line = len(line_pixels)
N_dot  = len(dot_pixels)
N_bg   = TOTAL_PIXELS - N_line - N_dot

assert N_bg + N_line + N_dot == TOTAL_PIXELS, "Pixel count mismatch!"

# === 8) Build & sort full 24-bit palette by HSV (v, s descending) ===
# Create array of shape (16_777_216, 3)
palette = np.empty((TOTAL_COLORS, 3), dtype=np.uint8)
idxs = np.arange(TOTAL_COLORS, dtype=np.uint32)
palette[:, 0] = (idxs >> 16) & 0xFF
palette[:, 1] = (idxs >>  8) & 0xFF
palette[:, 2] = (idxs      ) & 0xFF

# Convert to HSV
# scaled to [0,1] floats
rgb_norm = palette.astype(float) / 255.0
hsv = np.array([colorsys.rgb_to_hsv(*c) for c in rgb_norm])
v = hsv[:, 2]
s = hsv[:, 1]

# Sort so brightest & most saturated first:
order = np.lexsort((-(s), -(v)))
sorted_palette = palette[order]

# === 9) Assign colors to lines, dots, and background ===
line_colors = sorted_palette[:N_line]
dot_colors  = sorted_palette[N_line:N_line+N_dot]
bg_colors   = sorted_palette[N_line+N_dot:]

# === 10) Create RGBA image and paint ===
img = Image.new("RGBA", (SIZE, SIZE))
pixels = img.load()

# Paint lines
for (x, y), (r, g, b) in zip(line_pixels, line_colors):
    pixels[x, y] = (int(r), int(g), int(b), ALPHA_FG)

# Paint dots
for (x, y), (r, g, b) in zip(dot_pixels, dot_colors):
    pixels[x, y] = (int(r), int(g), int(b), ALPHA_FG)

# Paint background
bg_iter = iter(bg_colors)
for y in range(SIZE):
    for x in range(SIZE):
        if not used[y, x]:
            r, g, b = next(bg_iter)
            pixels[x, y] = (int(r), int(g), int(b), ALPHA_BG)

# === 11) Save PNG ===
img.save("E8_Petrie_exact24bit_4096.png")
print("✅ Generated 4096×4096 E₈ Petrie projection using every 24-bit RGB color exactly once.")

dark colors VS clear colors

2025-06-10T13:31:52+02:00

Same concept as "FULL COLOR IMAGE QR CODE", but without overlays.
However, for "FULL COLOR IMAGE QR CODE", I did not use "black & white" colors, on purpose.

LEFT : colors among the 8,388,608 DARKEST pixels
RIGHT : colors among the 8,388,608 LIGHEST pixels

Converted to 1-bit :

FULL COLOR IMAGE QR CODE

2025-06-09T23:56:09+02:00

The first allRGB full color QR CODE, within a full image inside !
Just scan it to get the link

Made by puting :
Instead of white : colors among the 8,388,608 LIGHEST pixels
Instead of black : colors among the 8,388,608 DARKEST pixels

So if you convert it to a 1-bit image, you will get :

In order to isolate the dark/black in QR code, we can also split it to TSL channels (L channel) or to CMYK channels (K channel)

+ 6 other variations (by interchanging RGB channels) : here

CHALLENGE GAME FOR GEEKS #21

2025-06-09T11:44:53+02:00

Challenge n°21 : QR CODE v1

This huge QR-CODE does not contain any link ! It contains a 4096x4096 colored image.

click here for help

Before being able to scan it, it is highly recommended to first convert :
- the 8,388,608 DARKEST pixels to BLACK
- the 8,388,608 LIGHEST pixels to WHITE
--> Same as CHALLENGE #15

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

Periodic System v3

2025-06-07T12:10:13+02:00

This is an evolution of Periodic System v1 and Periodic System v2, and they’re all based on another project of mine called Periodic System. This version bumps the number of elements up to 1024, and orders them in outward spiral. It also attempts to apply relevant colors to heavier element based on the chemical series they would be assumed to fall under, even though it is unlikely these elements could ever exist, at least under normal conditions.

import numpy as np
from PIL import Image, ImageDraw, ImageFont
import colorsys
from collections import defaultdict
from scipy.ndimage import binary_dilation
import random

# === Constants ===
WIDTH, HEIGHT = 4096, 4096
TOTAL_COLORS = WIDTH * HEIGHT
ELEMENT_COUNT = 1024
GRID_COLS = 32
GRID_ROWS = (ELEMENT_COUNT + GRID_COLS - 1) // GRID_COLS
CELL_W = WIDTH // GRID_COLS
CELL_H = HEIGHT // GRID_ROWS
TEXT_MARGIN = 4

# === Fonts ===
font_small = ImageFont.truetype("DejaVuSans-Bold.ttf", 12)
font_regular = ImageFont.truetype("DejaVuSans-Bold.ttf", 16)
font_bold = ImageFont.truetype("DejaVuSans-Bold.ttf", 32)

# === Known data ===
ELEMENT_SYMBOLS = [  # Z=1 to 118
    "H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne",
    "Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca",
    "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn",
    "Ga", "Ge", "As", "Se", "Br", "Kr", "Rb", "Sr", "Y", "Zr",
    "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn",
    "Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Ce", "Pr", "Nd",
    "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb",
    "Lu", "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg",
    "Tl", "Pb", "Bi", "Po", "At", "Rn", "Fr", "Ra", "Ac", "Th",
    "Pa", "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm",
    "Md", "No", "Lr", "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Ds",
    "Rg", "Cn", "Nh", "Fl", "Mc", "Lv", "Ts", "Og"
]

ELEMENT_NAMES = [  # Z=1 to 118
    "Hydrogen", "Helium", "Lithium", "Beryllium", "Boron", "Carbon", "Nitrogen", "Oxygen", "Fluorine", "Neon",
    "Sodium", "Magnesium", "Aluminium", "Silicon", "Phosphorus", "Sulfur", "Chlorine", "Argon", "Potassium", "Calcium",
    "Scandium", "Titanium", "Vanadium", "Chromium", "Manganese", "Iron", "Cobalt", "Nickel", "Copper", "Zinc",
    "Gallium", "Germanium", "Arsenic", "Selenium", "Bromine", "Krypton", "Rubidium", "Strontium", "Yttrium", "Zirconium",
    "Niobium", "Molybdenum", "Technetium", "Ruthenium", "Rhodium", "Palladium", "Silver", "Cadmium", "Indium", "Tin",
    "Antimony", "Tellurium", "Iodine", "Xenon", "Caesium", "Barium", "Lanthanum", "Cerium", "Praseodymium", "Neodymium",
    "Promethium", "Samarium", "Europium", "Gadolinium", "Terbium", "Dysprosium", "Holmium", "Erbium", "Thulium", "Ytterbium",
    "Lutetium", "Hafnium", "Tantalum", "Tungsten", "Rhenium", "Osmium", "Iridium", "Platinum", "Gold", "Mercury",
    "Thallium", "Lead", "Bismuth", "Polonium", "Astatine", "Radon", "Francium", "Radium", "Actinium", "Thorium",
    "Protactinium", "Uranium", "Neptunium", "Plutonium", "Americium", "Curium", "Berkelium", "Californium", "Einsteinium", "Fermium",
    "Mendelevium", "Nobelium", "Lawrencium", "Rutherfordium", "Dubnium", "Seaborgium", "Bohrium", "Hassium", "Meitnerium", "Darmstadtium",
    "Roentgenium", "Copernicium", "Nihonium", "Flerovium", "Moscovium", "Livermorium", "Tennessine", "Oganesson"
]

def generate_symbol(n):
    if n <= 118: return ELEMENT_SYMBOLS[n - 1]
    roots = ['n','u','b','t','q','p','h','s','o','e']
    return ''.join(roots[int(d)] for d in str(n)).capitalize()[:3]

def generate_name(n):
    if n <= 118: return ELEMENT_NAMES[n - 1]
    roots = ['nil','un','bi','tri','quad','pent','hex','sept','oct','enn']
    digits = [int(d) for d in str(n)]
    parts = [roots[d] for d in digits]
    if parts[-1] in ('bi', 'tri'):
        parts[-1] = parts[-1][:-1]
    for i in range(len(parts) - 1):
        if parts[i] == 'enn' and parts[i + 1] == 'nil':
            parts[i] = 'en'
    return ''.join(parts).capitalize() + "ium"

def generate_weight(n): return f"[{n:.1f}]"

def classify_element(n):
    if n == 1: return "nonmetal"
    if n in [2,10,18,36,54,86,118]: return "noble_gas"
    if n in [5,14,32,33,51,52,84]: return "metalloid"
    if n in [9,17,35,53,85,117]: return "halogen"
    if n in [6,7,8,15,16,34]: return "nonmetal"
    if n in [3,11,19,37,55,87,119]: return "alkali"
    if n in [4,12,20,38,56,88,120]: return "alkaline"
    if 57 <= n <= 71: return "lanthanide"
    if 89 <= n <= 103: return "actinide"
    if 104 <= n <= 112 or (21 <= n <= 30) or (39 <= n <= 48) or (72 <= n <= 80): return "transition"
    if (13 <= n <= 16) or (31 <= n <= 34) or (49 <= n <= 52) or (81 <= n <= 84): return "post_transition"
    if 121 <= n <= 138: return "actinide"
    if 139 <= n <= 152: return "transition"
    if 153 <= n <= 172: return "post_transition"
    if 173 <= n <= 200: return "noble_gas" if n % 18 == 2 else "halogen"
    if n > 200: return "unknown"
    return "unknown"

# === Spiral grid generator ===
def generate_spiral_grid(cols, rows):
    grid = [[-1] * cols for _ in range(rows)]
    cx, cy = cols // 2, rows // 2
    x, y = cx, cy
    dx = [1, 0, -1, 0]
    dy = [0, 1, 0, -1]
    steps = 1
    dir_idx = 0
    count = 1
    while count <= cols * rows:
        for _ in range(2):
            for _ in range(steps):
                if 0 <= x < cols and 0 <= y < rows:
                    grid[y][x] = count
                    count += 1
                    if count > cols * rows:
                        return grid
                x += dx[dir_idx]
                y += dy[dir_idx]
            dir_idx = (dir_idx + 1) % 4
        steps += 1
    return grid

spiral_grid = generate_spiral_grid(GRID_COLS, GRID_ROWS)
position_by_element = {}
for y in range(GRID_ROWS):
    for x in range(GRID_COLS):
        n = spiral_grid[y][x]
        if n != -1 and n <= ELEMENT_COUNT:
            position_by_element[n] = (x, y)

# === Reserve layout ===
image_array = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)
used_pixels = np.zeros((HEIGHT, WIDTH), dtype=bool)
label_coords, outline_coords, border_coords = [], [], []
cell_fill_coords = defaultdict(list)
series_element_ids = defaultdict(list)

for n in range(1, ELEMENT_COUNT + 1):
    col, row = position_by_element[n]
    x0, y0 = col * CELL_W, row * CELL_H
    lines = [
        (str(n), font_regular),
        (generate_symbol(n), font_bold),
        (generate_weight(n), font_regular),
        (generate_name(n), font_small)
    ]
    y_cursor = y0 + TEXT_MARGIN
    for text, font in lines:
        mask = Image.new("1", (CELL_W, CELL_H), 0)
        draw = ImageDraw.Draw(mask)
        draw.text((TEXT_MARGIN, 0), text, font=font, fill=1)
        arr = np.array(mask)
        outline = binary_dilation(arr) & ~arr
        for dy in range(arr.shape[0]):
            for dx in range(arr.shape[1]):
                px, py = x0 + dx, y_cursor + dy
                if 0 <= px < WIDTH and 0 <= py < HEIGHT:
                    if arr[dy, dx]:
                        label_coords.append((py, px))
                        used_pixels[py, px] = True
                    elif outline[dy, dx]:
                        outline_coords.append((py, px))
                        used_pixels[py, px] = True
        y_cursor += font.size + 4

    for x in range(x0, x0 + CELL_W):
        for y in (y0, y0 + CELL_H - 1):
            if not used_pixels[y, x]:
                border_coords.append((y, x))
                used_pixels[y, x] = True
    for y in range(y0 + 1, y0 + CELL_H - 1):
        for x in (x0, x0 + CELL_W - 1):
            if not used_pixels[y, x]:
                border_coords.append((y, x))
                used_pixels[y, x] = True

    series = classify_element(n)
    series_element_ids[series].append(n)
    for y in range(y0, y0 + CELL_H):
        for x in range(x0, x0 + CELL_W):
            if not used_pixels[y, x]:
                cell_fill_coords[n].append((y, x))
                used_pixels[y, x] = True

# === Color allocation ===
all_colors = np.array([[r, g, b] for r in range(256)
                                 for g in range(256)
                                 for b in range(256)], dtype=np.uint8)

def brightness(rgb): return 0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]
def rgb_to_hsv(rgb): return colorsys.rgb_to_hsv(rgb[0]/255, rgb[1]/255, rgb[2]/255)

sorted_by_brightness = sorted(all_colors.tolist(), key=brightness)
label_colors = sorted_by_brightness[:len(label_coords)]
outline_colors = sorted_by_brightness[-len(outline_coords):]
border_colors = sorted_by_brightness[len(label_colors):-len(outline_coords)][:len(border_coords)]

used_colors = set(tuple(c) for c in label_colors + outline_colors + border_colors)
for (py, px), c in zip(label_coords, label_colors):     image_array[py, px] = c
for (py, px), c in zip(outline_coords, outline_colors): image_array[py, px] = c
for (py, px), c in zip(border_coords, border_colors):   image_array[py, px] = c

remaining_colors = [tuple(c) for c in all_colors.tolist() if tuple(c) not in used_colors]
remaining_sorted = sorted(remaining_colors, key=lambda c: (-rgb_to_hsv(c)[1], rgb_to_hsv(c)[0], brightness(c)))

series_hue_ranges = {
    'transition': (0.00, 0.10), 'noble_gas': (0.50, 0.60), 'halogen': (0.30, 0.40),
    'alkali': (0.90, 1.00), 'alkaline': (0.10, 0.20), 'lanthanide': (0.55, 0.65),
    'actinide': (0.65, 0.75), 'post_transition': (0.20, 0.30), 'metalloid': (0.75, 0.85),
    'nonmetal': (0.05, 0.10)
}

series_rgb_pool = defaultdict(list)
unassigned_pool = []
for c in remaining_sorted:
    h, s, _ = rgb_to_hsv(c)
    for sname, (hmin, hmax) in series_hue_ranges.items():
        if hmin <= h <= hmax:
            series_rgb_pool[sname].append(c)
            break
    else:
        unassigned_pool.append(c)

used_known_colors = set()
for series, ids in series_element_ids.items():
    if series in series_hue_ranges:
        coords = sum((cell_fill_coords[n] for n in ids), [])
        needed = len(coords)
        pool = series_rgb_pool[series]
        if len(pool) < needed:
            pool += unassigned_pool[:needed - len(pool)]
            unassigned_pool = unassigned_pool[needed - len(pool):]
        random.shuffle(pool)
        for (y, x), c in zip(coords, pool[:needed]):
            image_array[y, x] = c
            used_known_colors.add(c)

remaining_pool = [c for c in remaining_sorted if c not in used_known_colors and c not in used_colors]
cursor = 0
for n in series_element_ids.get("unknown", []):
    coords = cell_fill_coords[n]
    chunk = remaining_pool[cursor:cursor + len(coords)]
    cursor += len(coords)
    random.shuffle(chunk)
    for (y, x), c in zip(coords, chunk):
        image_array[y, x] = c

used_pixel_count = np.count_nonzero(np.any(image_array != 0, axis=2))
print(f"\n? Total used pixels: {used_pixel_count} / {TOTAL_COLORS}")
Image.fromarray(image_array, 'RGB').save("periodic_table_allrgb_spiral.png")
print("✅ Saved as periodic_table_allrgb_spiral.png")

CHALLENGE GAME FOR GEEKS #20

2025-06-07T10:33:48+02:00

Challenge n°20 : TREASURE QUEST v1

The goal is to find the exact location of the treasure inside the photo ! which is one pixel, one color.
2 clues :
RxGxB=796544
It is yellow

WHISHING YOU FORTUNE ! ;-)

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

Potato Corner Stall (Located In The Philippines)

2025-06-07T10:33:29+02:00

This is such a very amazing glorious artwork. Speaking of which, I do live in the Philippines. (10)

tutti frutti - converted

2025-06-07T10:26:45+02:00

I enjoyed to convert "tutti frutti" to "Spectrum analysis" style

If people are interested for I convert any image (with tiles, pieces, parts) to this style, just ask : samuel35allrgb@outlook.com

In the same collection :
Spectrum analysis
MUSIC v1
Absorption Spectra v2 - converted

Donald J. Trump

2025-06-07T10:24:51+02:00

"Thanks for the support, ACJ! I cannot believe it worked! However, I did ran into errors and issues, too. I tried more patience until I get the point through." -Xave Mercado
Reminder note: Any AI Software isn't always accurate as it should be 100% of the time.
But anyways, I did use Google Colab and ChatGPT 4o mini again to try my best to generate an image of ACJ's similar detail. I asked every detail step-by-step. This is the very first time I successfully want to let everyone see my new outputed artwork that I downloaded to my files then it DID uploaded to AllRGB. I love this website!
FYI, why is Donald J. Trump the 45th AND 47th president of the United States?
I also think what this supporter of AllRGB believes is true. Make sure to support and stay tuned for more exciting 16,777,216 color pixels in images, and entries! (9)

Absorption Spectra v2 - converted

2025-06-07T10:24:42+02:00

I enjoyed to convert "Absorption Spectra v2" to "Spectrum analysis" style

If people are interested for I convert any image (with tiles, pieces, parts) to this style, just ask : samuel35allrgb@outlook.com

In the same collection :
Spectrum analysis
MUSIC v1
tutti frutti - converted

MUSIC v1

2025-06-06T10:08:48+02:00

256 images by 256x256
Each of 256 frames has got 65,536 unique colors
Total = 16,777,216 unique colors

Perhaps A.I. can generate real music from this ?!

In the same collection :
Spectrum analysis
Absorption Spectra v2 - converted
tutti frutti - converted

CHALLENGE GAME FOR GEEKS #19

2025-06-05T12:06:59+02:00

Challenge n°19 : Insane interlaced

HARD level ... For an easier level try CHALLENGE #16

This entry contains 256 images interlaced together
The goal is to split them

HELP :
On each image (256), a foreground watermark has been placed exactly here :

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

GLOWING FLASHLIGHT (perfect dithering)

2025-06-04T16:52:49+02:00

GLOWING
LIGHT
FLASHLIGHT
HEADLIGHT
HEADLAMP
LIGHTHOUSE

Perfect uniform dithering (no circle, no spiral, no scramble) excepted last row & last column

+ 48 other variations : here

Color wheels fun

2025-06-03T08:57:28+02:00

Plenty of color-wheels-like ... just for fun !

For a full true color real wheel, see :
INSIDE COLORS ! v1
INSIDE COLORS ! v2

🏳️‍🌈 v1

2025-06-03T00:18:40+02:00

Perhaps the most inclusive pride flag ever, as it contains all 16,777,216 rgb colors (exactly once). Made with Google ai Studio and Google Colab.

import numpy as np
from PIL import Image, ImageDraw
import time
import gc

# --- Configuration ---
WIDTH = 4096
HEIGHT = 4096
TOTAL_PIXELS = WIDTH * HEIGHT

if TOTAL_PIXELS != 2**24:
    raise ValueError(f"WIDTH x HEIGHT ({WIDTH}x{HEIGHT}={TOTAL_PIXELS}) must be 2^24 ({2**24})")

# --- Region Definitions (Target Colors and Labels) ---
REGION_DEFINITIONS = [
    # Chevron (Labels 0-4)
    ("Black",      (0, 0, 0),        0),
    ("Brown",      (96, 51, 22),     1), # Slightly richer brown: (102, 60, 36)
    ("Light Blue", (91, 206, 250),   2),
    ("Pink",       (241, 188, 232),  3),
    ("White",      (255, 255, 255),  4), # Innermost triangle
    # Main Stripes (Labels 5-10)
    ("Red",        (228, 3, 3),      5),
    ("Orange",     (255, 140, 0),    6),
    ("Yellow",     (255, 237, 0),    7),
    ("Green",      (0, 128, 38),     8),
    ("Blue",       (30, 90, 255),    9),
    ("Purple",     (118, 40, 160),   10),
]
NUM_REGIONS = len(REGION_DEFINITIONS)
TARGET_COLORS_RGB_ORDERED = [region[1] for region in REGION_DEFINITIONS]


def generate_all_rgb_colors_shuffled():
    print(f"Generating and shuffling all {TOTAL_PIXELS} colors...")
    s = time.time()
    color_indices = np.arange(TOTAL_PIXELS, dtype=np.uint32)

    r = np.right_shift(color_indices, 16) & 0xFF
    g = np.right_shift(color_indices, 8) & 0xFF
    b = color_indices & 0xFF
    all_colors = np.stack((r, g, b), axis=-1).astype(np.uint8)

    # Crucial step: Shuffle the colors
    np.random.shuffle(all_colors)
    print(f"Generated and shuffled all colors in {time.time() - s:.2f} seconds.")
    return all_colors

def create_label_image():
    print("Creating label image for flag regions...")
    s = time.time()
    label_img_pil = Image.new('L', (WIDTH, HEIGHT), 0) # 'L' mode for 8-bit pixels
    draw = ImageDraw.Draw(label_img_pil)

    # --- Main 6 Stripes ---
    # Labels 5 (Red) to 10 (Purple)
    stripe_height = HEIGHT // 6
    for i in range(6):
        y_start = i * stripe_height
        y_end = (i + 1) * stripe_height if i < 5 else HEIGHT # Ensure last stripe fills to bottom
        region_label = REGION_DEFINITIONS[5+i][2] # Get label ID (5 to 10)
        draw.rectangle([0, y_start, WIDTH, y_end], fill=region_label)

    # --- Chevron ---
    # Point of the chevron
    X_TIP = int(WIDTH * 0.38)  # How far the chevron extends into the flag
    Y_TIP = HEIGHT // 2

    # Thickness of each chevron band at the hoist (left edge)
    # These are not actual "thicknesses" but define the y-coordinates of the base of each triangle
    # We define 5 triangles, Black being the largest, White the smallest.
    # They share a common tip (X_TIP, Y_TIP).
    # Their bases are on the left edge (x=0), or slightly offset for visual appeal.

    # We define 5 layers for the chevron. Layer 0 is Black, Layer 4 is White.
    # Each layer k is a triangle. We draw Black first, then Brown on top, etc.
    # The base of triangle k (for Black, Brown, ..., White) starts at x_base_k
    # and extends from y_top_k to y_bottom_k.
    
    # Let's define the triangles from outermost (Black) to innermost (White)
    # The x-coordinates of the bases of the triangles.
    # Black triangle base is at x=0. White triangle base is most indented.
    # Let base_x_coords define the x-position of the *vertical line* forming the base of each triangle.
    # For simplicity, let all chevron triangle bases be at x=0, and their y-extents define their "thickness"
    
    num_chevron_bands = 5 # Black, Brown, LBlue, Pink, White
    
    # These values control the "spread" of the chevron bands at the hoist edge (x=0)
    # And how much "thinner" each inner band gets relative to the outer one.
    # `offsets_from_border` defines how far from (0,0) and (0,H) the base points of each triangle are.
    # Black (k=0): base points (0,0) and (0,H). Triangle: (0,0)-(X_TIP,Y_TIP)-(0,H-1)
    # Brown (k=1): base points (0, Y_OFFSET_1) and (0, H-Y_OFFSET_1). Triangle: (0,Y_OFFSET_1)-(X_TIP,Y_TIP)-(0,H-1-Y_OFFSET_1)
    # ...
    # White (k=4)
    
    # y_offsets defines the y-coordinate for the top point of the base and (H - y_offset) for bottom point.
    # A simple linear spacing for the y_offsets of the triangle bases at x=0
    y_offsets = np.linspace(0, HEIGHT * 0.18, num_chevron_bands).astype(int) # Fine-tune 0.18 for thickness

    for k in range(num_chevron_bands): # 0=Black, 1=Brown, ..., 4=White
        region_label = REGION_DEFINITIONS[k][2] # Get label ID (0 to 4)
        
        y_top_base = y_offsets[k]
        y_bottom_base = HEIGHT - 1 - y_offsets[k]
        
        # Define the polygon for the current chevron triangle layer
        # (Base Point 1), (Tip), (Base Point 2)
        polygon_points = [
            (0, y_top_base),
            (X_TIP, Y_TIP),
            (0, y_bottom_base)
        ]
        draw.polygon(polygon_points, fill=region_label)

    label_image_np = np.array(label_img_pil, dtype=np.uint8)
    print(f"Created label image in {time.time() - s:.2f}s.")

    # # Optional: Save label image for debugging
    # label_img_pil.save("debug_label_image.png")
    # unique_labels, counts = np.unique(label_image_np, return_counts=True)
    # print("Label counts:")
    # for label, count in zip(unique_labels, counts):
    #     region_name = [r[0] for r in REGION_DEFINITIONS if r[2] == label][0]
    #     print(f"  Label {label} ({region_name}): {count} pixels")
    # if np.sum(counts) != TOTAL_PIXELS:
    #    print(f"WARNING: Total pixels in labels ({np.sum(counts)}) != TOTAL_PIXELS ({TOTAL_PIXELS})")

    return label_image_np


def color_distance_sq(color_array_int32, target_color_np_int32):
    diff = color_array_int32 - target_color_np_int32
    return np.sum(diff**2, axis=1)

def create_flag_image_geometric(all_colors_shuffled, label_image):
    final_image_array = np.empty((HEIGHT, WIDTH, 3), dtype=np.uint8)
    current_color_idx = 0

    # Verify total pixels in label map matches expected
    total_labeled_pixels = 0
    pixel_counts_per_region = []
    for i in range(NUM_REGIONS):
        count = np.sum(label_image == i)
        pixel_counts_per_region.append(count)
        total_labeled_pixels += count
    
    if total_labeled_pixels != TOTAL_PIXELS:
        print(f"ERROR: Mismatch in pixel counts. Label map has {total_labeled_pixels}, expected {TOTAL_PIXELS}")
        # Distribute shortfall/excess (this is a hack, ideally label map is perfect)
        diff = TOTAL_PIXELS - total_labeled_pixels
        # Add/subtract from the largest region (e.g., first main stripe, Red, Label 5)
        # Find index of label 5 in REGION_DEFINITIONS to map to pixel_counts_per_region
        label_to_adjust = 5 
        pixel_counts_per_region[label_to_adjust] += diff
        print(f"Adjusted pixel count for region with label {label_to_adjust} by {diff}")
        if np.sum(pixel_counts_per_region) != TOTAL_PIXELS:
             raise ValueError("Pixel count adjustment failed.")


    for i in range(NUM_REGIONS):
        region_name, target_color_rgb, region_label = REGION_DEFINITIONS[i]
        target_color_np_int32 = np.array(target_color_rgb, dtype=np.int32)
        
        num_pixels_in_region = pixel_counts_per_region[region_label] # Use pre-calculated counts

        if num_pixels_in_region == 0:
            print(f"Skipping Region {region_label} ({region_name}): 0 pixels.")
            continue
            
        print(f"\nProcessing Region {region_label} ({region_name}): Target {target_color_rgb}, Pixels {num_pixels_in_region}")

        s_chunk = time.time()
        colors_for_this_region = all_colors_shuffled[current_color_idx : current_color_idx + num_pixels_in_region]
        # print(f"  Extracted {len(colors_for_this_region)} colors in {time.time() - s_chunk:.2f}s.")
        
        s_sort = time.time()
        colors_for_this_region_int32 = colors_for_this_region.astype(np.int32)
        distances = color_distance_sq(colors_for_this_region_int32, target_color_np_int32)
        sorted_indices = np.argsort(distances)
        sorted_colors_for_region = colors_for_this_region[sorted_indices]
        # print(f"  Sorted colors in {time.time() - s_sort:.2f}s.")

        s_fill = time.time()
        # Get coordinates for the current region
        # Important: The order of pixels returned by np.where matters for how sorted colors are placed.
        # This will create a gradient/texture within the region.
        region_pixels_y, region_pixels_x = np.where(label_image == region_label)
        
        if len(region_pixels_y) != num_pixels_in_region:
            print(f"  WARNING: Mismatch! np.where found {len(region_pixels_y)} pixels for label {region_label}, expected {num_pixels_in_region}.")
            # This can happen if the adjustment logic for pixel counts is triggered and np.where is not re-run
            # For now, we proceed but the image might have uncolored pixels or color reuse if counts differ.
            # A robust solution would be to ensure label_image perfectly matches TOTAL_PIXELS.
            # Or, if counts differ, take min(len(region_pixels_y), num_pixels_in_region) for assignment.
            # However, this would violate the "all colors once" if num_pixels_in_region is smaller,
            # or leave gaps if num_pixels_in_region is larger.
            # The current setup *should* ensure counts match if label image generation is correct.
            # The hacky adjustment is the main risk here.
            
        final_image_array[region_pixels_y, region_pixels_x] = sorted_colors_for_region
        # print(f"  Filled image data in {time.time() - s_fill:.2f}s.")
        
        current_color_idx += num_pixels_in_region
        
        del colors_for_this_region, colors_for_this_region_int32, distances, sorted_indices, sorted_colors_for_region
        del region_pixels_y, region_pixels_x
        gc.collect()

    if current_color_idx != TOTAL_PIXELS:
        print(f"WARNING: Processed {current_color_idx} colors, but expected {TOTAL_PIXELS}.")

    return final_image_array

if __name__ == "__main__":
    overall_start_time = time.time()

    all_rgb_colors_shuffled = generate_all_rgb_colors_shuffled()
    label_map = create_label_image()
    
    # Verify sum of pixels in label_map regions
    unique_labels, counts = np.unique(label_map, return_counts=True)
    print("\nPixel counts per label from generated label_map:")
    sum_label_pixels = 0
    for label_val, count_val in zip(unique_labels, counts):
        region_name = [r[0] for r in REGION_DEFINITIONS if r[2] == label_val][0]
        print(f"  Label {label_val} ({region_name}): {count_val} pixels")
        sum_label_pixels += count_val
    
    if sum_label_pixels != TOTAL_PIXELS:
        print(f"CRITICAL WARNING: Total pixels in label map ({sum_label_pixels}) does not match TOTAL_PIXELS ({TOTAL_PIXELS}).")
        print("This will lead to errors in color allocation or image generation.")
        print("The create_label_image() function needs to ensure all pixels are assigned a label exactly once.")
        # For now, the code attempts to adjust, but this is a symptom of an issue in label generation.
    else:
        print(f"Label map total pixels: {sum_label_pixels}. Matches TOTAL_PIXELS.")


    final_image_array = create_flag_image_geometric(all_rgb_colors_shuffled, label_map)
    
    s_save = time.time()
    print("\nSaving image...")
    img = Image.fromarray(final_image_array, 'RGB')
    img.save("inclusive_pride_all_colors_geometric.png")
    print(f"Image saved as inclusive_pride_all_colors_geometric.png in {time.time() - s_save:.2f}s.")

    total_time = time.time() - overall_start_time
    print(f"\nTotal execution time: {total_time:.2f} seconds.")

Reverse engineering 1

2025-06-02T09:59:03+02:00

I challenged myself ...
Recover the 11 images of this entry :

AIlien

2025-06-01T23:36:15+02:00

I asked Google Gemini 2.5 Pro Preview 05-06 to write Python code that generates an image that contains all 24-bit rgb colors exactly once and looks alien to humans, and then executed it in Google Colab.

import numpy as np
from PIL import Image
from tqdm import tqdm # For progress bar: pip install tqdm
import random

# Image dimensions
WIDTH = 4096
HEIGHT = 4096
NUM_PIXELS = WIDTH * HEIGHT # This is 2^24

# LCG parameters for full period over M = 2^24
# M = 2**24 (implicitly handled by uint32 wrapping for A*i+C)
A = np.uint32(1664525)
C = np.uint32(1013904223)

# --- "Alien" Bit Permutation Setup ---
# We need to choose 12 bit positions (0-23) for x and 12 for y.
# Let's make it reproducible but non-trivial.
# We'll shuffle all 24 bit indices and take the first 12 for x, next 12 for y.
# Using a fixed seed for reproducibility of the "alien" pattern.
rng = random.Random(42) # Alien seed
all_bit_indices = list(range(24))
rng.shuffle(all_bit_indices)

x_source_bit_indices = np.array(all_bit_indices[:12], dtype=np.int32)
y_source_bit_indices = np.array(all_bit_indices[12:], dtype=np.int32)

# Sanity check (optional)
# combined_indices = sorted(list(x_source_bit_indices) + list(y_source_bit_indices))
# assert combined_indices == list(range(24)), "Bit indices are not a permutation!"
# print(f"X bits sourced from original bit positions: {x_source_bit_indices}")
# print(f"Y bits sourced from original bit positions: {y_source_bit_indices}")

# Create an empty image array
# Using uint8 for R, G, B channels
image_array = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)

print(f"Generating {WIDTH}x{HEIGHT} image with {NUM_PIXELS} unique colors...")
print("This will take a while...")

# Iterate through all 2^24 possible color values
# color_val_i will be the 24-bit color itself
for color_val_i_long in tqdm(range(NUM_PIXELS), desc="Assigning colors"):
    color_val_i = np.uint32(color_val_i_long) # Ensure it's uint32 for LCG

    # 1. Determine RGB components from color_val_i
    r = (color_val_i >> 16) & 0xFF
    g = (color_val_i >> 8) & 0xFF
    b = color_val_i & 0xFF

    # 2. Calculate the "shuffled" index using LCG
    # This shuffled_val determines *where* the current color_val_i goes.
    # The LCG ensures that `shuffled_val` will also visit every number
    # from 0 to 2^24-1 exactly once as `color_val_i` does.
    # Note: (A * color_val_i + C) will naturally wrap around in uint32
    # arithmetic, effectively doing the modulo 2^32. We only care about the lower 24 bits.
    shuffled_val = (A * color_val_i + C) & 0xFFFFFF # Keep only lower 24 bits

    # 3. Derive x and y coordinates from shuffled_val using bit permutation
    x_coord = 0
    for target_bit_idx in range(12): # 12 bits for x-coordinate (0-4095)
        source_bit_pos = x_source_bit_indices[target_bit_idx]
        if (shuffled_val >> source_bit_pos) & 1:
            x_coord |= (1 << target_bit_idx)

    y_coord = 0
    for target_bit_idx in range(12): # 12 bits for y-coordinate (0-4095)
        source_bit_pos = y_source_bit_indices[target_bit_idx]
        if (shuffled_val >> source_bit_pos) & 1:
            y_coord |= (1 << target_bit_idx)
            
    # Ensure coordinates are within bounds (should be, due to 12 bits each)
    # x_coord = x_coord % WIDTH
    # y_coord = y_coord % HEIGHT

    # 4. Assign the color to the calculated (x, y) pixel
    # Important: Check if pixel is already set (for debugging, should not happen with correct LCG)
    # if np.any(image_array[y_coord, x_coord] != 0) and not (y_coord == 0 and x_coord == 0 and color_val_i != some_first_val_for_0_0):
    #    print(f"Collision at ({x_coord}, {y_coord}) for color_val {color_val_i}")
    #    print(f"Existing color: {image_array[y_coord, x_coord]}")
    #    # This indicates a problem with the LCG or bit permutation not being bijective.
    #    # For this setup, it should be bijective.
    
    image_array[y_coord, x_coord] = (r, g, b)


print("Image generation complete. Saving...")
# Create a PIL Image from the NumPy array
image = Image.fromarray(image_array, 'RGB')
image.save("alien_all_colors_4096.png")
print("Image saved as alien_all_colors_4096.png")

# Verification (optional, very slow for 4096x4096)
# print("Verifying all colors used exactly once (this can be very slow)...")
# if WIDTH*HEIGHT <= 2**20: # Only for smaller test images
#     seen_colors = set()
#     for r_val in range(HEIGHT):
#         for c_val in range(WIDTH):
#             color_tuple = tuple(image_array[r_val, c_val])
#             if color_tuple in seen_colors:
#                 print(f"Error: Color {color_tuple} seen more than once!")
#                 exit()
#             seen_colors.add(color_tuple)
#     if len(seen_colors) == NUM_PIXELS:
#         print("Verification successful: All colors unique and all pixels filled.")
#     else:
#         print(f"Verification failed: Expected {NUM_PIXELS} unique colors, found {len(seen_colors)}")
# else:
#     print("Skipping full verification due to large image size.")

INSIDE COLORS ! An animated double-cone explorer - v2

2025-06-01T17:16:22+02:00

v2 of INSIDE COLORS ! - v1

- Improvement by adding a grayscale background color which matches with the current luminance exploration

- Improvement of the viewpoint direction 👁 (more comprehensive), exploring inside the whole double-cone (HSL colorspace)
From luminance 100% to 0%, with 3 seconds pause at 50% which matches with the full color wheel :

Each of 33 frames has got 16,777,216 unique colors

Absorption Spectra v2

2025-06-01T12:49:10+02:00

Improved version of Absorption Spectra v1 Made with help from Chatgpt and Google Colab. Here are the Python script and sample output:

#!/usr/bin/env python3
"""
generate_spectra_with_labels.py

Generate a 4096×4096-pixel image of the absorption spectra for elements Z=1–128,
laid out in 4 columns × 32 rows, using every 24-bit RGB color exactly once.

Modifications:
1. Rainbow-style background for known-spectrum tiles goes from purple→red (hue rotated +60°).
2. 1-pixel “white” border around each tile and 2-pixel “white” border around the entire image,
   all drawn with the lightest available colors.
3. Each tile displays the chemical name (DejaVuSans, 32 px, no anti-aliasing) at its top-left,
   positioned 2 px from outer & tile borders, using the next-lightest available colors.
   Labels are drawn by masking, not textboxes, so no clipping or anti-aliasing.
4. The IUPAC systematic names are used for Z > 118.

- Absorption lines from NIST (380–780 nm) use the darkest colors (excluding borders & labels).
- Known-spectrum background: smooth rotated-hue gradient (violet→red) right-to-left.
- Unknown-spectrum background: flat gray.
- Every 24-bit RGB color is used exactly once, including borders and labels.

Dependencies:
    pip install astroquery astropy pillow numpy pandas
"""
import numpy as np
from PIL import Image, ImageFont
from astroquery.nist import Nist
from astropy import units as u
import pandas as pd

# --- 1. Image geometry ---
tile_w, tile_h = 1024, 128
ncols, nrows = 4, 32
width, height = tile_w * ncols, tile_h * nrows  # 4096 × 4096
total_pixels = width * height
print(f"Total pixels: {total_pixels}")

# Precompute flat indices, x/y coords, and tile IDs
indices = np.arange(total_pixels, dtype=np.int64)
y = indices // width
x = indices % width
tile_row = y // tile_h
tile_col = x // tile_w
tile_id = tile_row * ncols + tile_col + 1  # 1-based tile IDs

# --- 2. Element names Z=1..128 ---
element_names = [
    # Z=1–10
    "Hydrogen","Helium","Lithium","Beryllium","Boron",
    "Carbon","Nitrogen","Oxygen","Fluorine","Neon",
    # Z=11–20
    "Sodium","Magnesium","Aluminum","Silicon","Phosphorus",
    "Sulfur","Chlorine","Argon","Potassium","Calcium",
    # Z=21–30
    "Scandium","Titanium","Vanadium","Chromium","Manganese",
    "Iron","Cobalt","Nickel","Copper","Zinc",
    # Z=31–40
    "Gallium","Germanium","Arsenic","Selenium","Bromine",
    "Krypton","Rubidium","Strontium","Yttrium","Zirconium",
    # Z=41–50
    "Niobium","Molybdenum","Technetium","Ruthenium","Rhodium",
    "Palladium","Silver","Cadmium","Indium","Tin",
    # Z=51–60
    "Antimony","Tellurium","Iodine","Xenon","Cesium",
    "Barium","Lanthanum","Cerium","Praseodymium","Neodymium",
    # Z=61–70
    "Promethium","Samarium","Europium","Gadolinium","Terbium",
    "Dysprosium","Holmium","Erbium","Thulium","Ytterbium",
    # Z=71–80
    "Lutetium","Hafnium","Tantalum","Tungsten","Rhenium",
    "Osmium","Iridium","Platinum","Gold","Mercury",
    # Z=81–90
    "Thallium","Lead","Bismuth","Polonium","Astatine",
    "Radon","Francium","Radium","Actinium","Thorium",
    # Z=91–100
    "Protactinium","Uranium","Neptunium","Plutonium","Americium",
    "Curium","Berkelium","Californium","Einsteinium","Fermium",
    # Z=101–110
    "Mendelevium","Nobelium","Lawrencium","Rutherfordium","Dubnium",
    "Seaborgium","Bohrium","Hassium","Meitnerium","Darmstadtium",
    # Z=111–118
    "Roentgenium","Copernicium","Nihonium","Flerovium","Moscovium",
    "Livermorium","Tennessine","Oganesson",
    # Z=119–128 (IUPAC systematic temporary names)
    "Ununennium","Unbinilium","Unbiunium","Unbibium","Unbitrium",
    "Unbiquadium","Unbipentium","Unbihexium","Unbiseptium","Unbioctium"
]
assert len(element_names) == 128

# --- 3. Build border masks ---
# Outer border: 2 px wide at each edge
outer_mask = (x < 2) | (x >= width - 2) | (y < 2) | (y >= height - 2)

# Tile border: 1 px frame around each tile’s 1024×128 block
x_tile = x % tile_w
y_tile = y % tile_h
tile_border_mask = (
    (x_tile == 0) | (x_tile == tile_w - 1)
    | (y_tile == 0) | (y_tile == tile_h - 1)
)

# Combined border mask
border_mask = outer_mask | tile_border_mask
B_border = int(border_mask.sum())
print(f"Total border pixels (2px outer + 1px/tile): {B_border}")

# --- 4. Fetch NIST spectral lines (380–780 nm) for Z=1–118 ---
element_symbols = [
    'H','He','Li','Be','B','C','N','O','F','Ne',
    'Na','Mg','Al','Si','P','S','Cl','Ar','K','Ca',
    'Sc','Ti','V','Cr','Mn','Fe','Co','Ni','Cu','Zn',
    'Ga','Ge','As','Se','Br','Kr','Rb','Sr','Y','Zr',
    'Nb','Mo','Tc','Ru','Rh','Pd','Ag','Cd','In','Sn',
    'Sb','Te','I','Xe','Cs','Ba','La','Ce','Pr','Nd',
    'Pm','Sm','Eu','Gd','Tb','Dy','Ho','Er','Tm','Yb',
    'Lu','Hf','Ta','W','Re','Os','Ir','Pt','Au','Hg',
    'Tl','Pb','Bi','Po','At','Rn','Fr','Ra','Ac','Th',
    'Pa','U','Np','Pu','Am','Cm','Bk','Cf','Es','Fm',
    'Md','No','Lr','Rf','Db','Sg','Bh','Hs','Mt','Ds',
    'Rg','Cn','Nh','Fl','Mc','Lv','Ts','Og'
]
spectral_lines = {}
nist = Nist()
for Z, sym in enumerate(element_symbols, start=1):
    try:
        table = nist.query(380 * u.nm, 780 * u.nm, linename=sym)
        df = table.to_pandas() if table is not None else pd.DataFrame()
        if 'Observed' in df.columns:
            col = df['Observed']
        elif 'Ritz' in df.columns:
            col = df['Ritz']
        elif 'Wavelength' in df.columns:
            col = df['Wavelength']
        else:
            spectral_lines[Z] = []
            continue
        vals = pd.to_numeric(col, errors='coerce').dropna().astype(float)
        # Convert Å→nm if entries exceed 1000
        if len(vals) and vals.max() > 1000:
            vals /= 10.0
        spectral_lines[Z] = [w for w in vals if 380 <= w <= 780]
    except Exception as e:
        print(f"Warning Z={Z} ({sym}) fetch error: {e}")
        spectral_lines[Z] = []

known_ids = [Z for Z in range(1, 129) if spectral_lines.get(Z)]
unknown_ids = [Z for Z in range(1, 129) if Z not in known_ids]
print(f"Known spectra: {len(known_ids)}, Unknown: {len(unknown_ids)}")

# --- 5. Build label mask and list of label pixel indices ---
# Load DejaVuSans at 32 px (no anti-aliasing)
font = ImageFont.truetype("DejaVuSans.ttf", 32)

label_mask = np.zeros((total_pixels,), dtype=bool)
label_pixels_list = []

for Z in range(1, 129):
    name = element_names[Z - 1]
    mask = font.getmask(name, mode="1")
    w_text, h_text = mask.size  # getmask size returns (width, height)
    mask_arr = np.array(mask).reshape((h_text, w_text))  # 0 or 255

    # Position at 6 px from outer & tile borders: (x0 + 6, y0 + 6)
    r, c = divmod(Z - 1, ncols)
    y0, x0 = r * tile_h, c * tile_w
    for ty in range(h_text):
        for tx in range(w_text):
            if mask_arr[ty, tx]:  # pixel belongs to glyph
                global_x = x0 + 6 + tx
                global_y = y0 + 6 + ty
                pix_idx = global_y * width + global_x
                label_pixels_list.append(pix_idx)

label_flat = np.unique(np.array(label_pixels_list, dtype=np.int64))
B_labels = int(label_flat.size)
print(f"Total label pixels: {B_labels}")

label_mask[label_flat] = True

# --- 6. Identify raw absorption-line pixels (pre-filter) ---
raw_line_pixels = []
for Z in known_ids:
    r, c = divmod(Z - 1, ncols)
    y0, x0 = r * tile_h, c * tile_w
    for wl in spectral_lines[Z]:
        xi = x0 + int((wl - 380) / 400 * (tile_w - 1))
        ys = np.arange(y0, y0 + tile_h)
        raw_line_pixels.extend((ys * width + xi).tolist())

raw_line_flat = np.unique(np.array(raw_line_pixels, dtype=np.int64))
# Exclude any that fall on a border or a label
keep_line_mask = (~border_mask[raw_line_flat]) & (~label_mask[raw_line_flat])
line_flat = raw_line_flat[keep_line_mask]
M = int(line_flat.size)
print(f"Absorption-line pixels (excluding borders/labels): {M}")

# --- 7. Background masks (excluding borders, labels, and lines) ---
occupied = border_mask.copy()
occupied[line_flat] = True
occupied[label_flat] = True

mask_unk_bg = (~occupied) & np.isin(tile_id, unknown_ids)
G_count = int(mask_unk_bg.sum())

mask_known_bg = (~occupied) & np.isin(tile_id, known_ids)
R_count = int(mask_known_bg.sum())

assert (M + G_count + R_count + B_border + B_labels) == total_pixels, (
    f"Counts mismatch: M={M}, G={G_count}, R={R_count}, B_border={B_border}, "
    f"B_labels={B_labels}, sum={M+G_count+R_count+B_border+B_labels}, total={total_pixels}"
)
print(f"Counts → Lines: {M}, Gray bg: {G_count}, Rainbow bg: {R_count}, "
      f"Border: {B_border}, Labels: {B_labels}")

# --- 8. Sort all 24-bit colors by brightness ---
colors = np.arange(total_pixels, dtype=np.uint32)
R_vals = (colors >> 16) & 0xFF
G_vals = (colors >> 8) & 0xFF
B_vals = colors & 0xFF

brightness = 0.299 * R_vals + 0.587 * G_vals + 0.114 * B_vals
sorted_idx = np.argsort(brightness)  # darkest → lightest

# Reserve lightest B_border colors for borders
border_pool = sorted_idx[-B_border:]
remaining_after_border = sorted_idx[: total_pixels - B_border]

# Reserve next-lightest B_labels colors for labels
label_pool = remaining_after_border[-B_labels:]
remaining_after_border_labels = remaining_after_border[: total_pixels - B_border - B_labels]

# Next M darkest → absorption lines
line_pool = remaining_after_border_labels[:M]
remaining_after_lines = remaining_after_border_labels[M:]

# Build grayness metric for the rest (for flat gray background)
rem_R = (remaining_after_lines >> 16) & 0xFF
rem_G = (remaining_after_lines >> 8) & 0xFF
rem_B = remaining_after_lines & 0xFF
grayness = (
    np.abs(rem_R - rem_G).astype(np.int32)
    + np.abs(rem_G - rem_B).astype(np.int32)
    + np.abs(rem_R - rem_B).astype(np.int32)
)
g_idx = np.argsort(grayness)[:G_count]
gray_pool = remaining_after_lines[g_idx]

# The remainder → rainbow background
rainbow_pool = np.delete(remaining_after_lines, g_idx)
print(f"Pools sizes → Lines: {len(line_pool)}, Gray: {len(gray_pool)}, "
      f"Rainbow: {len(rainbow_pool)}, Border: {len(border_pool)}, Labels: {len(label_pool)}")

# --- 9. Hue-based sorting for rainbow_pool with +60° rotation ---
R3 = R_vals[rainbow_pool] / 255.0
G3 = G_vals[rainbow_pool] / 255.0
B3 = B_vals[rainbow_pool] / 255.0

maxc = np.maximum.reduce([R3, G3, B3])
minc = np.minimum.reduce([R3, G3, B3])
diff = maxc - minc

hue = np.zeros_like(maxc)
maskv = diff > 1e-6
rm = maskv & (maxc == R3)
gm = maskv & (maxc == G3)
bm = maskv & (maxc == B3)

hue[rm] = (60 * ((G3[rm] - B3[rm]) / diff[rm]) + 360) % 360
hue[gm] = (60 * ((B3[gm] - R3[gm]) / diff[gm]) + 120) % 360
hue[bm] = (60 * ((R3[bm] - G3[bm]) / diff[bm]) + 240) % 360

# Rotate by +60° → shift from violet→red
hue_rot = (hue + 60.0) % 360.0
hue_rot_norm = hue_rot / 360.0

hue_order = np.argsort(hue_rot_norm)
rainbow_sorted = rainbow_pool[hue_order]

# --- 10. Assemble final image ---
img_flat = np.zeros((total_pixels, 3), dtype=np.uint8)

# 10a. Draw borders (lightest colors)
border_positions = np.where(border_mask)[0]
border_positions.sort()
for i, pix in enumerate(border_positions):
    c = border_pool[i]
    img_flat[pix] = [(c >> 16) & 0xFF, (c >> 8) & 0xFF, c & 0xFF]

# 10b. Draw labels (next-lightest colors)
label_positions = label_flat.copy()
label_positions.sort()
for i, pix in enumerate(label_positions):
    c = label_pool[i]
    img_flat[pix] = [(c >> 16) & 0xFF, (c >> 8) & 0xFF, c & 0xFF]

# 10c. Draw absorption lines (darkest M colors)
line_positions = line_flat.copy()
line_positions.sort()
for i, pix in enumerate(line_positions):
    c = line_pool[i]
    img_flat[pix] = [(c >> 16) & 0xFF, (c >> 8) & 0xFF, c & 0xFF]

# 10d. Draw flat gray background for unknown-spectrum tiles
unk_positions = np.where(mask_unk_bg)[0]
unk_positions.sort()
for i, pix in enumerate(unk_positions):
    c = gray_pool[i]
    img_flat[pix] = [(c >> 16) & 0xFF, (c >> 8) & 0xFF, c & 0xFF]

# 10e. Draw rainbow background for known-spectrum tiles (right→left gradient)
k = len(known_ids)
n = len(rainbow_sorted)

# Compute per-element count of background pixels
tile_positions = {}
for idx, Z in enumerate(known_ids):
    count = int(np.count_nonzero(mask_known_bg & (tile_id == Z)))
    pos = (np.arange(count) * k + idx) % n
    tile_positions[Z] = pos.tolist()

# Resolve any duplicates among the hue indices
all_pos = np.concatenate([tile_positions[Z] for Z in known_ids])
unique_pos, counts = np.unique(all_pos, return_counts=True)
missing = list(set(np.arange(n)) - set(unique_pos))

def resolve_dupes(tile_positions_dict, counts_map, missing_list):
    for Z in known_ids:
        lst = tile_positions_dict[Z]
        for i, p in enumerate(lst):
            if counts_map[p] > 1 and missing_list:
                newp = missing_list.pop()
                counts_map[p] -= 1
                counts_map[newp] = 1
                lst[i] = newp
        if not missing_list:
            break

counts_map = {p: c for p, c in zip(unique_pos, counts)}
resolve_dupes(tile_positions, counts_map, missing)

# Assign actual rainbow colors per tile
for idx, Z in enumerate(known_ids):
    pos = np.array(tile_positions[Z], dtype=np.int64)
    cols = rainbow_sorted[pos]
    local_h = hue_rot_norm[hue_order][pos]
    grad_idx = np.argsort(local_h)
    cols_sorted = cols[grad_idx]
    cols_sorted = cols_sorted[::-1]  # reverse for right→left

    mask_k = mask_known_bg & (tile_id == Z)
    idxs = np.where(mask_k)[0]
    order_x = np.argsort(idxs % width)
    for j, pix in enumerate(idxs[order_x]):
        c = cols_sorted[j]
        img_flat[pix] = [(c >> 16) & 0xFF, (c >> 8) & 0xFF, c & 0xFF]

# --- 11. Save output ---
print("Saving image with labels and borders…")
img = Image.fromarray(img_flat.reshape((height, width, 3)), mode='RGB')
img.save('absorption_spectra_with_labels.png')
print("Done. Output file: absorption_spectra_with_labels.png")

Total pixels: 16777216
Total border pixels (2px outer + 1px/tile): 310636
Warning Z=85 (At) fetch error: Result did not contain a table
Warning Z=100 (Fm) fetch error: Result did not contain a table
Warning Z=101 (Md) fetch error: Result did not contain a table
Warning Z=102 (No) fetch error: Result did not contain a table
Warning Z=103 (Lr) fetch error: Result did not contain a table
Warning Z=104 (Rf) fetch error: Result did not contain a table
Warning Z=105 (Db) fetch error: Result did not contain a table
Warning Z=106 (Sg) fetch error: Result did not contain a table
Warning Z=107 (Bh) fetch error: Result did not contain a table
Warning Z=108 (Hs) fetch error: Result did not contain a table
Warning Z=109 (Mt) fetch error: Result did not contain a table
Warning Z=110 (Ds) fetch error: Result did not contain a table
Warning Z=111 (Rg) fetch error: Result did not contain a table
Warning Z=112 (Cn) fetch error: Result did not contain a table
Warning Z=113 (Nh) fetch error: Result did not contain a table
Warning Z=114 (Fl) fetch error: Result did not contain a table
Warning Z=115 (Mc) fetch error: Result did not contain a table
Warning Z=116 (Lv) fetch error: Result did not contain a table
Warning Z=117 (Ts) fetch error: Result did not contain a table
Warning Z=118 (Og) fetch error: Result did not contain a table
Known spectra: 98, Unknown: 30
Total label pixels: 136729
Absorption-line pixels (excluding borders/labels): 3054128
Counts → Lines: 3054128, Gray bg: 3818243, Rainbow bg: 9457480, Border: 310636, Labels: 136729
Pools sizes → Lines: 3054128, Gray: 3818243, Rainbow: 9457480, Border: 310636, Labels: 136729
Saving image with labels and borders…
Done. Output file: absorption_spectra_with_labels.png

INSIDE COLORS ! An animated double-cone explorer - v1

2025-06-01T10:32:04+02:00

v1 version
v2 --> here

Each of 32 frames has got 16,777,216 unique colors

First frame at top-left (delay 3 seconds) :
A perfect custom color wheel (no dithering !) with unique colors
π = 3.1415
Area of the circle = π*100*100 = 31415
= 31415 pixels
= 31415 unique colors
Luminance = 50%

REAL SIZE (downloadable) :

32 frames :
HSL colorspace model
Exploring inside the whole double-cone 👁 (viewpoint) :
16 frames : luminance 0%-->50%
16 frames : luminance 50%-->100%
+loop

Cosmic Microwave Background v1

2025-05-30T12:31:28+02:00

All 24-bit rgb colors mapped to actual Planck cmb temperature data. Made using Chatgpt and Google Colab.

#!/usr/bin/env python3
"""
plot_cmb_map.py

Downloads the Planck 2018 SMICA CMB temperature map (nosz version) from IRSA,
reads it with Astropy + Healpy, projects it, and produces a 4096×4096 PNG
using every 24-bit RGB color exactly once—mapping pixel intensities
by sorting the full RGB spectrum by luminance to create a meaningful heat
scale and assigning colors by rank order of CMB temperature.
The projected map (~2048×4096) is resampled (each row repeated) to
exactly fill a square 4096×4096 canvas before color mapping.
"""

import os
import requests
from astropy.io import fits
import healpy as hp
import numpy as np
from PIL import Image

# IRSA URL for the SMICA “nosz” full-mission CMB map
URL = (
    "https://irsa.ipac.caltech.edu/data/Planck/release_3/"
    "all-sky-maps/maps/component-maps/cmb/"
    "COM_CMB_IQU-smica-nosz_2048_R3.00_full.fits"
)
FILENAME = os.path.basename(URL)
OUTFILE = "cmb_rgb_4096.png"


def download_map(url: str, filename: str) -> None:
    """Download the FITS file if not present."""
    if not os.path.exists(filename):
        r = requests.get(url, stream=True)
        r.raise_for_status()
        with open(filename, "wb") as f:
            for chunk in r.iter_content(4096):
                f.write(chunk)


def read_cmb_map(filename: str):
    """Read I_STOKES from the FITS file."""
    with fits.open(filename, memmap=True) as hdul:
        return hdul[1].data["I_STOKES"]


def project_map(cmb_data, xsize=4096):
    """Project CMB data to a plate carrée array (~2048×xsize)."""
    return hp.cartview(
        cmb_data,
        return_projected_map=True,
        xsize=xsize,
        cbar=False,
        title=None,
        notext=True
    )


def resample_to_square(proj):
    """Resample projected map by repeating each row to reach square shape."""
    h, w = proj.shape
    # Compute repeat factor (should be integer, here 2)
    factor = w // h
    return np.repeat(proj, factor, axis=0)


def map_to_rgb(proj_square):
    """
    Map resampled data to every 24-bit RGB color exactly once.
    Flatten the data, rank-order by temperature,
    generate all RGB triplets sorted by luminance,
    and assign each pixel a unique color.
    """
    h, w = proj_square.shape
    N = h * w
    flat = proj_square.ravel()
    order = np.argsort(flat)

    idx = np.arange(N, dtype=np.uint32)
    r = (idx >> 16) & 0xFF
    g = (idx >> 8) & 0xFF
    b = idx & 0xFF
    lum = 0.2126 * r + 0.7152 * g + 0.0722 * b
    color_order = np.argsort(lum)

    rgb_flat = np.empty((N, 3), dtype=np.uint8)
    colors = np.stack((r, g, b), axis=1)[color_order]
    rgb_flat[order] = colors

    return rgb_flat.reshape((h, w, 3))


def save_image(rgb_img, output: str = OUTFILE):
    """Save the RGB image at exact resolution."""
    img = Image.fromarray(rgb_img, mode='RGB')
    img.save(output)


def main():
    download_map(URL, FILENAME)
    cmb = read_cmb_map(FILENAME)
    proj = project_map(cmb, xsize=4096)
    proj_sq = resample_to_square(proj)
    rgb = map_to_rgb(proj_sq)
    save_image(rgb)
    print(f"Saved RGB image: {OUTFILE} (4096×4096, full 24-bit palette)")


if __name__ == "__main__":
    main()

Absorption Spectra v1

2025-05-30T10:48:44+02:00

Absorption spectra for the chemical elements 1 - 128, using actual nist data. The spectral colors are approximate; feel free to try and improve on that. Made with help from Chatgpt and Google Colab.

#!/usr/bin/env python3
"""
generate_spectra.py

Generate a 4096×4096-pixel image of the absorption spectra for elements Z=1–128,\
laid out in 4 columns × 32 rows, using every 24-bit RGB color exactly once.

- Absorption lines from NIST (380–780 nm) are drawn with the darkest colors.
- Background for known-spectrum tiles is a smooth gradient ordered from violet→blue→green→yellow→orange→red, applied individually, right-to-left.
- Background for unknown-spectrum tiles (no NIST data) is flat gray.

Dependencies:
    pip install astroquery astropy pillow numpy pandas
"""
import numpy as np
from PIL import Image
from astroquery.nist import Nist
from astropy import units as u
import pandas as pd

# --- 1. Setup ---
tile_w, tile_h = 1024, 128
ncols, nrows = 4, 32
width, height = tile_w * ncols, tile_h * nrows
total_pixels = width * height
print(f"Total pixels: {total_pixels}")

# Atomic symbols Z=1–118
element_symbols = [
    'H','He','Li','Be','B','C','N','O','F','Ne',
    'Na','Mg','Al','Si','P','S','Cl','Ar','K','Ca',
    'Sc','Ti','V','Cr','Mn','Fe','Co','Ni','Cu','Zn',
    'Ga','Ge','As','Se','Br','Kr','Rb','Sr','Y','Zr',
    'Nb','Mo','Tc','Ru','Rh','Pd','Ag','Cd','In','Sn',
    'Sb','Te','I','Xe','Cs','Ba','La','Ce','Pr','Nd',
    'Pm','Sm','Eu','Gd','Tb','Dy','Ho','Er','Tm','Yb',
    'Lu','Hf','Ta','W','Re','Os','Ir','Pt','Au','Hg',
    'Tl','Pb','Bi','Po','At','Rn','Fr','Ra','Ac','Th',
    'Pa','U','Np','Pu','Am','Cm','Bk','Cf','Es','Fm',
    'Md','No','Lr','Rf','Db','Sg','Bh','Hs','Mt','Ds',
    'Rg','Cn','Nh','Fl','Mc','Lv','Ts','Og'
]

# --- 2. Fetch NIST spectral lines ---
spectral_lines = {}
nist = Nist()
for Z, sym in enumerate(element_symbols, start=1):
    try:
        table = nist.query(380*u.nm, 780*u.nm, linename=sym)
        df = table.to_pandas() if table is not None else pd.DataFrame()
        if 'Observed' in df.columns:
            col = df['Observed']
        elif 'Ritz' in df.columns:
            col = df['Ritz']
        elif 'Wavelength' in df.columns:
            col = df['Wavelength']
        else:
            spectral_lines[Z] = []
            continue
        vals = pd.to_numeric(col, errors='coerce').dropna().astype(float)
        if len(vals) and vals.max() > 1000:
            vals /= 10.0
        spectral_lines[Z] = [w for w in vals if 380 <= w <= 780]
    except Exception as e:
        print(f"Warning Z={Z} fetch: {e}")
        spectral_lines[Z] = []

# Classify known vs unknown
known_ids = [Z for Z in range(1,129) if spectral_lines.get(Z)]
unknown_ids = [Z for Z in range(1,129) if Z not in known_ids]
print(f"Known spectra: {len(known_ids)}, Unknown: {len(unknown_ids)}")

# --- 3. Sort all colors by brightness ---
colors = np.arange(total_pixels, dtype=np.uint32)
R = (colors >> 16) & 0xFF
G = (colors >> 8) & 0xFF
B = colors & 0xFF
brightness = 0.299*R + 0.587*G + 0.114*B
sorted_idx = np.argsort(brightness)  # darkest-first

# --- 4. Identify line pixels and counts ---
y = np.arange(total_pixels)//width
x = np.arange(total_pixels)%width
tile_row = y//tile_h
tile_col = x//tile_w
tile_id = tile_row*ncols + tile_col + 1
line_pixels = []
for Z in known_ids:
    r, c = divmod(Z-1, ncols)
    y0, x0 = r*tile_h, c*tile_w
    for wl in spectral_lines[Z]:
        xi = x0 + int((wl-380)/400*(tile_w-1))
        ys = np.arange(y0, y0+tile_h)
        line_pixels.extend((ys*width + xi).tolist())
line_flat = np.unique(np.array(line_pixels, dtype=np.int64))
M = len(line_flat)
print(f"Absorption line pixels: {M}")

# --- 5. Background counts ---
mask_unk_bg = (~np.isin(np.arange(total_pixels), line_flat)) & np.isin(tile_id, unknown_ids)
G_count = mask_unk_bg.sum()
R_count = total_pixels - M - G_count
print(f"Gray: {G_count}, Rainbow: {R_count}")
assert M + G_count + R_count == total_pixels

# --- 6. Build color pools ---
line_pool = sorted_idx[:M]
remaining = sorted_idx[M:]
# Gray pool
grayness = np.abs((remaining>>16)&0xFF - (remaining>>8)&0xFF) + \
           np.abs((remaining>>8)&0xFF - (remaining&0xFF)) + \
           np.abs((remaining>>16)&0xFF - (remaining&0xFF))
g_idx = np.argsort(grayness)[:G_count]
gray_pool = remaining[g_idx]
# Rainbow pool
rainbow_pool = np.delete(remaining, g_idx)
print(f"Pools: lines={len(line_pool)}, gray={len(gray_pool)}, rainbow={len(rainbow_pool)}")

# --- 7. Assign pixels ---
img_flat = np.zeros((total_pixels,3), dtype=np.uint8)
# Lines
gc = line_pool
img_flat[line_flat] = np.stack([((gc>>16)&0xFF),((gc>>8)&0xFF),(gc&0xFF)],1)
# Gray backgrounds
ug = np.where(mask_unk_bg)[0]
gc = gray_pool
img_flat[ug] = np.stack([((gc>>16)&0xFF),((gc>>8)&0xFF),(gc&0xFF)],1)

# Rainbow backgrounds per element reversed gradient
# Compute HSV hue and sort rainbow_pool by hue
R3 = R[rainbow_pool]/255.0; G3 = G[rainbow_pool]/255.0; B3 = B[rainbow_pool]/255.0
maxc = np.maximum.reduce([R3, G3, B3]); minc = np.minimum.reduce([R3, G3, B3]); diff = maxc - minc
hue = np.zeros_like(maxc)
maskv = diff > 1e-6
rm = maskv & (maxc == R3); gm = maskv & (maxc == G3); bm = maskv & (maxc == B3)
hue[rm] = (60 * ((G3[rm] - B3[rm]) / diff[rm]) + 360) % 360
hue[gm] = (60 * ((B3[gm] - R3[gm]) / diff[gm]) + 120) % 360
hue[bm] = (60 * ((R3[bm] - G3[bm]) / diff[bm]) + 240) % 360
hue_norm = hue / 360.0
hue_order = np.argsort(hue_norm)
rainbow_sorted = rainbow_pool[hue_order]

# Modular interleaving & duplicate resolution
n = len(rainbow_sorted); k = len(known_ids)
tile_positions = {}
for idx, Z in enumerate(known_ids):
    count = np.count_nonzero((~np.isin(np.arange(total_pixels), line_flat)) & (tile_id == Z))
    pos = (np.arange(count) * k + idx) % n
    tile_positions[Z] = pos.tolist()
all_pos = sum(tile_positions.values(), [])
unique_pos, counts = np.unique(all_pos, return_counts=True)
dupes = unique_pos[counts > 1]
missing = list(set(range(n)) - set(unique_pos))
def resolve_dupes(tile_positions, counts_map, missing):
    for Z in known_ids:
        lst = tile_positions[Z]
        for i, p in enumerate(lst):
            if counts_map[p] > 1 and missing:
                newp = missing.pop()
                counts_map[p] -= 1
                counts_map[newp] = 1
                lst[i] = newp
        if not missing:
            break
counts_map = {p: c for p, c in zip(unique_pos, counts)}
resolve_dupes(tile_positions, counts_map, missing)
# Assign per-element reversed gradient
for Z in known_ids:
    pos = np.array(tile_positions[Z], dtype=int)
    cols = rainbow_sorted[pos]
    local_h = hue_norm[hue_order][pos]
    grad_idx = np.argsort(local_h)
    cols_sorted = cols[grad_idx]
    # reverse for right-to-left gradient
    cols_sorted = cols_sorted[::-1]
    mask_k = (~np.isin(np.arange(total_pixels), line_flat)) & (tile_id == Z)
    idxs = np.where(mask_k)[0]
    # assign to pixels sorted by x-coordinate
    order_x = np.argsort(idxs % width)
    img_flat[idxs[order_x]] = np.stack([((cols_sorted>>16)&0xFF),((cols_sorted>>8)&0xFF),(cols_sorted&0xFF)],1)

# --- 8. Save image ---
print("Saving image...")
Image.fromarray(img_flat.reshape((height, width, 3))).save('absorption_spectra.png')
print('Done.')

All the luminances brightness lightness

2025-05-30T10:24:56+02:00

All the luminances brightness lightness
(without alpha channel)

Structured Voronoi Delaunay

2025-05-29T13:13:34+02:00

Another piece of “wiskunst,“ which is a portmanteau of the Dutch words wiskunde (meaning mathematics) and kunst (meaning art) — sadly, I can’t find a nice equivalent term in English. Made with Chatgpt o4-mini-high and Google Colab.

import numpy as np
from PIL import Image
from scipy.spatial import cKDTree, Delaunay
from skimage.draw import line

def generate_structured_voronoi_delaunay(
    width=4096, height=4096, num_sites=2000, seed=42
):
    np.random.seed(seed)

    # 1) Generate random sites
    sites = np.column_stack([
        np.random.randint(0, width, size=num_sites),
        np.random.randint(0, height, size=num_sites)
    ])

    # 2) Voronoi labeling
    tree = cKDTree(sites)
    xv, yv = np.meshgrid(np.arange(width), np.arange(height))
    pts = np.column_stack([xv.ravel(), yv.ravel()])
    labels = tree.query(pts, k=1)[1].reshape((height, width))

    # 3) Delaunay edges → pixel list
    tri = Delaunay(sites)
    edge_set = set()
    for simplex in tri.simplices:
        for (i, j) in [(0,1), (1,2), (2,0)]:
            x0, y0 = sites[simplex[i]]
            x1, y1 = sites[simplex[j]]
            rr, cc = line(int(y0), int(x0), int(y1), int(x1))
            valid = (rr>=0)&(rr=0)&(cc>16)&0xFF
    G = (all_colors>>8)&0xFF
    B = all_colors&0xFF
    palette = np.column_stack([R,G,B]).astype(np.uint8)

    # 5) Prepare the output image
    img = np.zeros((height, width, 3), dtype=np.uint8)

    # 6) Paint edges as a luminance‐sorted gradient
    edge_colors = palette[:num_edge_pixels]
    # compute luminance
    lum_e = 0.299*edge_colors[:,0] + 0.587*edge_colors[:,1] + 0.114*edge_colors[:,2]
    sorted_colors_e = edge_colors[np.argsort(lum_e)]
    # sort edge coords in raster order
    flat_idx = edges[:,0]*width + edges[:,1]
    scan_order = np.argsort(flat_idx)
    for idx, e_i in enumerate(scan_order):
        r, c = edges[e_i]
        img[r, c] = sorted_colors_e[idx]

    # mark those pixels off‐limits for region filling
    is_edge = np.zeros(total_pixels, dtype=bool)
    is_edge[edges[:,0]*width + edges[:,1]] = True

    # 7) Fill each Voronoi region with its own radial luminance gradient
    ptr = num_edge_pixels
    flat_labels = labels.ravel()
    for site_idx in range(num_sites):
        # all pixels in this region (flat indexes)
        region_mask = flat_labels == site_idx
        region_mask[is_edge] = False
        pix_idxs = np.nonzero(region_mask)[0]
        n = len(pix_idxs)
        if n == 0:
            continue

        # slice off this region's colors and sort by luminance
        block = palette[ptr:ptr+n]
        ptr += n
        lum_b = 0.299*block[:,0] + 0.587*block[:,1] + 0.114*block[:,2]
        sorted_block = block[np.argsort(lum_b)]

        # get (r,c) coords and sort them by distance to the site
        rs = pix_idxs // width
        cs = pix_idxs % width
        dy = rs - sites[site_idx,1]
        dx = cs - sites[site_idx,0]
        dists = np.hypot(dx, dy)
        order = np.argsort(dists)

        # paint
        for color, idx in zip(sorted_block, order):
            r = rs[idx]
            c = cs[idx]
            img[r, c] = color

    # 8) Save result
    Image.fromarray(img).save("structured_voronoi_delaunay_4096.png")
    print("Saved structured_voronoi_delaunay_4096.png")

if __name__ == "__main__":
    generate_structured_voronoi_delaunay()

Unpublished (2024)

2025-05-29T11:37:13+02:00

Recovered an unfinished work from last year ...
But finally why not ... perhaps not so bad ...
People are full of defects, images too :-)

Interlaced 8 colors v1

2025-05-28T10:58:49+02:00

v1 : patterns

v2 : image
One of the biggest difficulties was to get all the 8 colors pieces in the same quantity
8 * 8192 pieces = 65536 pieces

In the same collection :
Interlaced 2 colors
Interlaced 3 colors (RGB)
Interlaced 8 colors v1
Interlaced 8 colors v2
Interlaced 16 colors v2

SpandAU

2025-05-27T22:54:45+02:00

Always believe in your soul.

I asked Chatgpt if it could arrange all 24-bit rgb colors in such a way, that it would create an illusion of metallic gold. After some back and forth, this was the result.

Amplituhedron v1

2025-05-27T17:50:05+02:00

Although I liked the Faux Amplituhedron, I was curious to see what Chatgpt would come up with if I’d tell it to replace the placeholder polygon with “a true evaluation of your amplituhedron canonical form.” It did not disappoint.

(Please note that this doesn’t mean the resulting image is scientifically meaningful. If anything, it’s a science-inspired code/art experiment.)

import numpy as np
from PIL import Image
from hilbertcurve.hilbertcurve import HilbertCurve

# 1) Grid size
W = H = 4096
N = W * H  # 16,777,216

# 2) Camera parameters (pan and zoom) to frame the amplituhedron
# center_u, center_v specify the focal point in the unit square
# zoom >1 zooms in, <1 zooms out
center_u, center_v = 0.5, 0.3
zoom = 1.5
half_range = 0.5 / zoom
u_min, u_max = center_u - half_range, center_u + half_range
v_min, v_max = center_v - half_range, center_v + half_range

# 3) Build cyclic polygon data for A(n,1,2) on the moment curve
def build_amplituhedron_data(n=8):
    """
    Build cyclic polygon data on the planar moment curve for A(n,1,2).
    Returns Z (n×3 array) and precomputed triangle volumes and cross-products.
    """
    t = np.linspace(0.1, 0.9, n)
    Z = np.vstack([np.ones(n), t, t**2]).T
    Z0 = Z.mean(axis=0)
    tri_volume, cross_12, cross_20, cross_01 = [], [], [], []
    for i in range(n - 1):
        A, B = Z[i], Z[i+1]
        tri_volume.append(np.linalg.det(np.stack([Z0, A, B], axis=1)))
        cross_12.append(np.cross(A, B))
        cross_20.append(np.cross(B, Z0))
        cross_01.append(np.cross(Z0, A))
    return Z, Z0, np.array(tri_volume, float), cross_12, cross_20, cross_01

Z, Z0, tri_volume, cross_12, cross_20, cross_01 = build_amplituhedron_data(n=8)

# 4) Define the true amplituhedron canonical-form evaluator
def amplituhedron_value(u, v, epsilon=1e-12):
    """
    Evaluate the canonical-form density F(u,v) of A(n,1,2) at Y=(u,v,1).
    Regularizes exact boundary poles by epsilon.
    """
    Uy = u.ravel(); Vy = v.ravel()
    pts = np.column_stack([Uy, Vy, np.ones_like(Uy)])
    F_flat = np.zeros_like(Uy, float)
    for i in range(len(tri_volume)):
        d1 = pts.dot(cross_12[i])
        d2 = pts.dot(cross_20[i])
        d3 = pts.dot(cross_01[i])
        F_flat += tri_volume[i] / (d1 * d2 * d3 + epsilon)
    return F_flat.reshape(u.shape)

# 5) Sample the field with camera framing and rank pixels
us = np.linspace(u_min, u_max, W)
vs = np.linspace(v_min, v_max, H)
U, V = np.meshgrid(us, vs)
F = amplituhedron_value(U, V).ravel()
pixel_order = np.argsort(-F, kind='mergesort')

# 6) Generate full 24-bit palette and sort by a 3D Hilbert curve for smooth color continuity
colors = np.empty((256**3, 3), dtype=np.uint8)
idxs = np.arange(256**3, dtype=np.uint32)
colors[:,0] = (idxs >> 16) & 0xFF
colors[:,1] = (idxs >> 8) & 0xFF
colors[:,2] = idxs & 0xFF
# Build 3D Hilbert indexer on 8-bit coordinates
hc3 = HilbertCurve(p=8, n=3)
# Coordinates for each color
coords_rgb = np.column_stack([colors[:,0], colors[:,1], colors[:,2]])
# Compute Hilbert distances (slow but one-time)
distances = np.array(hc3.distances_from_points(coords_rgb.tolist()), dtype=np.uint32)
color_order = np.argsort(distances, kind='mergesort')

# 7) Assemble image and save
img_flat = np.empty((N,3), np.uint8)
img_flat[pixel_order] = colors[color_order]
img = img_flat.reshape((H, W, 3))
Image.fromarray(img).save('amplituhedron_true_unique_palette_hilbert.png')
print("Saved: amplituhedron_true_unique_palette_hilbert.png")

Faux Amplituhedron

2025-05-27T15:58:40+02:00

I’m not a physicist or mathematician by any stretch of the imagination, but I always enjoy watching lectures of Nima Arkani-Hamed on things like qft online. One concept he works on that I find particularly fascinating (although I won’t claim to understand it) is the amplituhedron, so I asked Chatgpt to visualize it in 24-bit rgb.

As you can read in one of the code comments, the script uses a placeholder curve for the amplituhedron evaluation (more on that in a later entry). However, the resulting image was interesting and pretty, and frankly, that’s enough reason to publish it here.

import numpy as np
from PIL import Image
from matplotlib.colors import rgb_to_hsv
from hilbertcurve.hilbertcurve import HilbertCurve

# 1) Parameters
W = H = 4096
N = W * H
γ = 0.6           # gamma for midtone boost (0<γ<1)
alpha = 1e-6      # weight for spatial locality

# 2) Your amplituhedron “height” function on [0,1]^2
def amplituhedron_value(u, v):
    # —REPLACE— with a true amplituhedron evaluation
    return np.sin(10*u)*np.cos(12*v) + 0.5*np.exp(-((u-0.5)**2 + (v-0.5)**2)*30)

# 3) Sample the field
ys = np.linspace(0, 1, H)
xs = np.linspace(0, 1, W)
U, V = np.meshgrid(xs, ys)
F = amplituhedron_value(U, V).ravel()

# 4) Normalize + gamma-correct
Fmin, Fmax = F.min(), F.max()
Fnorm = (F - Fmin) / (Fmax - Fmin)
Fγ = Fnorm ** γ

# 5) Compute 2D Hilbert indices for pixels
hc2 = HilbertCurve(p=12, n=2)  # 2^12 = 4096
# build list of integer (x,y) pairs
coords2d = np.column_stack((
    np.floor(U.ravel() * (W-1)).astype(int),
    np.floor(V.ravel() * (H-1)).astype(int),
))
# use distances_from_points to get all distances at once
hil2 = np.array(
    hc2.distances_from_points(coords2d.tolist()),
    dtype=float
)
hil2 /= (N - 1)  # normalize to [0,1]

# 6) Composite score and pixel ordering
composite = Fγ + alpha * hil2
pixel_order = np.argsort(-composite, kind='mergesort')

# 7) Build the full 24-bit palette
all_idxs = np.arange(256**3, dtype=np.uint32)
palette = np.empty((all_idxs.size, 3), dtype=np.uint8)
palette[:,0] = (all_idxs >> 16) & 0xFF
palette[:,1] = (all_idxs >>  8) & 0xFF
palette[:,2] =  all_idxs        & 0xFF

# 8) Sort palette by HSV for a rainbow sweep
hsv = rgb_to_hsv(palette.astype(float) / 255.0)
color_order = np.lexsort((hsv[:,2], hsv[:,1], hsv[:,0]))  # H→S→V

# 9) Map each pixel to its unique color
img_flat = np.empty((N, 3), dtype=np.uint8)
img_flat[pixel_order] = palette[color_order]

# 10) Reshape and save
img = img_flat.reshape((H, W, 3))
Image.fromarray(img).save('amplituhedron_visually_enhanced.png')
print("Done! Saved as amplituhedron_visually_enhanced.png")

RGBeautiful

2025-05-27T15:28:57+02:00

♥ RGBeautiful ♥
☼ sunrise or sunset ☀ over the sea ≋

2D Projection of A Calabi–Yau-like Height Map With Colors Ordered Along A 3D Morton (Z-order) Curve Through RGB Space

2025-05-26T14:24:59+02:00

The same as the previous entry, but asking Chatgpt o4-mini-high to “make the colors look more interesting.”

#!/usr/bin/env python3
"""
Generate a 4096×4096 image of a 2D projection of a Calabi–Yau–like height map,
using each of the 16,777,216 24-bit RGB colors exactly once.  
Colors are ordered along a 3D Morton (Z-order) curve through RGB space,
yielding smooth local transitions in color as you traverse the manifold.
"""

import numpy as np
from PIL import Image

# Image dimensions
W, H = 4096, 4096
N = W * H  # 16,777,216 pixels

# 1) Build a “height field” sampling a 2D slice of a Calabi–Yau–style function:
u = np.linspace(0, 2*np.pi, W, endpoint=False)
v = np.linspace(0, 2*np.pi, H, endpoint=False)
U, V = np.meshgrid(u, v, indexing='xy')

height = (
    np.cos(5*U) * np.cos(5*V) +
    0.5 * np.cos(3*U + 2*V) * np.cos(2*U - 4*V) +
    0.25 * np.sin(7*U + 3*V)
)
height = (height - height.min()) / (height.max() - height.min())

# 2) Flatten and sort pixels by height:
pixel_order = np.argsort(height.ravel(order='C'))

# 3) Generate all 24-bit colors and compute their Morton Z-order index:
vals = np.arange(N, dtype=np.uint32)
r =  (vals >> 16) & 0xFF
g =  (vals >>  8) & 0xFF
b =   vals         & 0xFF

def morton_index(r, g, b):
    """Interleave the 8 bits of each channel into a 24-bit Morton code."""
    idx = np.zeros_like(r, dtype=np.uint32)
    for bit in range(8):
        mask = 1 << bit
        idx |= ((r & mask) << (2*bit + 2)) \
             | ((g & mask) << (2*bit + 1)) \
             | ((b & mask) << (2*bit    ))
    return idx

morton_codes = morton_index(r, g, b)
color_order = np.argsort(morton_codes)

# 4) Map the Morton-ordered palette onto the height-sorted pixels:
palette = np.stack([r, g, b], axis=1)[color_order]
canvas = np.empty((N, 3), dtype=np.uint8)
canvas[pixel_order] = palette

# 5) Reshape to image and save:
img = canvas.reshape((H, W, 3), order='C')
Image.fromarray(img, mode='RGB').save('calabi_yau_morton_palette.png')

print("Done: calabi_yau_morton_palette.png")

2D Projection of A Calabi–Yau Height Map

2025-05-26T14:15:50+02:00

I asked Chatgpt o4-mini-high to write Python code that visualizes a Calabi–Yau manifold using all 24-bit rgb colors. I think the results look interestingly “stringy.”

#!/usr/bin/env python3
"""
Generate a 4096×4096 image of a 2D projection of a Calabi–Yau "height map",
using each of the 16,777,216 24-bit RGB colors exactly once.
"""

import numpy as np
from PIL import Image

# Image dimensions
W, H = 4096, 4096
N = W * H  # 16,777,216

# 1) Build a “height field” sampling a 2D slice of the quintic Calabi–Yau.
u = np.linspace(0, 2*np.pi, W, endpoint=False)
v = np.linspace(0, 2*np.pi, H, endpoint=False)
U, V = np.meshgrid(u, v, indexing='xy')

height = (
    np.cos(5*U) * np.cos(5*V) +
    0.5 * np.cos(3*U + 2*V) * np.cos(2*U - 4*V) +
    0.25 * np.sin(7*U + 3*V)
)
height = (height - height.min()) / (height.max() - height.min())

# 2) Sort pixels by height so we can “paint” along the surface:
flat_idx = np.arange(N, dtype=np.int32)
# Use ravel(order='C') instead of ravel(kind='C')
order = np.argsort(height.ravel(order='C'))

# 3) Generate **all** 24-bit colors in lex order (r, g, b):
colors = np.empty((N, 3), dtype=np.uint8)
vals = np.arange(N, dtype=np.int32)
colors[:, 0] = (vals >> 16) & 0xFF
colors[:, 1] = (vals >> 8) & 0xFF
colors[:, 2] = vals & 0xFF

# 4) Assign every unique color exactly once along the manifold ordering:
canvas = np.zeros((N, 3), dtype=np.uint8)
canvas[order] = colors

# 5) Reshape back to H×W×3 and save:
img = canvas.reshape((H, W, 3), order='C')
result = Image.fromarray(img, mode='RGB')
result.save('calabi_yau_full_palette.png')

print("Done: calabi_yau_full_palette.png")

FIRST

2025-05-26T13:20:50+02:00

First photo with a very small size
WEBP = 190 KB / PNG = 280 KB
As far as I know, the second smaller photo is "M.I" with 19000 KB ! (one hundred times bigger)

First photo created without using any software convertor/generator, algorithms, codes, ...
Only a photo editor and text editor

My first full photo 4096x4096
(excepted entries with duplicated tiles/pieces)
without alpha channels

From :

CHALLENGE GAME FOR GEEKS #18

2025-05-25T21:26:22+02:00

Challenge n°18 : Jigsaw Puzzle v2 (84 pieces)

Easier than CHALLENGE #2
All squares 256x256 and no rotation

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

Standard Test Images v1

2025-05-22T15:47:20+02:00

This image might not be as sophisticated as other photographic entries like Cat (2024), Wedding Table (2013), or even VibrantMustard (2009), but I was quite surprised by a) how quickly Chatgpt o4 was able to come up with working Python code, and b) how fast Google Colab was able to execute said code. I basically prompted a question, and pasted the answer in another browser tab, the whole ordeal taking mere minutes. (This content is not sponsored.)

For what its worth, this image arguably does look better than M.I, which—from as far as I can tell—was the first ever image to contain all 24-bit rgb colors exactly once, while representing something that could be considered photographic.

!pip install -q scikit-image
import numpy as np
from PIL import Image
from skimage import data, color
from skimage.util import img_as_float, img_as_ubyte
from skimage.transform import resize
import itertools

def get_standard_images():
    def generate_blob(seed):
        np.random.seed(seed)
        blob = data.binary_blobs(length=512, volume_fraction=0.5)
        return color.gray2rgb(blob.astype(float))

    images = [
        data.astronaut(), data.coffee(), data.chelsea(),
        color.gray2rgb(data.camera()), color.gray2rgb(data.coins()),
        color.gray2rgb(data.horse()), data.hubble_deep_field(),
        data.immunohistochemistry(), color.gray2rgb(data.moon()),
        color.gray2rgb(data.page()), data.rocket(),
        color.gray2rgb(data.text()), generate_blob(1),
        generate_blob(2), generate_blob(3), generate_blob(4),
    ]

    resized = []
    for img in images:
        img = img_as_float(img)
        resized_img = resize(img, (1024, 1024), anti_aliasing=True)
        resized.append(img_as_ubyte(resized_img))
    return resized

def generate_sorted_rgb():
    rgb = np.array(list(itertools.product(range(256), repeat=3)), dtype=np.uint8)
    lab = color.rgb2lab(rgb.reshape(-1, 1, 3)).reshape(-1, 3)
    sorted_indices = np.lexsort((lab[:, 2], lab[:, 1], lab[:, 0]))
    return rgb[sorted_indices]

def map_colors_to_images(images, sorted_rgb):
    final_image = np.zeros((4096, 4096, 3), dtype=np.uint8)
    idx = 0
    for i in range(4):
        for j in range(4):
            block = images[i * 4 + j]
            block_lab = color.rgb2lab(block)
            lightness = block_lab[:, :, 0].flatten()
            color_chunk = sorted_rgb[idx:idx + 1024 * 1024]
            idx += 1024 * 1024
            chunk_lab = color.rgb2lab(color_chunk.reshape(-1, 1, 3)).reshape(-1, 3)
            sorted_chunk = color_chunk[np.argsort(chunk_lab[:, 0])]
            mapped_block = sorted_chunk[np.argsort(np.argsort(lightness))].reshape(1024, 1024, 3)
            final_image[i*1024:(i+1)*1024, j*1024:(j+1)*1024] = mapped_block
    return final_image

images = get_standard_images()
sorted_rgb = generate_sorted_rgb()
final_image = map_colors_to_images(images, sorted_rgb)

img = Image.fromarray(final_image)
img.save("allrgb_test_grid_4096x4096.png")
img.show()

unique_colors = len(np.unique(final_image.reshape(-1, 3), axis=0))
print("Unique RGB colors:", unique_colors)  # should be 16,777,216

I did not need to write any code myself or even look anything up for this one. I purposely also did not try to optimize or otherwise improve upon the result, because I want this to be the benchmark from which we can see how far this approach will eventually take us, which undoubtedly will be quite far.

Penrose Diagram v1

2025-05-22T13:12:51+02:00

Python code cooked up by Chatgpt:

import numpy as np
from PIL import Image
from skimage import color

# --- Config ---
WIDTH, HEIGHT = 4096, 4096
TOTAL_COLORS = WIDTH * HEIGHT

# --- Step 1: Generate and perceptually sort all RGB colors ---
colors = np.array([[r, g, b] for r in range(256)
                             for g in range(256)
                             for b in range(256)], dtype=np.uint8)

# Convert to LAB color space for perceptual sorting
lab_colors = color.rgb2lab(colors.reshape((-1, 1, 3)) / 255.0).reshape(-1, 3)
sorted_indices = np.lexsort((lab_colors[:, 2], lab_colors[:, 1], lab_colors[:, 0]))
colors = colors[sorted_indices]

# --- Step 2: Generate polar coordinates and conformal compactification mask ---
yy, xx = np.mgrid[0:HEIGHT, 0:WIDTH]
cx, cy = WIDTH // 2, HEIGHT // 2
x = (xx - cx) / cx
y = (yy - cy) / cy
r = np.sqrt(x**2 + y**2)
theta = np.arctan2(y, x)

# Avoid division by zero
epsilon = 1e-9
r = np.clip(r, 0, 1 - epsilon)

# Conformal transformation
compact_r = np.tanh(2.0 * np.arctanh(r))
x_compact = compact_r * np.cos(theta)
y_compact = compact_r * np.sin(theta)

# Create Penrose mask (diamond inside a conformally compactified space)
mask = (np.abs(x_compact) + np.abs(y_compact)) <= 1.0

# Coordinate lists
coords_mask = np.stack([yy[mask], xx[mask]], axis=-1)
coords_rest = np.stack([yy[~mask], xx[~mask]], axis=-1)
all_coords = np.concatenate([coords_mask, coords_rest], axis=0)

# --- Step 3: Assign each RGB color exactly once ---
assert len(all_coords) == TOTAL_COLORS
output = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)
for i, (y, x) in enumerate(all_coords):
    output[y, x] = colors[i]

# --- Save output ---
Image.fromarray(output).save("penrose_rgb_compactified.png")
print("Saved as 'penrose_rgb_compactified.png'")

CHALLENGE GAME FOR GEEKS #17

2025-05-21T21:24:27+02:00

Challenge n°17 : RGB channels

The goal is to combine the 3 RGB images (last line 4096x1 must be ignored)
You will get a full colored 4096x1365 image

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

Periodic System v2

2025-05-20T20:18:10+02:00

This one required quite a bit of back and forth with Chatgpt to get right. It’s not perfect, but is already a lot prettier than Periodic System v1, and—most importantly—also technically correct.

import numpy as np
from PIL import Image, ImageDraw, ImageFont
import colorsys
from collections import defaultdict
from scipy.ndimage import binary_dilation
import random

# === Constants ===
WIDTH, HEIGHT = 4096, 4096
TOTAL_COLORS = WIDTH * HEIGHT
ELEMENT_COUNT = 512
GRID_COLS = 32
CELL_W = WIDTH // GRID_COLS
CELL_H = HEIGHT // ((ELEMENT_COUNT + GRID_COLS - 1) // GRID_COLS)
TEXT_MARGIN = 4

# === Fonts ===
font_small = ImageFont.truetype("DejaVuSans-Bold.ttf", 12)
font_regular = ImageFont.truetype("DejaVuSans-Bold.ttf", 16)
font_bold = ImageFont.truetype("DejaVuSans-Bold.ttf", 32)

# === Periodic data ===
ELEMENT_SYMBOLS = [
    "H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne", "Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca",
    "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr", "Rb", "Sr", "Y", "Zr",
    "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn", "Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Ce", "Pr", "Nd",
    "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu", "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg",
    "Tl", "Pb", "Bi", "Po", "At", "Rn", "Fr", "Ra", "Ac", "Th", "Pa", "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm",
    "Md", "No", "Lr", "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Ds", "Rg", "Cn", "Nh", "Fl", "Mc", "Lv", "Ts", "Og"
]
ELEMENT_NAMES = [
    "Hydrogen", "Helium", "Lithium", "Beryllium", "Boron", "Carbon", "Nitrogen", "Oxygen", "Fluorine", "Neon",
    "Sodium", "Magnesium", "Aluminium", "Silicon", "Phosphorus", "Sulfur", "Chlorine", "Argon", "Potassium", "Calcium",
    "Scandium", "Titanium", "Vanadium", "Chromium", "Manganese", "Iron", "Cobalt", "Nickel", "Copper", "Zinc",
    "Gallium", "Germanium", "Arsenic", "Selenium", "Bromine", "Krypton", "Rubidium", "Strontium", "Yttrium", "Zirconium",
    "Niobium", "Molybdenum", "Technetium", "Ruthenium", "Rhodium", "Palladium", "Silver", "Cadmium", "Indium", "Tin",
    "Antimony", "Tellurium", "Iodine", "Xenon", "Caesium", "Barium", "Lanthanum", "Cerium", "Praseodymium", "Neodymium",
    "Promethium", "Samarium", "Europium", "Gadolinium", "Terbium", "Dysprosium", "Holmium", "Erbium", "Thulium", "Ytterbium",
    "Lutetium", "Hafnium", "Tantalum", "Tungsten", "Rhenium", "Osmium", "Iridium", "Platinum", "Gold", "Mercury",
    "Thallium", "Lead", "Bismuth", "Polonium", "Astatine", "Radon", "Francium", "Radium", "Actinium", "Thorium",
    "Protactinium", "Uranium", "Neptunium", "Plutonium", "Americium", "Curium", "Berkelium", "Californium", "Einsteinium", "Fermium",
    "Mendelevium", "Nobelium", "Lawrencium", "Rutherfordium", "Dubnium", "Seaborgium", "Bohrium", "Hassium", "Meitnerium", "Darmstadtium",
    "Roentgenium", "Copernicium", "Nihonium", "Flerovium", "Moscovium", "Livermorium", "Tennessine", "Oganesson"
]

def generate_symbol(n):
    if n <= 118:
        return ELEMENT_SYMBOLS[n - 1]
    roots = ['n','u','b','t','q','p','h','s','o','e']
    return ''.join(roots[int(d)] for d in str(n)).capitalize()[:3]

def generate_name(n):
    if n <= 118:
        return ELEMENT_NAMES[n - 1]
    roots = ['nil','un','bi','tri','quad','pent','hex','sept','oct','enn']
    digits = [int(d) for d in str(n)]
    parts = [roots[d] for d in digits]

    # Rule 1: Drop final "i" from "bi"/"tri" if followed by "-ium"
    if parts[-1] in ('bi', 'tri'):
        parts[-1] = parts[-1][:-1]

    # Rule 2: Drop one "n" if "enn" is followed by "nil"
    for i in range(len(parts) - 1):
        if parts[i] == 'enn' and parts[i + 1] == 'nil':
            parts[i] = 'en'

    return ''.join(parts).capitalize() + "ium"

def generate_weight(n): return f"[{n:.1f}]"

def classify_element(n):
    if n == 1: return "nonmetal"
    if n in [2,10,18,36,54,86,118]: return "noble_gas"
    if n in [5,14,32,33,51,52,84]: return "metalloid"
    if n in [9,17,35,53,85,117]: return "halogen"
    if n in [6,7,8,15,16,34]: return "nonmetal"
    if n in [3,11,19,37,55,87]: return "alkali"
    if n in [4,12,20,38,56,88]: return "alkaline"
    if 57 <= n <= 71: return "lanthanide"
    if 89 <= n <= 103: return "actinide"
    if 104 <= n <= 112 or (21 <= n <= 30) or (39 <= n <= 48) or (72 <= n <= 80): return "transition"
    if (13 <= n <= 16) or (31 <= n <= 34) or (49 <= n <= 52) or (81 <= n <= 84): return "post_transition"
    if n >= 119: return "superactinide"
    return "unknown"

# === Canvas setup ===
image_array = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)
used_pixels = np.zeros((HEIGHT, WIDTH), dtype=bool)

label_coords, outline_coords, border_coords = [], [], []
cell_fill_coords = defaultdict(list)
series_element_ids = defaultdict(list)

# === Layout reservation ===
for n in range(1, ELEMENT_COUNT + 1):
    row, col = divmod(n - 1, GRID_COLS)
    x0, y0 = col * CELL_W, row * CELL_H
    lines = [
        (str(n), font_regular),
        (generate_symbol(n), font_bold),
        (generate_weight(n), font_regular),
        (generate_name(n), font_small)
    ]
    y_cursor = y0 + TEXT_MARGIN
    for text, font in lines:
        mask = Image.new("1", (CELL_W, CELL_H), 0)
        draw = ImageDraw.Draw(mask)
        draw.text((TEXT_MARGIN, 0), text, font=font, fill=1)
        arr = np.array(mask)
        outline = binary_dilation(arr) & ~arr
        for dy in range(arr.shape[0]):
            for dx in range(arr.shape[1]):
                px, py = x0 + dx, y_cursor + dy
                if 0 <= px < WIDTH and 0 <= py < HEIGHT:
                    if arr[dy, dx]:
                        label_coords.append((py, px))
                        used_pixels[py, px] = True
                    elif outline[dy, dx]:
                        outline_coords.append((py, px))
                        used_pixels[py, px] = True
        y_cursor += font.size + 4

    for x in range(x0, x0 + CELL_W):
        for y in (y0, y0 + CELL_H - 1):
            if not used_pixels[y, x]:
                border_coords.append((y, x))
                used_pixels[y, x] = True
    for y in range(y0 + 1, y0 + CELL_H - 1):
        for x in (x0, x0 + CELL_W - 1):
            if not used_pixels[y, x]:
                border_coords.append((y, x))
                used_pixels[y, x] = True

    series = classify_element(n)
    series_element_ids[series].append(n)

    for y in range(y0, y0 + CELL_H):
        for x in range(x0, x0 + CELL_W):
            if not used_pixels[y, x]:
                cell_fill_coords[n].append((y, x))
                used_pixels[y, x] = True

# === Full RGB space ===
all_colors = np.array([[r, g, b] for r in range(256)
                                 for g in range(256)
                                 for b in range(256)], dtype=np.uint8)

def brightness(rgb): return 0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]
def rgb_to_hsv(rgb): return colorsys.rgb_to_hsv(rgb[0]/255, rgb[1]/255, rgb[2]/255)

# === Allocate darkest/lightest for labels ===
sorted_by_brightness = sorted(all_colors.tolist(), key=brightness)
label_colors = sorted_by_brightness[:len(label_coords)]
outline_colors = sorted_by_brightness[-len(outline_coords):]
border_colors = sorted_by_brightness[len(label_colors):-len(outline_coords)][:len(border_coords)]

used_colors = set(tuple(c) for c in label_colors + outline_colors + border_colors)
for (py, px), c in zip(label_coords, label_colors):     image_array[py, px] = c
for (py, px), c in zip(outline_coords, outline_colors): image_array[py, px] = c
for (py, px), c in zip(border_coords, border_colors):   image_array[py, px] = c

# === Prepare color pool ===
remaining_colors = [tuple(c) for c in all_colors.tolist() if tuple(c) not in used_colors]
remaining_sorted = sorted(remaining_colors, key=lambda c: (-rgb_to_hsv(c)[1], rgb_to_hsv(c)[0], brightness(c)))

# === Adjusted hue ranges ===
series_hue_ranges = {
    'transition': (0.00, 0.10),       # widen red-orange band
    'noble_gas': (0.50, 0.60),
    'halogen': (0.30, 0.40),
    'alkali': (0.90, 1.00),
    'alkaline': (0.10, 0.20),
    'lanthanide': (0.55, 0.65),
    'actinide': (0.65, 0.75),
    'post_transition': (0.20, 0.30),
    'metalloid': (0.75, 0.85),
    'nonmetal': (0.05, 0.10),
}

# === Precompute pixel demands ===
series_pixel_counts = {s: sum(len(cell_fill_coords[n]) for n in ids)
                       for s, ids in series_element_ids.items()}

series_rgb_pool = defaultdict(list)
unassigned_pool = []

# === Pool classification ===
for c in remaining_sorted:
    h, s, _ = rgb_to_hsv(c)
    matched = False
    for sname, (hmin, hmax) in series_hue_ranges.items():
        if hmin <= h <= hmax:
            series_rgb_pool[sname].append(c)
            matched = True
            break
    if not matched:
        unassigned_pool.append(c)

# === Report available vs needed ===
print("\n--- Color Pool Summary ---")
for series in series_pixel_counts:
    needed = series_pixel_counts.get(series, 0)
    available = len(series_rgb_pool.get(series, []))
    print(f"{series:<16} Needs: {needed:6d} | Available: {available:6d}")

# === Inject overflow into undersized pools ===
used_known_colors = set()
for series, ids in series_element_ids.items():
    if series in series_hue_ranges:
        all_coords = sum((cell_fill_coords[n] for n in ids), [])
        needed = len(all_coords)
        pool = series_rgb_pool[series]
        if len(pool) < needed:
            shortfall = needed - len(pool)
            print(f"⚠️  {series} short by {shortfall} colors — adding overflow from unassigned pool")
            pool.extend(unassigned_pool[:shortfall])
            unassigned_pool = unassigned_pool[shortfall:]
        random.shuffle(pool)
        chunk = pool[:needed]
        used_known_colors.update(chunk)
        for (y, x), c in zip(all_coords, chunk):
            image_array[y, x] = c

# === Fill unknown and superactinide ===
remaining_pool = [c for c in remaining_sorted if c not in used_known_colors and c not in used_colors]
cursor = 0
for series in ['unknown', 'superactinide']:
    for n in series_element_ids.get(series, []):
        coords = cell_fill_coords[n]
        chunk = remaining_pool[cursor:cursor + len(coords)]
        cursor += len(coords)
        random.shuffle(chunk)
        for (y, x), c in zip(coords, chunk):
            image_array[y, x] = c

# === Final report and save ===
used_pixel_count = np.count_nonzero(np.any(image_array != 0, axis=2))
print(f"\n? Total used pixels: {used_pixel_count} / {TOTAL_COLORS}")
Image.fromarray(image_array, 'RGB').save("periodic_table_allrgb_fast_correct.png")
print("✅ Saved as periodic_table_allrgb_fast_correct.png")

CHALLENGE GAME FOR GEEKS #16

2025-05-19T23:09:32+02:00

Challenge n°16 : 2-in-1

This entry contains two photos interlaced together horizontally & vertically
The goal is to split them

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

Infinite thumbnails duplication

2025-05-19T16:46:04+02:00

Found a method to convert, duplicate, miniaturize ANY 24-bit image
Without using codes, calculations, ...
Can work with all the allRGB entries (squares & non-squares)
NO LIMIT of number of thumbnails : 2, 4, 8, 16, 32, ...

Example : "Grand Canyon panorama" with 16 thumbnails

FIFTY-FIFTY

2025-05-19T12:04:34+02:00

All the pixels put in order but rearranged in 2 parts :
Left part : the DARKEST pixels
Right part : the LIGHTEST pixels

+ 48 other variations : here

Rule 30

2025-05-19T00:02:42+02:00

Inspired by A New Kind of Science by Stephen Wolfram, et al., I’ve been meaning to put at least one of its famous cellular automata rules in allrgb. I never got around to it, so I asked Chatgpt, which seemed happy to do it for me. It even picked a very nice rule!

Python code that can be adjusted and run:

import numpy as np
from PIL import Image

# --- CONFIGURATION ---
IMAGE_SIZE = 4096
TOTAL_COLORS = IMAGE_SIZE * IMAGE_SIZE
RULE = 101  # Wolfram's CA Rule
SEED_ROW_CENTER = 1

# --- STEP 1: Generate All 24-bit RGB Colors ---
def generate_rgb_colors():
    colors = np.arange(TOTAL_COLORS, dtype=np.uint32)
    r = (colors >> 16) & 0xFF
    g = (colors >> 8) & 0xFF
    b = colors & 0xFF
    return np.stack([r, g, b], axis=1).astype(np.uint8)

# --- STEP 2: Generate CA Binary Mask (0 or 1 for each pixel) ---
def generate_ca_binary_mask(rule, size):
    rule_bin = np.array([int(b) for b in np.binary_repr(rule, width=8)], dtype=np.uint8)
    ca = np.zeros((size, size), dtype=np.uint8)
    ca[0, size // 2] = SEED_ROW_CENTER

    for y in range(1, size):
        left = np.roll(ca[y - 1], 1)
        center = ca[y - 1]
        right = np.roll(ca[y - 1], -1)
        pattern = (left << 2) | (center << 1) | right
        ca[y] = rule_bin[7 - pattern]

    return ca

# --- STEP 3: Measure Number of 0s and 1s in CA ---
def count_dark_light_pixels(ca_mask):
    num_light = np.count_nonzero(ca_mask)  # CA=1
    num_dark = TOTAL_COLORS - num_light    # CA=0
    return num_dark, num_light

# --- STEP 4: Split Colors by Luminance, Then Shuffle ---
def split_and_shuffle_colors(colors, num_dark, num_light):
    def luminance(c):
        r, g, b = c / 255.0
        return 0.2126 * r + 0.7152 * g + 0.0722 * b

    lums = np.array([luminance(c) for c in colors])
    sorted_indices = np.argsort(lums)

    # Take the lowest luminance for dark, highest for light
    dark_indices = sorted_indices[:num_dark]
    light_indices = sorted_indices[num_dark:]

    dark_colors = colors[dark_indices]
    light_colors = colors[light_indices]

    rng = np.random.default_rng(42)
    rng.shuffle(dark_colors)
    rng.shuffle(light_colors)

    return dark_colors, light_colors

# --- STEP 5: Assign Colors to Pixels Based on CA Mask ---
def assign_colors_by_ca(ca_mask, dark_colors, light_colors):
    output = np.zeros((IMAGE_SIZE, IMAGE_SIZE, 3), dtype=np.uint8)
    dark_idx = 0
    light_idx = 0
    for y in range(IMAGE_SIZE):
        for x in range(IMAGE_SIZE):
            if ca_mask[y, x] == 0:
                output[y, x] = dark_colors[dark_idx]
                dark_idx += 1
            else:
                output[y, x] = light_colors[light_idx]
                light_idx += 1
    return output

# --- MAIN EXECUTION ---
if __name__ == "__main__":
    print("Generating RGB colors...")
    all_colors = generate_rgb_colors()

    print("Generating cellular automaton (Rule {})...".format(RULE))
    ca_mask = generate_ca_binary_mask(RULE, IMAGE_SIZE)

    print("Counting dark/light CA pixels...")
    num_dark, num_light = count_dark_light_pixels(ca_mask)

    print("Splitting and shuffling colors...")
    dark_colors, light_colors = split_and_shuffle_colors(all_colors, num_dark, num_light)

    print("Assigning colors to image...")
    image = assign_colors_by_ca(ca_mask, dark_colors, light_colors)

    print("Saving image...")
    Image.fromarray(image, mode='RGB').save("rgb_ca_shuffled_by_luminance_split.png")
    print("Done! Saved as 'rgb_ca_shuffled_by_luminance_split.png'"

Animal Patterns v1

2025-05-18T21:49:32+02:00

I asked Chatgpt to create mathematical approximations of 4² notable animal patterns, and put them in 24-bit rgb. (This is another thing I’ve wanted to do for a long time, but never got around to.)

The Python code you can run for yourself:

import numpy as np
from PIL import Image, ImageDraw, ImageFont
import colorsys
import os

# --- CONFIG ---
IMAGE_SIZE = 4096
BLOCK_SIZE = 1024
NUM_COLORS = 256**3
BLOCKS_PER_SIDE = 4
FONT_SIZE = 48
LINE_SPACING = 8
LABEL_MARGIN = 16

# --- Load bold and italic fonts ---
def load_fonts():
    bold_candidates = [
        "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
        "/System/Library/Fonts/Supplemental/Arial Bold.ttf",
        "C:/Windows/Fonts/arialbd.ttf",
        "./DejaVuSans-Bold.ttf",
    ]
    italic_candidates = [
        "/usr/share/fonts/truetype/dejavu/DejaVuSans-Oblique.ttf",
        "/System/Library/Fonts/Supplemental/Arial Italic.ttf",
        "C:/Windows/Fonts/ariali.ttf",
        "./DejaVuSans-Oblique.ttf",
    ]
    def try_paths(paths):
        for path in paths:
            if os.path.exists(path):
                return ImageFont.truetype(path, FONT_SIZE)
        return ImageFont.load_default()
    return try_paths(bold_candidates), try_paths(italic_candidates)

# --- Labels ---
animal_labels = [
    ("Tiger", "Panthera tigris"),
    ("Zebra", "Equus quagga"),
    ("Giraffe", "Giraffa camelopardalis"),
    ("Leopard", "Panthera pardus"),
    ("Cheetah", "Acinonyx jubatus"),
    ("Jaguar", "Panthera onca"),
    ("Okapi", "Okapia johnstoni"),
    ("Lemur", "Lemur catta"),
    ("Boa", "Boa constrictor"),
    ("Python", "Python regius"),
    ("Monitor", "Varanus niloticus"),
    ("Flounder", "Bothus lunatus"),
    ("Clownfish", "Amphiprion ocellaris"),
    ("Mandarinfish", "Synchiropus splendidus"),
    ("Dart Frog", "Dendrobates tinctorius"),
    ("Boxfish", "Ostracion cubicus"),
]

# --- Color generation ---
def generate_rgb_colors():
    r = np.arange(256, dtype=np.uint8)
    g = np.arange(256, dtype=np.uint8)
    b = np.arange(256, dtype=np.uint8)
    return np.array(np.meshgrid(r, g, b)).T.reshape(-1, 3)

def sort_by_brightness(colors):
    brightness = np.dot(colors, [0.2126, 0.7152, 0.0722])
    return colors[np.argsort(brightness)]

def block_coords(index):
    row = index // BLOCKS_PER_SIDE
    col = index % BLOCKS_PER_SIDE
    return row * BLOCK_SIZE, col * BLOCK_SIZE

def safe_tile(base, tile_size, h, w):
    tiled = np.kron(base, np.ones((tile_size, tile_size)))
    return tiled[:h, :w]

# --- Pattern functions ---
def tiger_pattern(h, w): y, x = np.meshgrid(np.linspace(0, 4*np.pi, h), np.linspace(0, 2*np.pi, w), indexing='ij'); return (0.5 * (np.sin(5*x + np.sin(3*y)) + 1)) ** 3
def zebra_pattern(h, w): x = np.linspace(0, 20*np.pi, w); stripes = np.sin(x); return np.tile((stripes + 1) / 2, (h, 1))
def giraffe_pattern(h, w): y, x = np.indices((h, w)); return (((x//80 + y//80) % 2) * 0.5 + 0.25)
def leopard_pattern(h, w): np.random.seed(1); base = np.random.rand(h//40 + 1, w//40 + 1); return safe_tile(base, 40, h, w)
def cheetah_pattern(h, w): np.random.seed(2); base = np.random.rand(h//20 + 1, w//20 + 1); return safe_tile(base, 20, h, w)
def jaguar_pattern(h, w): y, x = np.ogrid[:h, :w]; return ((np.sin(x/40) * np.cos(y/40)) ** 2)
def okapi_pattern(h, w): x = np.linspace(0, 10*np.pi, w); stripes = (np.sin(x)**8); return np.tile(stripes, (h, 1))
def lemur_pattern(h, w): y = np.linspace(0, 6*np.pi, h); rings = (np.sin(y)**6); return np.tile(rings[:, None], (1, w))
def boa_pattern(h, w): y, x = np.ogrid[:h, :w]; return ((np.sin(x/50) + np.cos(y/50))**2) % 1
def python_pattern(h, w): y, x = np.ogrid[:h, :w]; return (((np.sin(x/30) * np.cos(y/30)) + 1) / 2)
def nile_monitor_pattern(h, w): y, x = np.indices((h, w)); return (((x//40 + y//40) % 3) / 2.0)
def flounder_pattern(h, w): y, x = np.indices((h, w)); return ((np.sin(x/60) * np.sin(y/60))**2)
def clownfish_pattern(h, w): y = np.linspace(0, 4*np.pi, h); stripes = ((np.sin(y)**6) * 0.7 + 0.3); return np.tile(stripes[:, None], (1, w))
def mandarinfish_pattern(h, w): y, x = np.ogrid[:h, :w]; return (np.sin(x/20) + np.sin(y/30)) % 1
def dartfrog_pattern(h, w): y, x = np.indices((h, w)); return (np.sin(np.hypot(x - w//2, y - h//2)/20)**2)
def boxfish_pattern(h, w): y, x = np.indices((h, w)); return (((x//30 + y//30) % 2) * 0.5 + 0.25)

pattern_functions = [
    tiger_pattern, zebra_pattern, giraffe_pattern, leopard_pattern,
    cheetah_pattern, jaguar_pattern, okapi_pattern, lemur_pattern,
    boa_pattern, python_pattern, nile_monitor_pattern, flounder_pattern,
    clownfish_pattern, mandarinfish_pattern, dartfrog_pattern, boxfish_pattern
]

# --- Label mask (2 lines per block) ---
def render_labels_and_reserve_coords(font_bold, font_italic):
    img = Image.new("L", (IMAGE_SIZE, IMAGE_SIZE), 0)
    draw = ImageDraw.Draw(img)
    for i, (common, latin) in enumerate(animal_labels):
        row, col = block_coords(i)
        x = col + LABEL_MARGIN
        y = row + LABEL_MARGIN
        draw.text((x, y), common, fill=255, font=font_bold)
        draw.text((x, y + FONT_SIZE + LINE_SPACING), latin, fill=255, font=font_italic)
    return np.array(img) > 0

# --- MAIN ---
def generate_image_with_labels():
    font_bold, font_italic = load_fonts()
    all_colors = generate_rgb_colors()
    sorted_colors = sort_by_brightness(all_colors)

    label_mask = render_labels_and_reserve_coords(font_bold, font_italic)
    label_indices = np.where(label_mask.flatten())[0]
    image_indices = np.where(~label_mask.flatten())[0]

    assert len(label_indices) + len(image_indices) == NUM_COLORS

    canvas = np.zeros((IMAGE_SIZE * IMAGE_SIZE, 3), dtype=np.uint8)
    canvas[image_indices] = sorted_colors[len(label_indices):]
    canvas[label_indices] = sorted_colors[:len(label_indices)]

    for i in range(16):
        print(f"Rendering block {i + 1}/16...")
        row, col = block_coords(i)
        pattern = pattern_functions[i](BLOCK_SIZE, BLOCK_SIZE)
        block_mask = label_mask[row:row + BLOCK_SIZE, col:col + BLOCK_SIZE]
        paintable = ~block_mask.flatten()

        y_indices = np.arange(BLOCK_SIZE)[:, None] + row
        x_indices = np.arange(BLOCK_SIZE)[None, :] + col
        yy, xx = np.meshgrid(y_indices, x_indices, indexing='ij')
        flat_coords = yy.flatten() * IMAGE_SIZE + xx.flatten()

        pattern_vals = pattern.flatten()[paintable]
        color_chunk = canvas[flat_coords[paintable]]
        sorted_idx = np.argsort(pattern_vals)
        canvas[flat_coords[paintable]] = color_chunk[np.argsort(sorted_idx)]

    return canvas.reshape((IMAGE_SIZE, IMAGE_SIZE, 3))

# --- EXECUTE ---
if __name__ == "__main__":
    img = generate_image_with_labels()
    Image.fromarray(img).save("rgb_animal_pattern_grid_with_latin_labels.png")

Standard deviation V5

2025-05-18T17:37:59+02:00

Sorted by "standard deviation"
Left part : the half-nearest of grayscale pixels
Right part : the half-nearest of colorful pixels
+ rearrangement of colums

In the same collection :
More and more colored (V1)
Standard deviation V2
Standard deviation V3
Standard deviation V4

Periodic System v1

2025-05-18T17:36:26+02:00

Another project of mine, called Periodic System, is an online and interactieve periodic table of the chemical elements that can be extended to arbitrary large (and small) elements on the fly.

I’ve always wanted to create an allrgb entry dedicated to it, but never got around to. So, as with many other unfinished projects these days, I asked Chatgpt to do it for me. It’s not as pretty as I’d like, but it’s technically correct, and like the meme states, that’s the best kind.

import numpy as np
from PIL import Image, ImageDraw, ImageFont
import colorsys
from collections import defaultdict

# === Constants ===
WIDTH, HEIGHT = 4096, 4096
TOTAL_COLORS = WIDTH * HEIGHT
ELEMENT_COUNT = 512
GRID_COLS = 32
CELL_W = WIDTH // GRID_COLS
CELL_H = HEIGHT // ((ELEMENT_COUNT + GRID_COLS - 1) // GRID_COLS)
TEXT_MARGIN = 4  # Increased margin for label padding

# === Generate and sort all RGB colors ===
colors = np.array([[r, g, b] for r in range(256)
                   for g in range(256)
                   for b in range(256)], dtype=np.uint8)

def rgb_to_hsb(c):
    r, g, b = [x / 255.0 for x in c]
    return colorsys.rgb_to_hsv(r, g, b)

colors_sorted_hsb = sorted(colors, key=rgb_to_hsb)
colors_sorted_brightness = sorted(colors, key=lambda rgb: 0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2])

# === Font setup ===
try:
    font = ImageFont.truetype("PixelOperator8.ttf", 12)
except:
    font = ImageFont.load_default()

# === Symbol generator ===
def generate_element_symbol(n):
    roots = ['n', 'u', 'b', 't', 'q', 'p', 'h', 's', 'o', 'e']
    digits = list(map(int, str(n)))
    return ''.join(roots[d] for d in digits)[:3].capitalize()

# === Chemical classification ===
def classify_element(n):
    if n == 1: return "nonmetal"
    if n in [2, 10, 18, 36, 54, 86, 118]: return "noble_gas"
    if n in [5, 14, 32, 33, 51, 52, 84]: return "metalloid"
    if n in [9, 17, 35, 53, 85, 117]: return "halogen"
    if n in [6, 7, 8, 15, 16, 34]: return "nonmetal"
    if n in [3, 11, 19, 37, 55, 87]: return "alkali"
    if n in [4, 12, 20, 38, 56, 88]: return "alkaline"
    if 57 <= n <= 71: return "lanthanide"
    if 89 <= n <= 103: return "actinide"
    if 104 <= n <= 112 or (21 <= n <= 30) or (39 <= n <= 48) or (72 <= n <= 80): return "transition"
    if (13 <= n <= 16) or (31 <= n <= 34) or (49 <= n <= 52) or (81 <= n <= 84): return "post_transition"
    if n >= 119: return "superactinide"
    return "unknown"

element_categories = [classify_element(n) for n in range(1, ELEMENT_COUNT + 1)]
unique_categories = sorted(set(element_categories))
category_counts = {cat: element_categories.count(cat) for cat in unique_categories}

# === Reserve image canvas ===
image_array = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)
used_pixels = np.zeros((HEIGHT, WIDTH), dtype=bool)
text_coords, border_coords = [], []
element_by_category = defaultdict(list)

# === Step 1: Reserve text label coordinates ===
for n in range(1, ELEMENT_COUNT + 1):
    row, col = (n - 1) // GRID_COLS, (n - 1) % GRID_COLS
    x0, y0 = col * CELL_W, row * CELL_H
    symbol = generate_element_symbol(n)
    label = f"{n}\n{symbol}"
    y_cursor = y0 + 4
    element_by_category[classify_element(n)].append((n, x0, y0))

    for line in label.split('\n'):
        bbox = font.getbbox(line)
        x_min, y_min, x_max, y_max = bbox
        width = x_max - x_min + 2 * TEXT_MARGIN
        height = y_max - y_min + 2 * TEXT_MARGIN
        x_cursor = x0 + (CELL_W - width) // 2

        mask = Image.new("1", (width, height), 0)
        draw = ImageDraw.Draw(mask)
        draw.text((TEXT_MARGIN - x_min, TEXT_MARGIN - y_min), line, fill=1, font=font)
        mask_array = np.array(mask)

        for dy in range(height):
            for dx in range(width):
                if mask_array[dy, dx] == 1:
                    px, py = x_cursor + dx, y_cursor + dy
                    if 0 <= px < WIDTH and 0 <= py < HEIGHT:
                        text_coords.append((py, px))
                        used_pixels[py, px] = True

        y_cursor += height

# === Step 2: Reserve 1px cell borders ===
for n in range(1, ELEMENT_COUNT + 1):
    row, col = (n - 1) // GRID_COLS, (n - 1) % GRID_COLS
    x0, y0 = col * CELL_W, row * CELL_H
    x1, y1 = x0 + CELL_W, y0 + CELL_H

    for x in range(x0, x1):
        for y in (y0, y1 - 1):  # top and bottom
            if not used_pixels[y, x]:
                border_coords.append((y, x))
                used_pixels[y, x] = True
    for y in range(y0 + 1, y1 - 1):
        for x in (x0, x1 - 1):  # left and right
            if not used_pixels[y, x]:
                border_coords.append((y, x))
                used_pixels[y, x] = True

# === Step 3: Assign RGBs to text and borders ===
colors_for_text = colors_sorted_brightness[:len(text_coords)]
colors_for_border = colors_sorted_brightness[len(text_coords):len(text_coords) + len(border_coords)]

for i, (py, px) in enumerate(text_coords):
    image_array[py, px] = colors_for_text[i]
for i, (py, px) in enumerate(border_coords):
    image_array[py, px] = colors_for_border[i]

used_color_set = set(tuple(c) for c in colors_for_text + colors_for_border)

# === Step 4: Fill remaining cell pixels, clustered by series ===
remaining_colors = [tuple(c) for c in colors_sorted_hsb if tuple(c) not in used_color_set]
color_index = 0

for category in unique_categories:
    for n, x0, y0 in element_by_category[category]:
        for y in range(y0, y0 + CELL_H):
            for x in range(x0, x0 + CELL_W):
                if not used_pixels[y, x]:
                    image_array[y, x] = remaining_colors[color_index]
                    used_pixels[y, x] = True
                    color_index += 1

# === Final Validation ===
#assert np.count_nonzero(used_pixels) == TOTAL_COLORS, "❌ Pixel count mismatch"
#assert color_index + len(text_coords) + len(border_coords) == TOTAL_COLORS, "❌ Color count mismatch"
print(np.count_nonzero(used_pixels))
print(color_index + len(text_coords) + len(border_coords))

# === Save image ===
Image.fromarray(image_array, 'RGB').save("periodic_table_series_clustered.png")
print("✅ Saved as 'periodic_table_series_clustered.png'")

HSB spiral

2025-05-18T09:50:55+02:00

I asked Chatgpt to put all rgb colors in an hsb spiral.


import numpy as np
from PIL import Image
import colorsys
import itertools

# --- CONFIG ---
IMAGE_SIZE = 4096
TOTAL_COLORS = IMAGE_SIZE * IMAGE_SIZE

# --- STEP 1: Generate All RGB Colors and Sort by HSB ---
print("Generating and sorting colors...")

def rgb_to_hsb(rgb):
    r, g, b = [x / 255.0 for x in rgb]
    h, s, v = colorsys.rgb_to_hsv(r, g, b)
    return (h, s, v)

# Generate all RGB colors
all_colors = np.array(list(itertools.product(range(256), repeat=3)), dtype=np.uint8)
sorted_colors = sorted(all_colors, key=rgb_to_hsb)

# --- STEP 2: Generate Spiral Coordinates (Corrected Version) ---
print("Generating correct spiral coordinates...")

def generate_spiral_coords(size):
    coords = np.zeros((size * size, 2), dtype=np.int32)
    x, y = size // 2, size // 2
    dx, dy = 1, 0  # Start by moving right
    steps = 1      # Number of steps in current leg
    idx = 0

    while idx < size * size:
        for _ in range(2):  # Each step count is repeated twice (x and y direction)
            for _ in range(steps):
                if 0 <= x < size and 0 <= y < size:
                    coords[idx] = (x, y)
                    idx += 1
                    if idx >= size * size:
                        return coords
                x += dx
                y += dy
            # Rotate direction: right → down → left → up
            dx, dy = -dy, dx
        steps += 1

    return coords

spiral_coords = generate_spiral_coords(IMAGE_SIZE)

# --- STEP 3: Paint the Image ---
print("Painting the image...")
image_array = np.zeros((IMAGE_SIZE, IMAGE_SIZE, 3), dtype=np.uint8)

for idx, (x, y) in enumerate(spiral_coords):
    image_array[y, x] = sorted_colors[idx]

# --- STEP 4: Save the Image ---
print("Saving image...")
image = Image.fromarray(image_array, 'RGB')
image.save("spiral_hsb_rgb_universe_fixed.png", "PNG")

print("Done! Image saved as 'spiral_hsb_rgb_universe_fixed.png'")

Surfer Dude

2025-05-18T00:13:30+02:00

I had a discussion with Chatgpt o4 about E8 in the context of An Exceptionally Simple Theory of Everything, and had it write some Python code to put it into allrgb:

import numpy as np
from PIL import Image
from sklearn.decomposition import PCA
from scipy.spatial import cKDTree
from skimage import color
import itertools
import colorsys

# --- CONFIG ---
IMAGE_SIZE = 4096
TOTAL_PIXELS = IMAGE_SIZE * IMAGE_SIZE

# --- STEP 1: Generate E8 root system ---
def generate_e8_roots():
    roots = []
    for i, j in itertools.combinations(range(8), 2):
        for s1 in [-1, 1]:
            for s2 in [-1, 1]:
                if s1 == s2:
                    vec = [0.0] * 8
                    vec[i], vec[j] = s1, s2
                    roots.append(vec)
    for signs in itertools.product([-0.5, 0.5], repeat=8):
        if sum(signs) == 0 and signs.count(-0.5) % 2 == 0:
            roots.append(list(signs))
    return np.array(roots)

# --- STEP 2: Project E8 roots to 2D via PCA ---
e8_roots = generate_e8_roots()
pca = PCA(n_components=2)
projected = pca.fit_transform(e8_roots)
projected -= projected.min(axis=0)
projected /= projected.max(axis=0)
projected *= (IMAGE_SIZE - 1)
e8_centers = projected.astype(np.int32)
NUM_MARKERS = len(e8_centers)

# --- STEP 3: Generate all 24-bit RGB colors and sort them ---
indices = np.arange(TOTAL_PIXELS, dtype=np.uint32)
np.random.seed(42)
np.random.shuffle(indices)

r = (indices >> 16) & 0xFF
g = (indices >> 8) & 0xFF
b = indices & 0xFF
rgb_colors = np.stack([r, g, b], axis=1).astype(np.uint8)

# --- STEP 4: Select 240 brightest colors as marker colors ---
brightness = 0.2126 * r + 0.7152 * g + 0.0722 * b
brightest_indices = np.argsort(-brightness)
marker_indices = brightest_indices[:NUM_MARKERS]
marker_colors = rgb_colors[marker_indices]

# Remove marker colors from pool
mask = np.ones(TOTAL_PIXELS, dtype=bool)
mask[marker_indices] = False
remaining_rgb = rgb_colors[mask]

# Convert to LAB and HSV for hybrid sorting
norm = remaining_rgb / 255.0
lab = color.rgb2lab(norm.reshape(-1, 1, 3)).reshape(-1, 3)
hsv = np.array([colorsys.rgb_to_hsv(*c) for c in norm])

# Sort remaining colors by hybrid key
hybrid_key = hsv[:, 0] * 100000 + lab[:, 0] * 100 + lab[:, 1]
sorted_indices = np.argsort(hybrid_key)
remaining_colors = remaining_rgb[sorted_indices]

# --- STEP 5: Assign each pixel to nearest E8 root ---
print("Computing pixel regions...")
coords = np.indices((IMAGE_SIZE, IMAGE_SIZE)).reshape(2, -1).T.astype(np.float32)
tree = cKDTree(e8_centers)
_, regions = tree.query(coords, k=1)

# --- STEP 6: Radially sort pixels within each region ---
coords_by_region = [[] for _ in range(NUM_MARKERS)]
for i, region in enumerate(regions):
    coords_by_region[region].append(coords[i])

ordered_coords = []
for i, coord_list in enumerate(coords_by_region):
    coord_list = np.array(coord_list)
    center = e8_centers[i]
    if len(coord_list) == 0:
        continue
    deltas = coord_list - center
    angles = np.arctan2(deltas[:, 1], deltas[:, 0])
    distances = np.linalg.norm(deltas, axis=1)
    sort_idx = np.lexsort((distances, angles))
    sorted_coords = coord_list[sort_idx]
    ordered_coords.append(sorted_coords)

coords_ordered = np.vstack(ordered_coords).astype(np.int32)

# --- STEP 7: Reserve marker coordinates (nearest to centers) ---
marker_coords = []
used = set()
for cx, cy in e8_centers:
    best = None
    best_dist = float('inf')
    for dx in range(-2, 3):
        for dy in range(-2, 3):
            x = int(np.clip(cx + dx, 0, IMAGE_SIZE - 1))
            y = int(np.clip(cy + dy, 0, IMAGE_SIZE - 1))
            coord = (x, y)
            if coord not in used:
                d = np.hypot(dx, dy)
                if d < best_dist:
                    best_dist = d
                    best = coord
    used.add(best)
    marker_coords.append(best)

# Remove marker_coords from ordered_coords and insert at front
used_set = set(marker_coords)
coords_filtered = [tuple(x) for x in coords_ordered if tuple(x) not in used_set]
final_coords = np.array(marker_coords + coords_filtered, dtype=np.int32)

# --- STEP 8: Build image ---
print("Mapping colors to pixels...")
image_array = np.zeros((IMAGE_SIZE, IMAGE_SIZE, 3), dtype=np.uint8)
all_colors = np.vstack((marker_colors, remaining_colors))
assert len(final_coords) == len(all_colors), "Mismatch in coordinate/color count"
for i, (x, y) in enumerate(final_coords):
    image_array[x, y] = all_colors[i]

# --- STEP 9: Save image ---
Image.fromarray(image_array, mode='RGB').save("e8_rgb_exact_4096.png")
print("✅ Saved: e8_rgb_exact_4096.png")

Standard deviation V4

2025-05-17T12:21:45+02:00

Sorted by "standard deviation"
Left part : the half-nearest of grayscale pixels
Right part : the half-nearest of colorful pixels

In the same collection :
More and more colored (V1)
Standard deviation V2
Standard deviation V3
Standard deviation V5

Standard deviation V3

2025-05-17T12:18:53+02:00

Sorted by "standard deviation"
From left to right, from grayscale to colorful

In the same collection :
More and more colored (V1)
Standard deviation V2
Standard deviation V4
Standard deviation V5

Standard deviation V2

2025-05-17T12:18:26+02:00

Sorted by "standard deviation"
From left to right, from grayscale to colorful

In the same collection :
More and more colored (V1)
Standard deviation V3
Standard deviation V4
Standard deviation V5

Square Buttons

2025-05-16T11:40:39+02:00

You can reach me at https://www.instagram.com/arcanesignature if you have questions.

Pop Squares

2025-05-16T11:38:49+02:00

You can reach me at https://www.instagram.com/arcanesignature if you have questions.

Furry thing

2025-05-16T11:07:41+02:00

You can reach me at https://www.instagram.com/arcanesignature if you have questions.

Clustered Hallucination (Gemini + ChatGPT)

2025-05-13T21:53:58+02:00

First, I prompted Gemini to write some Python code to generate allrgb images resembling ai hallucination. It did, but the code contained errors, which it refused to fix.

I then prompted Chatgpt to fix the code, which it did. I also prompted it to improve the results.

Lastly, I returned the corrected code back to Google by running it in Colab.


import numpy as np
from PIL import Image
import noise
import math
import random

# Constants
WIDTH = HEIGHT = 4096
TOTAL_COLORS = WIDTH * HEIGHT

# Step 1: Generate all RGB colors exactly once
print("Generating RGB color list...")
colors = np.zeros((TOTAL_COLORS, 3), dtype=np.uint8)
index = 0
for r in range(256):
    for g in range(256):
        for b in range(256):
            colors[index] = [r, g, b]
            index += 1

assert index == TOTAL_COLORS

# Step 2: Create spatial weights (hallucination-like structure)
print("Generating spatial weights...")
coords = []
scale1 = 6.5
scale2 = 17.0
octaves = 5

for y in range(HEIGHT):
    for x in range(WIDTH):
        u = (x - WIDTH / 2) / (WIDTH / 2)
        v = (y - HEIGHT / 2) / (HEIGHT / 2)

        # Multi-scale noise + trigonometric field
        n1 = noise.pnoise2(u * scale1, v * scale1, octaves=octaves)
        n2 = noise.pnoise2(u * scale2, v * scale2, octaves=octaves)
        trig = (
            np.sin(8 * (u + v) + n1)
            + np.cos(15 * u * v + n2)
            + np.sin((u**2 - v**2) * 12 + n1)
        )
        weight = trig + 0.3 * n1 + 0.2 * n2
        coords.append((weight, x, y))

coords.sort()

# Step 3: Cluster colors into perceptual groups (brightness + hue)
print("Clustering and reshuffling colors...")
def perceptual_cluster_key(color):
    r, g, b = color / 255.0
    brightness = 0.3 * r + 0.59 * g + 0.11 * b
    hue = math.atan2(math.sqrt(3) * (g - b), 2 * r - g - b)  # Improved hue estimation
    return (int(hue * 10) % 20, int(brightness * 10))  # Cluster bins

# Sort colors into chunks, then shuffle within and across clusters
clusters = {}
for color in colors:
    key = perceptual_cluster_key(color)
    clusters.setdefault(key, []).append(color)

# Shuffle colors within each cluster to add internal chaos
for group in clusters.values():
    random.shuffle(group)

# Collect and re-shuffle groups to increase global contrast
shuffled_cluster_keys = list(clusters.keys())
random.shuffle(shuffled_cluster_keys)

colors_clustered = []
for key in shuffled_cluster_keys:
    colors_clustered.extend(clusters[key])

colors = np.array(colors_clustered, dtype=np.uint8)
assert len(colors) == TOTAL_COLORS, "Color loss or duplication occurred."

# Step 4: Map each color to a spatially-sorted coordinate
print("Mapping hallucinated color field...")
image = Image.new("RGB", (WIDTH, HEIGHT))
pixels = image.load()

for i, (_, x, y) in enumerate(coords):
    pixels[x, y] = tuple(colors[i])

# Step 5: Save final image
output_filename = "hallucination_clustered_rgb_exact.png"
print(f"Saving to {output_filename}...")
image.save(output_filename, format="PNG")
print("Done! ✅ Image contains all 16,777,216 RGB colors exactly once, in full chaos.")

Quantum Wave Field Function (ChatGPT)

2025-05-13T11:07:43+02:00

A little chat with ChatGPT 4o returned the following Python code, which I then ran in Google Colab:

import numpy as np
from PIL import Image
import colorsys

# Image size
WIDTH = HEIGHT = 4096
TOTAL_COLORS = WIDTH * HEIGHT

# Step 1: Generate all RGB colors — exactly once
colors = np.zeros((TOTAL_COLORS, 3), dtype=np.uint8)
index = 0
for r in range(256):
    for g in range(256):
        for b in range(256):
            colors[index] = (r, g, b)
            index += 1

assert index == TOTAL_COLORS, "Color generation failed"

# Step 2: Generate quantum-inspired coordinate map
# Convert coordinates to "wave-interference energy" for sorting
coords = []
for y in range(HEIGHT):
    for x in range(WIDTH):
        # Normalize to [-1, 1]
        nx = (x - WIDTH / 2) / (WIDTH / 2)
        ny = (y - HEIGHT / 2) / (HEIGHT / 2)
        # Simulate quantum field interference (wave-like energy)
        wave = (
            np.sin(10 * nx) * np.cos(10 * ny)
            + np.sin(20 * nx * ny)
            + np.cos(15 * (nx**2 + ny**2))
        )
        coords.append((wave, x, y))

# Step 3: Sort pixels by wave function output
coords.sort()

# Step 4: Sort colors for aesthetic match (e.g., brightness)
brightness = np.dot(colors, [0.299, 0.587, 0.114])
sorted_color_indices = np.argsort(brightness)
colors_sorted = colors[sorted_color_indices]

# Step 5: Create image and assign each color to its sorted coordinate
img = Image.new("RGB", (WIDTH, HEIGHT))
pixels = img.load()

for (i, (_, x, y)) in enumerate(coords):
    pixels[x, y] = tuple(colors_sorted[i])

# Step 6: Save image losslessly
img.save("quantum_field_color_space.png", format="PNG")

Radial HSB RGB Visualization (ChatGPT)

2025-05-13T00:11:14+02:00

A little chat with ChatGPT 4o returned the following Python code, which I then ran in Google Colab:


import numpy as np
from PIL import Image
import colorsys

# Image size: 4096 x 4096 = 16,777,216 pixels
WIDTH = HEIGHT = 4096
CENTER_X, CENTER_Y = WIDTH // 2, HEIGHT // 2

# Generate all RGB colors
rgb_colors = np.array([[r, g, b] for r in range(256)
                                  for g in range(256)
                                  for b in range(256)], dtype=np.uint8)

# Convert RGB to HSB (HSV), normalized to 0–1 range
def rgb_to_hsv(rgb):
    return np.array([colorsys.rgb_to_hsv(r/255, g/255, b/255) for r, g, b in rgb])

# Convert HSB (HSV) back to RGB 0–255
def hsv_to_rgb(hsv):
    return np.array([colorsys.hsv_to_rgb(h, s, v) for h, s, v in hsv]) * 255

# Convert all RGB to HSV to enable sorting
hsv_colors = rgb_to_hsv(rgb_colors)

# Assign image coordinates to each color using radial HSB mapping
# Hue: angle around center
# Saturation: distance from center
# Brightness: vertical axis (top = bright, bottom = dark)

coords = []
for y in range(HEIGHT):
    for x in range(WIDTH):
        dx = x - CENTER_X
        dy = y - CENTER_Y
        r = np.hypot(dx, dy) / (WIDTH / 2)  # radius as saturation
        theta = (np.arctan2(dy, dx) + np.pi) / (2 * np.pi)  # hue from angle (0–1)
        v = 1.0 - (y / HEIGHT)  # brightness vertically
        coords.append((theta, r, v, x, y))

# Sort all RGB colors by their HSV mapping to the image layout
# Then place each color exactly once
coords.sort()  # sorts by hue, then sat, then bright

# Sort the HSV list the same way to match coordinates
hsv_sorted_idx = np.lexsort((hsv_colors[:, 2], hsv_colors[:, 1], hsv_colors[:, 0]))
rgb_sorted = rgb_colors[hsv_sorted_idx]

# Create image
image = Image.new("RGB", (WIDTH, HEIGHT))
pixels = image.load()

for (h, s, v, x, y), color in zip(coords, rgb_sorted):
    pixels[x, y] = tuple(color)

# Save image (lossless)
image.save("radial_hsb_rgb_visualization.png", "PNG")

CHALLENGE GAME FOR GEEKS #15

2025-05-13T00:09:38+02:00

Challenge n°15 : BOOK

This image can contain a whole book, with 262,144 characters ! (uppercases, lowercases and digits)

Objective n°1 :
Display the "fake" book (random characters) :
with BLACK : for the 8,388,608 DARKEST pixels
with WHITE : for the 8,388,608 LIGHEST pixels

Tutorial --> here

Objective n°2 :
Find the two words : "allRGB" & "16777216"

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

CHALLENGE GAME FOR GEEKS #14

2025-05-10T15:20:00+02:00

Challenge n°14 : The right way 2/2 (large)

The goal is to fill each square :
with BLACK : for VERTICAL lines
with WHITE : for HORIZONTAL lines

You will get : a message for challenge #13 (16x16 blocks) / a picture for challenge #14 (256x256 blocks)

Tutorial --> here

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

CHALLENGE GAME FOR GEEKS #13

2025-05-10T12:49:36+02:00

Challenge n°13 : The right way 1/2 (medium)

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

VIRUS

2025-05-08T12:22:56+02:00

☠ allRGB hacking colors ! ☠

allRGB logos

2025-05-08T12:17:13+02:00

allRGB logos

TANGRAM generator

2025-05-08T12:12:20+02:00

TANGRAM generator
Random of 10 different pieces and their negatives

+ some other variations --> here

In the same collection :
Galaxy of colors / Pixel-Art Generator

ONLY 3 COLORS - RGB (interlaced)

2025-05-06T13:40:11+02:00

ONLY 3 COLORS - RGB (interlaced)

+ other colors variations --> here

In the same collection :
Interlaced 8 colors
Interlaced 2 colors
ONLY 2 COLORS
ONLY ONE COLOR (red)
ONLY ONE COLOR (green)
ONLY ONE COLOR (blue)

RGB disco dance floor

2025-05-05T10:01:01+02:00

RGB disco dance floor

In the same collection :
ANIMATED fireworks

My anniversary

2025-04-25T11:42:52+02:00

Celebrating my first contribution, first entry, one year ago ! --> Mario

= 3145 x Mario
407 x full Mario
2738 x semi-transparent Mario

Also called "writing letter paper with header, ready to print !" :-)

Based on my other entry --> PURE RGB

Target Practice

2025-04-23T18:36:53+02:00

See my Instagram for more https://www.instagram.com/arcanesignature/

Magical Snail

2025-04-23T18:33:16+02:00

See my Instagram for more https://www.instagram.com/arcanesignature/

Cut Geodes

2025-04-23T18:32:12+02:00

See my Instagram for more https://www.instagram.com/arcanesignature/

Sandstone Slabs

2025-04-23T18:30:21+02:00

See my Instagram for more https://www.instagram.com/arcanesignature/

The Octagon

2025-04-23T18:26:17+02:00

Same technique as https://allrgb.com/lollipops

Paintbrush Diamonds

2025-04-22T19:49:12+02:00

Same technique as https://allrgb.com/lollipops

Hand-drawn Squares

2025-04-22T16:42:54+02:00

Same technique as https://allrgb.com/lollipops

ANIMATED allrgb 3D

2025-04-22T12:30:14+02:00

Each of 150 frames has got 16,777,216 unique colors

Lollipops

2025-04-19T10:53:24+02:00

See https://www.reddit.com/r/generative/comments/1jrhd2y/lollipops_all_2%C2%B2%E2%81%B4_colors/ for explanation.

Disco Katamari

2025-04-13T16:21:47+02:00

I start with one pixel and grow a tree from it like in Prim's algorithm, except edge weights aren't decided ahead of time. At each iteration I take the next edge that maximizes (minimize works too) the angle difference between the two angles f(next_node - starting_node) and f(current_node - starting_node), where f(x, y) = (np.arctan2(y, x) + spiral_factor * (x**2 + y**2) ** 2) % tau. The pixels are colored according to the order in which they were explored, using a space filling curve through RGB space from black to white. Oh, and the pixel neighborhoods are knight jumps.

See https://www.reddit.com/r/generative/comments/1jx6r1x/disco_katamari_all_rgb_colors_exactly_once/ for discussion.

Google Colab's First Successful Attempt

2025-04-03T13:52:04+02:00

Thanks to AI and Gemini's support using Google Colab, I finally made the 4096x4096 image that I believed in ACJ entries will work the first attempt time. If you help with more stuff using Google Gemini, it can help you in the best convenient way to make various images depending on your internet speed and RAM Disk. This is a post that I'm very satisfied of this image EVER. (8)

CHALLENGE GAME FOR GEEKS #12

2025-04-03T12:31:42+02:00

Challenge n°12 : Stacking squares

The goal is to display the 65 "grey" squares all together
You will get a secret message

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

Unrolled RGB Cube

2025-03-11T14:02:40+01:00

Imagine taking the RGB cube and "unrolling" it as if peeling a (square) apple, this is the result. All 12 permutations, which each include all colors, are included in the animation.

sorty14

2025-02-23T11:21:14+01:00

sorty13

2025-02-23T10:53:50+01:00

sorty12

2025-02-22T13:53:26+01:00

sorty11

2025-02-22T13:50:21+01:00

sorty10

2025-02-22T13:47:42+01:00

sorty9

2025-02-22T13:45:21+01:00

sorty8

2025-02-20T11:21:44+01:00

sorty7

2025-02-19T12:52:06+01:00

sorty6

2025-02-19T12:51:35+01:00

sorty5

2025-02-19T12:46:35+01:00

sorty4

2025-02-19T12:46:08+01:00

sorty3

2025-02-19T11:19:11+01:00

sorty2

2025-02-19T11:18:12+01:00

sorty1

2025-02-19T11:17:37+01:00

JxL's Astonishing #1

2025-02-10T10:10:31+01:00

From https://discord.com/channels/794206087879852103/824000991891554375/1284108786780471351

Custom artistic ambigram

2025-01-28T11:08:44+01:00

Each of 12 frames has got 16,777,216 unique colors
--> Ambigram

Eyes

2025-01-16T19:12:33+01:00

Eyes

CHALLENGE GAME FOR GEEKS #11

2025-01-15T21:37:44+01:00

Challenge n°11 : Coloring 2/2 (large)

The goal is to fill each of the 65536 tiles, with the top-left pixel color of each box.
You will get a photo-art image (256x256 blocks)

Tutorial --> here

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

CHALLENGE GAME FOR GEEKS #10

2025-01-15T21:25:32+01:00

Challenge n°10 : Coloring 1/2 (medium)

The goal is to fill each of the 256 tiles, with the top-left pixel color of each box.
You will get a pixel-art image (16x16 blocks)

Tutorial --> here

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

CHALLENGE GAME FOR GEEKS #9

2024-12-23T20:27:33+01:00

Challenge n°9 : Alpha channel

The goal is to remove the alpha channel ... to display the image and decrypt a sentence, with a good eyesight ;-)

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

Random Spread from Center

2024-12-15T15:07:14+01:00

Each pixel is colored depending on the order of activation in the random spread algorithm.

The algorithm assigns one of 3 states to pixels: deactivated, border and activated.

Starts at the middle (2048,2048), where the pixel is set to border.

Every iteration, one randomly chosen border pixel become activated, then sets its deactivated neighbors to border. Repeat until all pixels are activated.

(Uses "Suave" post mapping)

Z-Curve Iterated Permutation Index Map

2024-12-14T13:27:05+01:00

Each frame is the previous frame index mapped to the Z-Curve permutation, the first one being the identity permutation (all colors in order). From 0 to 10 iterations, because the pattern repeats every 11 iterations.

An explanation of permutation index mapping for 5 items: for A = [1, 3, 0, 4, 2]:

A⁰ = [0, 1, 2, 3, 4] (indentity)
A¹ = [1, 3, 0, 4, 2]
A² = [3, 4, 1, 2, 0] = A×A
A³ = [4, 2, 3, 0, 1] = A×A×A
A⁴ = [2, 0, 4, 1, 3] = A×A×A×A
A⁵ = [0, 1, 2, 3, 4] (repeats)

A³ = [A²[A[0]], A²[A[1]], A²[A[2]], A²[A[3]], A²[A[4]]], whereas A[n] is the nth item of A, first being 0.
Aⁿ × A^m = A^(n+m)
The last frame is also equivalent to A^-1, or the inverse of the Z-Curve map.
attempt 2

Hilbert Curve Squared

2024-12-14T13:08:57+01:00

The hilbert curve permutation index mapped to itself.
I was planning to make this an animation from iteration -5 to +5, but it was 200 MB... Because more iterations means more random noise.

Explanation of index map in the Z Curve version (animated)

CHALLENGE GAME FOR GEEKS #8

2024-12-09T12:20:19+01:00

Challenge n°8 : Disorder

Into this picture the pixels are put in order, excepted some of them.
Find them ... to reveal a famous emoji 👍

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

64 squares

2024-11-30T12:37:08+01:00

The algorithm used in "Touch of 127.5" applied to 64 different 64x64x64 sections of the RGB cube.

I made a Discord server for AllRGB, check it out here: https://discord.gg/XJfZ47K6kK

CHALLENGE GAME FOR GEEKS #7

2024-11-28T12:33:59+01:00

Challenge n°7 : Where's Wally / Waldo ?
--> other names

The goal is to search and find -->
Not only for geeks ;-)

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

CHALLENGE GAME FOR GEEKS #6

2024-11-20T14:49:51+01:00

Challenge n°6 : Difference

All the pieces are the same, excepted one which a thing into has changed or moved. Search and find it !

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

CHALLENGE GAME FOR GEEKS #5

2024-11-11T10:16:51+01:00

Challenge n°5 : Hidden message

The goal is to erase or display only the pixels which missing one or more RGB color (R=0 or G=0 or B=0)
... to reveal the hidden message

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

ULTIMATE CLONES V5

2024-11-04T13:51:49+01:00

ULTIMATE VERSION !
Previous versions --> V1 - V2 - V3 - V4

Clones V4

2024-11-04T13:49:30+01:00

Previous versions --> V1 - V2 - V3
ULTIMATE VERSION --> V5

Gallery slideshow

2024-11-04T12:32:45+01:00

Gallery slideshow

Hilbert Curve w/ MS alternating map

2024-10-30T22:40:23+01:00

In order, each pixel increments from the most significant bit to the least, alternating between blue, green and red. Then transformed into a Hilbert Curve.

Animated RGB

2024-10-29T17:58:20+01:00

Animated WEBP file test. Each frame has 65536 colors with all combinations of red and green, and 256 frames with a different blue value. Hopefully this counts as a submission.

CHALLENGE GAME FOR GEEKS #4

2024-10-29T09:40:02+01:00

Challenge n°4 : A-MAZE-ING picture

The goal is to fill the maze. You will get a full picture.
Be careful don't fill the wrong paths ...

Enter / Exit / Tutorial demo --> here

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

CHALLENGE GAME FOR GEEKS #3

2024-10-21T08:55:39+02:00

Challenge n°3 : Reverse engineering

The goal is to find the algorithm or formula which was used to build this picture. Sorted by ?
Rather simple but never published ;-)

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

ANIMATED thingy (R)EVOLUTION

2024-10-17T23:11:29+02:00

Each of 17 frames has got 16,777,216 unique colors

Final picture at last frame !

CHALLENGE GAME FOR GEEKS #2

2024-10-14T09:41:43+02:00

Challenge n°2 : Jigsaw Puzzle (7x7 / 49 pieces)

The goal is ... you know !
(some pieces have been rotated)
NOT a geek ? --> You can print & cut ;-)

Edit 06/2025 :
Need HELP ? --> Blank pieces + partial solution, in real size

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

Trigonometric Rainbow

2024-10-12T09:58:15+02:00

All pixels are shuffled, then each row sorted by trigonometric hue, which is defined by the angle from the gray point to the color.
And finally, each column is sorted by the distance to the color assigned to that column, which is a RGB color that has a constant distance to gray, the column position varying the angle around gray. 0° red, 120° green, 240° blue.
The last row is mostly just black and white pixels.

Tertiary Sort

2024-10-12T08:49:00+02:00

Colors are sorted by the rearrangement order of their RGB channel values when sorted to increasing order*, or, sorted by hue in which the hue value only stays unchanged if it's a multiple of 60°, and if not, then the value is set to the midpoint between the nearest multiples of 60°.

Example: [125, 23, 77] would become [2, 0, 1]. 0 when the value is the lowest, 2 when the value is the highest, 1 when neither.

The sort order in this image: 200, 210, 220, 120, 020, 021, 022, 012, 002, 102, 202, 201, 000 (grayscale)

TRIVIA: for each group with only 0s and 2s, they contain 32,640 colors. With all three digits, 2,763,520 colors. For grayscale, 256 colors.

Yawn

2024-10-11T23:08:30+02:00

Same algorithm as my other cat image. 6.94 billion iterations, resulting in 0.9% of iterations doing swaps, for a total of 62,326,101 swapped pixel pairs.

Cat

2024-10-11T15:34:37+02:00

Initialize random allRGB permutation, and randomly pick pairs of pixels to swap, if the resulting sum of squares of distances from the target pixels becomes smaller. Distances are calculated in the Lab colorspace, using the metric from: https://www.compuphase.com/cmetric.htm

In the allRGB image to get the source pixel to compare, pixels are averaged from a 3x3 area, in the Lab colorspace, with an approximate gaussian weighting: weight 4 for the center, 2 for the edges, and 1 for the corners. And then I ran this for a couple days, and it did 6.95 billion iterations. 0.9% of the iterations resulted in swaps, for a total of 62,338,350 swapped pixels.

Infinite transformations

2024-10-10T10:55:06+02:00

Each of 240 frames has got 16,777,216 unique colors
12 different transitions + last drawing to first drawing

Hue over brightness descending

2024-10-04T09:38:52+02:00

Similar algorithm as https://allrgb.com/color-wheel-v2 , but going top-down instead of inside-outward

Brightest colors at the top
An even distribution of hues and saturations are selected when there are more than enough for the current row
Prominent rays are visible along hues with multiple saturations

Recursive rectangle sections

2024-10-04T09:34:56+02:00

Start with a square

Split the square into 8 vertical sections, one per 3-bit color, with black on the top left, white on the bottom left, and RGB / CMY following them respectively, affecting the most-significant bit not affected by a bigger section
Recurse, but with square sub-sections, with black on the top left and white on the top right
Recurse with squares again

Grainy

2024-10-03T08:11:07+02:00

Smooth tiled RGB texture, but random pixels get swapped 2,097,152 times (1/8 of pixel count).

Crazy XOR Party

2024-10-03T08:09:46+02:00

256 tiles with a colorful bitwise XOR (p ^ q) pattern. Each of them have a different blue value distribution, and the tiles are reflective.

CHALLENGE GAME FOR GEEKS #1

2024-10-03T08:08:20+02:00

Challenge n°1 : Connect the dots !

The goal is to connect (with lines or by hand) the 256 greyscale pixels IN ORDER.

You will get a drawing shape (like the paper game for kids)

Need HELP ? The starting & ending dots are exactly inside --> this area

Submit your solution (with your nickname) at : samuel35allrgb@outlook.com

For group discussions, help, comments, feedback, suggestions, ... join the DISCORD server
+ social networks of allRGB

↓↓↓ THE WINNERS ↓↓↓
(click the link above if iframe does not load)

Custom art RGB ping-pong girl

2024-10-02T16:08:39+02:00

Custom art RGB ping-pong girl

Dozen Patterns 2

2024-10-01T00:09:27+02:00

12 iterations of recursive 2x2 pattern layering, each iteration being a different pattern. The patterns are listed below, from least to most significant:

0123, 0132, 0213, 0231, 0312, 0321, 1023, 1032, 1203, 1302, 2013, 2103

Same as Dozen Patterns 1, except the layers of iterations are separated by additive intensity. 1, 4, 16, 64.

Dozen Patterns 1

2024-09-30T23:28:26+02:00

12 iterations of recursive 2x2 pattern layering, each iteration being a different pattern. The patterns are listed below, from least to most significant:

0123, 0132, 0213, 0231, 0312, 0321, 1023, 1032, 1203, 1302, 2013, 2103

The 12 layers of iterations are separated by channel. Blue, green, red.

ANIMATED The impossible infinite staircase

2024-09-30T21:25:28+02:00

Each of 200 (!) frames has got 16,777,216 unique colors
(with alpha channels)

Half and half and half and...

2024-09-25T09:35:28+02:00

Starting with a single black pixel, copy the image, turn on one bit on one of the copies, repeat until there's no bits left

Custom art pencil signature - V3

2024-09-24T21:03:40+02:00

Custom art pencil signature - V3

Custom art pencil signature - V2

2024-09-23T23:31:43+02:00

Custom art pencil signature - V2

Custom art pencil signature - V1

2024-09-23T23:30:40+02:00

Custom art pencil signature - V1

Holes

2024-09-18T23:55:21+02:00

At center : big hole (grey) + small hole (black)

Subway

2024-09-18T22:31:17+02:00

(without any generator software)

ANIMATED loading gradients

2024-09-10T19:15:38+02:00

Each of 42 frames has got 16,777,216 unique colors

12 custom gradients

2024-09-10T11:29:26+02:00

Each of 12 frames has got 16,777,216 unique colors

Custom, additional gradients around and at middle cross

Curvy Rainbow

2024-09-07T21:30:04+02:00

Colors are shuffled, then each column sorted by luma, then each row sorted my HSV/L hue.

Glitch Stripes

2024-09-07T19:27:29+02:00

All colors sorted by the arithmetic expression R % G % B. The "%" is the modulo operator.

MS Z-curve map

2024-09-06T14:36:05+02:00

Each pixel mapped to Z curve in the RGB color cube, starting with the most significant bit.

Simple Perfect Squared Squares, Order 28.

2024-09-02T10:19:04+02:00

Simple Perfect Squared Squares, Order 28.

Simple Perfect Squared Squares, Order 27.

2024-09-02T09:57:51+02:00

Simple Perfect Squared Squares, Order 27.

Simple Perfect Squared Squares, Order 26.

2024-09-02T09:51:26+02:00

Simple Perfect Squared Squares, Order 26.

Simple Perfect Squared Squares, Order 25.

2024-09-02T09:43:50+02:00

Simple Perfect Squared Squares, Order 25.

ANIMATED Game of Life

2024-08-19T09:37:32+02:00

Each of 35 frames has got 16,777,216 unique colors

The admin (ACJ) made the wish to me to have an animated "Game of life" in the gallery

This is my version with the logo allRGB ;-)

Game of life of only one tile : click here

ANIMATED infinite fractal (final)

2024-08-17T20:28:59+02:00

Each of 20 frames has got 16,777,216 unique colors

Smallest Warhol of the World

2024-08-14T10:56:54+02:00

12 KB / 12884 bytes

ANIMATED infinite fractal (beta)

2024-08-09T11:02:29+02:00

Each of 25 frames has got 16,777,216 unique colors
Beta version with alpha channels

Final version (lower quality, small file, without alpha channel) : here

ANIMATED hypnotic

2024-08-08T09:58:40+02:00

Each of 27 frames has got 16,777,216 unique colors

From the file Spiral by ACJ

ANIMATED fireworks

2024-08-06T11:02:12+02:00

Each of 6 frames has got 16,777,216 unique colors
included 6 different dominant colors (red->purple->darkblue->lightblue->green->yellow)

The preview frames can be seen : here
(with alpha channels)

In the same collection :
RGB disco dance floor

JxL's Amazing #3

2024-08-01T08:54:19+02:00

JxL AllRGB conversion #3 (check filesize)

JxL's Amazing #2

2024-07-31T21:46:24+02:00

JxL AllRGB conversion #2 (check filesize)

JxL's Amazing #1

2024-07-31T11:20:00+02:00

JxL AllRGB Conversion #1 (check filesize)

CIE Lab Sort

2024-07-29T21:39:29+02:00

Shuffled array of all RGB colors, each row being sorted by the a value, then each column being sorted by the b value.

Grayscale colors are located around (1850, 1960)

More and more colored

2024-07-22T11:03:57+02:00

From left to right, from grayscale to colorful

Sorted by "standard deviation"
then scramble columns
then cut a bit at left & right, rearranged to 2 squares focused to the center to make a comprehensive visual comparison.

BONUS : Animated GIF

In the same collection :
Standard deviation V2
Standard deviation V3
Standard deviation V4
Standard deviation V5

Spectrum analysis

2024-07-10T13:41:51+02:00

Spectrum analysis of 256 different pieces

In the same collection :
MUSIC v1
Absorption Spectra v2 - converted
tutti frutti - converted

ANIMATED increase/decrease

2024-07-03T18:14:23+02:00

Each of 64 frames has got 16,777,216 unique colors

(with masks / alpha channels)

64 images = only 590 KB !
Note : Size of the full 32nd frame is only 7 KB, which is close to the smallest file of the website (Small, smaller, this)

ANIMATED Scramble

2024-07-02T10:26:05+02:00

Each of 32 frames has got 16,777,216 unique colors !

First ANIMATED 16,777,216 colors

2024-06-30T21:45:41+02:00

Each of 8 frames has got 16,777,216 unique colors !
Check here

Tested on most popular web PC browsers
Total size only 1 MB
:-)

Thingy 45 Degrees - Blue/Magenta to Green/Yellow

2024-06-30T10:33:43+02:00

Like "Thingy 45 Degrees - Red to Cyan," this version instead goes on the axis from blue/magenta to green/yellow.

Image Licence: Public Domain (CC0).

Thingy 45 Degrees - Green/Cyan to Red/Magenta

2024-06-30T10:32:48+02:00

Like "Thingy 45 Degrees - Red to Cyan," this version instead goes on the axis from green/cyan to red/magenta.

Image Licence: Public Domain (CC0).

Thingy 45 Degrees - Red/Yellow to Blue/Cyan

2024-06-30T10:30:16+02:00

Like "Thingy 45 Degrees - Red to Cyan," this version instead goes on the axis from red/yellow to blue/cyan.

Image Licence: Public Domain (CC0).

Thingy 45 Degrees - Blue to Yellow

2024-06-30T10:29:15+02:00

Like "Thingy 45 Degrees - Red to Cyan," this version instead goes on the axis from blue/black to white/yellow.

Image Licence: Public Domain (CC0).

Thingy 45 Degrees - Green to Magenta

2024-06-30T10:28:39+02:00

Like "Thingy 45 Degrees - Red to Cyan," this version instead goes on the axis from green/black to white/magenta.

Image Licence: Public Domain (CC0).

Thingy 45 Degrees - Red to Cyan

2024-06-30T10:27:38+02:00

This is a version of Thingy, where instead of slicing the RGB cube into 256 layers, it is instead sliced diagonally on the axis from red/black to cyan/white into 511 different layers. Resulting layers that don't fit fully at the right sides of their rows wrap around to the left side of the next row. Image Licence: Public Domain (CC0).

Celebrating tribute to 16th anniversary of allRGB ! 3/3

2024-06-21T12:22:37+02:00

3/3
Subtitle :
Real Clones (with logo)

Celebrating tribute to 16th anniversary of allRGB ! 2/3

2024-06-21T12:19:17+02:00

2/3
Subtitle :
Real Clones (without logo)

Celebrating tribute to 16th anniversary of allRGB ! 1/3

2024-06-21T12:17:37+02:00

1/3
Subtitle :
Nearly Clones

Small carpet

2024-06-20T16:32:55+02:00

Small file < 1 MB

In the same collection :
Carpet

ONLY ONE COLOR - blue

2024-06-18T11:18:31+02:00

ONLY ONE COLOR
--> blue

In the same collection :
Interlaced 8 colors
Interlaced 3 colors (RGB)
Interlaced 2 colors
ONLY 2 COLORS
ONLY ONE COLOR (red)
ONLY ONE COLOR (green)

ONLY ONE COLOR - green

2024-06-18T11:17:32+02:00

ONLY ONE COLOR
--> green

In the same collection :
Interlaced 8 colors
Interlaced 3 colors (RGB)
Interlaced 2 colors
ONLY 2 COLORS
ONLY ONE COLOR (red)
ONLY ONE COLOR (blue)

ONLY ONE COLOR - red

2024-06-18T11:13:10+02:00

ONLY ONE COLOR
--> red

In the same collection :
Interlaced 8 colors
Interlaced 3 colors (RGB)
Interlaced 2 colors
ONLY 2 COLORS
ONLY ONE COLOR (green)
ONLY ONE COLOR (blue)

ONLY 2 COLORS - red & blue

2024-06-18T10:57:33+02:00

ONLY 2 COLORS
red & blue

In the same collection :
Interlaced 8 colors
Interlaced 3 colors (RGB)
Interlaced 2 colors
ONLY ONE COLOR (red)
ONLY ONE COLOR (green)
ONLY ONE COLOR (blue)

ONLY 2 COLORS - Interlaced checkered pattern

2024-06-18T10:46:02+02:00

ONLY 2 COLORS
Interlaced checkered pattern

In the same collection :
Interlaced 8 colors
Interlaced 3 colors (RGB)
ONLY 2 COLORS
ONLY ONE COLOR (red)
ONLY ONE COLOR (green)
ONLY ONE COLOR (blue)

RGB Paint

2024-06-18T09:48:40+02:00

Painting effect

RGBig pixels

2024-06-17T09:33:46+02:00

Rearrangement of the 65536 tiles of this image : wikipedia

Pillars

2024-06-11T17:28:42+02:00

James Webb Space Telescope NIRCam image of the Pillars of Creation.

Created with an alpha channel by iterating pixels in brightness order, searching RGBA space for the closest match to RGB*A for each pixel with every RGB unique.

Image Credit: NASA, ESA, CSA, Space Telescope Science Institute (STScI)
Original Image: https://stsci-opo.org/STScI-01GGF8H15VZ09MET9HFBRQX4S3.png
Website: https://webbtelescope.org/images

Light Diffraction 2/2

2024-06-10T11:00:17+02:00

Light Diffraction 2/2

Light Diffraction 1/2

2024-06-10T10:59:39+02:00

Light Diffraction 1/2

Color wheel & standard palette

2024-06-07T17:04:24+02:00

Color wheel & standard palette

Advertising Merchandising

2024-06-03T10:01:46+02:00

Gift for allRGB.com !
Several days of work ;-)
(NOT FOR SALE)

+ 48 other styles :
bit.ly/allrgb
bit.ly/allrgbGIF

All Eyes on Rafah

2024-06-02T13:13:22+02:00

All Eyes on Rafah

THE PERFECT TWINS

2024-05-27T22:37:45+02:00

TWINS
FOUR PERFECT GRADIENT SQUARES

+ 48 other variations : here

LSH Hilbert

2024-05-25T18:48:49+02:00

Colors first sorted in LSH order, then placed onto the image following a Hilbert curve.

Image Licence: Public Domain (CC0).

LHS Hilbert

2024-05-25T18:43:46+02:00

Colors first sorted in LHS order, then placed onto the image following a Hilbert curve.

Image Licence: Public Domain (CC0).

SLH Hilbert

2024-05-25T18:38:20+02:00

Colors first sorted in SLH order, then placed onto the image following a Hilbert curve.

Image Licence: Public Domain (CC0).

SHL Hilbert

2024-05-25T18:35:47+02:00

Colors first sorted in SHL order, then placed onto the image following a Hilbert curve.

Image Licence: Public Domain (CC0).

HSL Hilbert

2024-05-25T18:24:11+02:00

Colors first sorted in HSL order, then placed onto the image following a Hilbert curve.

Image Licence: Public Domain (CC0).

HLS Hilbert

2024-05-25T18:20:03+02:00

Colors first sorted in HLS order, then placed onto the image following a Hilbert curve.

Image Licence: Public Domain (CC0).

PURE GRADIENT

2024-05-25T15:25:24+02:00

Full refined gradient focused to the center

+ 96 other variations : here

In the same collection :
PURE COLORS
PURE RGB
PURE GRADIENT
PURE Additive RGB colors (v3)

FULL GRADIENT

2024-05-25T15:21:03+02:00

FULL GRADIENT

ULTIMATE GRADIENT

2024-05-25T15:12:19+02:00

ULTIMATE GRADIENT

RGB goes to heaven

2024-05-25T15:01:37+02:00

Multi gradients dark to light to colors ... to heaven :-)

PURE RGB + 96 flags

2024-05-22T08:21:44+02:00

The 3 full refined RGB colors focused to the center

+ 96 flags / variations : here

In the same collection :
PURE COLORS
PURE RGB
PURE GRADIENT
PURE Additive RGB colors (v3)

PURE COLORS

2024-05-19T10:09:03+02:00

The 8 full refined standard colors focused to the center

In the same collection :
PURE COLORS
PURE RGB
PURE GRADIENT
PURE Additive RGB colors (v3)

RGBIZE ME

2024-05-18T09:36:06+02:00

Who wants to be RGBized ?
;-)

Still and always without any generator software, like all my entries
Only collages, montages, assemblies, layering

BEHIND THE SCENES

I made a tutorial : here
ENJOY !

WITHOUT SOFTWARE (beta)

2024-05-16T13:00:25+02:00

First attempt building a true photo WITHOUT USING ANY SOFTWARE ! (excepting text editor like Notepad+)

The main interest of this concept is that the unique colors/pixels of the original photo remain strictly unchanged !

Here are the steps, I hope my english language will be understandable.

STEP 1 :
Choose any photo
Convert it into comprehensive ASCII format
-> PIC1_ASCII.txt
PIC1 (this example) had got about only 2 millions of unique colors
and about 9 millions pixels, so 9M RGB values but NOT unique

STEP 2 :
Search & Replace all duplicates RGB values [xxx,yyy,zzz] by any same string : e.g. "pixels_to_add"
-> PIC2_ASCII.txt
PIC2 has got 2M unique RGB values + 7M distributed strings "pixels_to_add" inside

STEP 3 : (finding pixels to add)
Take PIC1
Search & Delete all duplicates RGB values [xxx,yyy,zzz]
PIC1 has got now 2M unique values
Append it with ALL existing RGB values [000,000,000] to [255,255,255]
-> PIC3_ASCII.txt
PIC3 has got 18,7M values (2M+16,7M)
Search & Delete all duplicates RGB values [xxx,yyy,zzz]
PIC3 has got now 16,7M values (2M unchanged unique + 14,7M unique)
Delete 2M first values
-> PIC3_ASCII.txt
PIC3 has got now 14,7M unique values

STEP 4 :
Take PIC2
Search & Replace incrementially the strings "pixels_to_add" by the PIC3 list

END

The last STEP should be : try to replace the RGB values as near as possible than the original values, but I don't have enough RAM memory in order to do it :-(
So I had to use random values, so not pretty, so attempt not finished (beta)

The more unique colors there are into the original photo, better the result will be !

Flowers

2024-05-16T08:56:40+02:00

Still and always without any generator software, like all my entries
Only collages, montages, assemblies, layering
(But not possible all the time to make maximum size with this method)

First attempt with an existing true photo
Maybe less perfect than generators softwares but more rewarding, deserving :-)

Carpet

2024-05-14T21:48:44+02:00

All pieces are different
65536 combinations

DO NOT VACUUM ;-)

In the same collection :
Small carpet

Northern Lights (Aurora Borealis)

2024-05-14T10:01:45+02:00

Northern Lights (Aurora Borealis)

STAR WARS

2024-05-13T09:30:33+02:00

STAR WARS

Polar Lightness

2024-05-10T10:41:59+02:00

Colors sorted by perceptual lightness, assigned to pixel coordinates sorted by theta, then r with an origin of (2048, 4000)

Galaxy of colors / Pixel-Art Generator

2024-05-10T10:37:08+02:00

Random of 4 different levels :

64 tiles 256x256
256 tiles 128x128
1024 tiles 64x64
4096 tiles 32x32

One version among billions of billions …

With different zooms we can see some pixel-art shapes, animals, characters, … With imagination you can see lots of ! ;-)

In the same collection :
TANGRAM generator

Earth

2024-05-07T11:27:37+02:00

Earth

TETRIS 3D

2024-05-02T10:05:50+02:00

TETRIS 3D

ULTIMATE PALETTE 256 COLORS

2024-05-01T09:47:06+02:00

No gradient colors / True palette 256

Additive Palette

2024-04-30T18:25:14+02:00

All additive standard colors !
Pick what you need
256*256 each

Additive RGB colors v1

2024-04-29T11:48:36+02:00

v1 : FAKE FALSE

v2 : REAL TRUE

v3 : REAL TRUE + PURE additive colors at the center
(My spent time record, several days of work !)

Multicolor Scrapbooking

2024-04-29T11:18:05+02:00

Multicolor Scrapbooking

Hue Sort in XOR

2024-04-27T19:45:08+02:00

All colors are sorted by HSV hue, and index mapped to bitwise XOR.

Luminance Sort in XOR

2024-04-27T19:41:09+02:00

All colors are sorted by luminance, and index mapped to bitwise XOR.

Multi-Size-Random-Palettes

2024-04-27T19:21:05+02:00

10 levels :

512*512
256*256
128*128
64*64
32*32
16*16
8*8
4*4
2*2
1*1 - zoom for small surprise inside ;-)

Infinite Reflection

2024-04-27T19:13:12+02:00

3 different pseudo-grayscale

Polygonal Animals

2024-04-26T09:41:30+02:00

Polygonal Animals

Me and sport

2024-04-26T09:40:59+02:00

3 different pseudo-grayscale

Animal

2024-04-25T09:08:21+02:00

Animal

Touch of colors

2024-04-24T08:49:43+02:00

Touch of colors

allRGB

2024-04-23T08:16:50+02:00

allRGB

Pure Clean Visual Art

2024-04-20T13:20:53+02:00

Just look

MATRIX

2024-04-19T23:05:45+02:00

The Matrix has you

We are Anonymous

2024-04-19T09:28:46+02:00

We are Anonymous
We are Legion
We do not forget
We do not forgive
Expect us

PAC-MAN 8 colors

2024-04-18T12:04:36+02:00

8 colors … really ?

Recursive Stripes 2

2024-04-16T11:07:02+02:00

This one is similar to Recursive Stripes, except it has the initial 6-bit colors sorted by HSL within their columns, with the exception of the reddest colors column which wraps around to have its pinks at the top so it better matches the other color columns, and the black and white columns which have maintained the same order as in Recursive Stripes to be more balanced looking. Image Licence: Public Domain (CC0).

Recursive Radial Split

2024-04-16T11:01:18+02:00

Similar to my previous entry, this one uses the same iterative process, however in this case, the 6-bit color base template has been arranged differently.

Image Licence: Public Domain (CC0).

Inverted Hilbert Curve Map

2024-04-16T11:00:13+02:00

This is the inversion of the hilbert curve: all pixels replace the pixel that would replace them in the normal hilbert curve.

Axial Recursive 3-Bit

2024-04-16T10:54:55+02:00

X and Y axis, starting from top left, has eight colors in this order: black, blue, red, magenta, green, cyan, yellow, white; X being the dominant (brighter) axis.
And it's recursive, with 4 iterations.

(when i was uploading i noticed there was a similar version, this one the order is based on luminance)

Unlerp Sort

2024-04-16T10:48:16+02:00

All colors sorted by the linear interpolation of Green between Red and Blue using the formula: (G - R) / (B - R) If B < R, then the output will turn negative. If R = G = B, then the output will be 0.

Recursive Stripes

2024-04-15T10:50:20+02:00

Inspired by entries such as Recursive Squares and Iterative, this entry differs in that it starts with a base pattern with all the 6-bit colors arranged into 8 groupings, based on which 3-bit color they are closest to. These groupings are then sorted within their 8 columns so that a given color falls into the row closest to the same order of 3-bit colors, except transposed.

This image was created by iteratively overlaying the 8x8 blackest corner over an 8:1 scale and 4x multiplied value version of itself. In total, there are 3 levels of nesting.

Fun fact: With just this method alone of arranging the 6-bit color set in any order into a square and overlaying it on itself iteratively, there are 64! (~1.2688693e+89) possible entries. To put that in perspective, it is estimated that there are around 1.0e+80 atoms in the observable universe.

Image Licence: Public Domain (CC0).

Mario 8 colors 12x16 blocks

2024-04-15T10:11:14+02:00

8 colors … really ?
12×16 blocks … really ?

EBU Color Bars

2024-04-09T10:02:51+02:00

All colors shuffled, but seperated into eight groups depending on the color they're closer to: white, yellow, cyan, magenta, green, red, blue, black.
Each group is a 256x4096 vertical bar.

Triangle -> Tetrahedron

2024-04-09T09:51:44+02:00

I made an algorithm that maps the RGB color space into a tetahedron pattern. There are 766 layers, and the colors in every layer add up to the same amount. The first layer only has black. In order, the amount of colors per layer are: 1, 3, 6, 10, 15, 21, ... Basically the triangle numbers.
Every layer starts with blue and transitions to green in one cycle, and transitions to red the more the gradient cycles (you can see it if you zoom in).
But for layers from index 256 to 765, some colors are excluded since they're out of bounds.
Because each layer's color adds up to the same amount, they're technically sorted by Average.

Not just that, but the input index is also mapped into a triangle pattern. The same as tetrahedron, but in two dimensions. That's why the color sequence goes diagonally.

Trivia: index 2,829,056 (x: 1953, y: 425), being color [256,0,0] is the first color that is off bounds, causing it to be ignored.

Rainbow Smoke Algorithm

2024-03-30T12:26:03+01:00

I am well aware that this might not qualify as "different from the existing entries on the website", however, this feels like the fastest way to test wether or not my implementation of this algorithm was correct or not.

Sliced

2024-03-26T08:57:39+01:00

All 24-bit colors but split into 2 triangles. The bottom left triangle has the first 8,390,656 colors. The top right triangle has the last 8,386,560. The first color of the top right triangle is [128, 7, 255].

Progressive Group Shuffle

2024-03-20T08:25:21+01:00

All colors are split into 64 groups, in a random order.
Colors of each group will also shuffle, the shuffling mix/probability being determined by its group's position in the list, for example: first group is sorted by hex, last group is completely randomized.

Sorted by Distance to Red

2024-03-19T19:02:39+01:00

Every color sorted by its distance to red [255, 0, 0], increasing order.

Pattern

2024-03-10T12:55:34+01:00

Quick one: Some sorting and rotation.

Argentière - Provence

2024-02-27T11:30:31+01:00

Underground city

2024-02-25T11:35:43+01:00

Life

2024-02-25T11:32:21+01:00

https://conwaylife.com/wiki/Main_Page

Colorful face

2024-01-16T20:27:00+01:00

Lyapunov

2024-01-16T20:22:15+01:00

A Lyapunov fractal with sequence BBBABBAAAAAA
https://en.wikipedia.org/wiki/Lyapunov_fractal

Small, smaller, this

2023-12-12T12:14:40+01:00

I thought let's see. what compression now a days can do.... Jpeg XL It can be viewed in Safari on MacOS and Firefox but you have to enable jpeg-xl support

Dither Map

2023-12-10T23:39:26+01:00

Fractal layering variant

Hue, Saturation, Value

2023-12-09T12:23:48+01:00

Every shade of the Hue wheel in H -> S -> V order.

Iteration is 1 full hue cycle.
MIN and MAX are the limits applied to all 3 RGB channels. 1 interation has (MAX - MIN) * 6 colors.
Note that for each color in an interation there will be at least 2 channels that are equal to MIN and MAX.

Starting from 1,530 colors in an iteration, every iteration will add MIN by 1, thus decreasing the Saturation and subtracting the colors per iteration by 6.

When saturation becomes zero, or when MIN = MAX, the previous process will loop all over again, which will subtract MAX by 1 and reset colors per iteration where the starting point (1,530) becomes 6 less. This will change the Value.

All of this summed up result in exactly 16,777,216 colors.

1530 + 1524 + 1518 + ... = (255² + 255) * 3 = 195,840 (255² + 255) * 3 + (254² + 254) * 3 + (253² + 253) * 3 = 255 * 256 * 257 = 16,776,960

16,776,960 + 256 = 16,777,216 --> Extra 256 are from gray colors where R = G = B.

Image generated in JavaScript

Sand circles

2023-11-09T19:07:36+01:00

Expanding circles of color become trails of sand. Created using this program, which I wrote: https://github.com/isaacg1/colors/

OkHue

2023-11-04T11:13:34+01:00

All the sRGB colours in a Hilbert curve, sorted by their hue* in Björn Ottosson's Oklab colourspace.

The hues were computed as (M-script based syntax):

W = M2*(M1*X).^(1/3)
for each column w in W: atan2(w(3),w(2))

where:

X is a 3x16777216 matrix of sRGB colours converted to linear RGB,
M1 and M2 as defined in Björn's programming sample in his blog post.

Generated as a farbfeld image with C++ and the Eigen library, then converted to PNG.

*: I'm less satisfied with this one. There were 23 hue value collisions when I originally ran my generator, and my attempts to fix it only caused more collisions. I'm not sure how many are actual collisions or just floating-point error, so just I used the L component (lightness, w(1)) as a tiebreaker. I may revisit this in the future...

Plan OkB

2023-11-04T11:09:08+01:00

All the sRGB colours in a Hilbert curve, sorted by their b component (blue vs. yellow) in Björn Ottosson's Oklab colourspace.

The components were computed as (M-script syntax) W = M2(3,:)*(M1*X).^(1/3), where:

X is a 3x16777216 matrix of sRGB colours converted to linear RGB,
M1 and M2 as defined in Björn's programming sample in his blog post.

The blockiness near the zero point in the left middle is not computation error, I checked using ISymPy.

I will not upload one for the L (lightness) component, as it looks very similar to Distance From OkZero.

Generated as a farbfeld image with C++ and the Eigen library, then converted to PNG.

Plan OkA

2023-11-04T11:01:59+01:00

All the sRGB colours in a Hilbert curve, sorted by their a component (green vs. red) in Björn Ottosson's Oklab colourspace.

The components were computed as (M-script syntax) W = M2(2,:)*(M1*X).^(1/3), where:

X is a 3x16777216 matrix of sRGB colours converted to linear RGB,
M1 and M2 as defined in Björn's programming sample in his blog post.

The blockiness near the zero point in the right middle is not computation error, I checked using ISymPy.

I will not upload one for the L (lightness) component, as it looks very similar to Distance From OkZero.

Generated as a farbfeld image with C++ and the Eigen library, then converted to PNG.

OkChroma

2023-11-03T09:19:26+01:00

All the sRGB colours in a Hilbert curve, sorted by their chroma/saturation/intensity in Björn Ottosson's Oklab colourspace.

Computing was similar to my previous Distance From OkZero entry, but with the L component fixed to 0 (M-script based syntax):

W = M2(2:3,:)*(M1*X).^(1/3)
for each column w in W: w'*w

where:

X is a 3x16777216 matrix of sRGB colours converted to linear RGB,
M1 and M2 as defined in Björn's programming sample in his blog post.

The blockiness in the bottom left corner is not computation error, I checked using ISymPy.

Generated as a farbfeld image with C++ and the Eigen library, then converted to PNG.

Distance From OkZero

2023-10-27T13:05:40+02:00

All the sRGB colours in a Hilbert curve, sorted by their distance from {0,0,0} in Björn Ottosson's Oklab colourspace.

The (squares of the) distances were computed as (M-script based syntax):

W = L'*(M1*X).^(1/3)
for each column w in W: w'*w

where:

X is a 3x16777216 matrix of sRGB colours converted to linear RGB,
M1 as defined in Björn's programming sample in his blog post, and
L is the Cholesky factorization of M2'*M2.

Generated as a farbfeld image with C++ and the Eigen library, then converted to PNG.

Whirlpool

2023-10-19T12:44:45+02:00

Make half-size spanning trees in the RGB cube and the pixels, then form hamiltonian cycles through both. This general idea has been done before, but no source code exists online so I had to figure out the relevant algorithms myself. What hasn't been done before is biasing the weights used for the spanning trees, which has the effect of forming interesting patterns on the final image while still keeping the hamiltonian property. Takes about 10s to generate a 4096x4096 image. Code repo: https://github.com/mnurzia/hamrgb

The Impossible Colorful Illusion

2023-08-16T13:37:16+02:00

Try to test the new image while saving this picture and zooming in to see the effect of random hidden colors in this image. Instead of knowing your knowledge about 6^24 = 4,738,381,338,321,616,896 - think of as of being more clear of dividing 3^24 = 282,429,536,481 - and substitute each multiplicative value of 2^24 = 16,777,216 colors. (7)

The Big Bang Theory

2023-08-15T09:46:56+02:00

Of the several images I've uploaded to this site, this one has the most suitable colors for conversion to allRGB.

Ukrainian Folk Musician

2023-08-15T09:25:39+02:00

August 24 is Ukraine's Independence Day.

UQAU

2023-08-09T11:53:24+02:00

UQAU is one of my online nicknames.

ZigZag on Hilbert

2023-08-09T11:41:45+02:00

3D Zigzag walk of the RGB color cube projected on a 2D Hilbert curve. Generated by calculating the 2D Hilbert distance for each coordinate pair (x, y), and then decoding the RGB channels as the coordinates corresponding to the calculated distance on the 3D ZigZag curve.

ZigZag on Morton

2023-08-09T11:35:04+02:00

3D Zigzag walk of the RGB color cube projected on a 2D Morton (Z) curve. Generated by calculating the 2D Morton distance for each coordinate pair (x, y), and then decoding the RGB channels as the coordinates corresponding to the calculated distance on the 3D ZigZag curve.

ZigZagCeption

2023-08-08T18:19:02+02:00

3D Zigzag walk of the RGB color cube projected on a 2D ZigZag curve starting at (0, 0). Generated by calculating the distance of each coordinate pair (x, y) from the starting point, and then decoding the RGB channels as the coordinates corresponding to the calculated distance on the 3D ZigZag curve.

Hilbert on ZigZag

2023-08-08T09:13:51+02:00

3D Hilbert walk of the RGB color cube projected on a on a 2D ZigZag curve starting at (0, 0). Generated by calculating the distance of each coordinate pair (x, y) from the starting point, and then decoding the RGB channels as the coordinates corresponding to the calculated distance on the 3D Hilbert curve.

Morton on ZigZag

2023-08-08T08:49:11+02:00

3D Morton walk of the RGB color cube projected on a 2D ZigZag curve starting at (0, 0). Generated by calculating the distance of each coordinate pair (x, y) from the starting point, and then decoding the RGB channels as the interleaved bits of that distance.

ZigZag on Spiral

2023-08-06T21:52:54+02:00

3D Zigzag walk of the RGB color cube projected on a 2D Spiral curve starting at (2048, 2048). Generated by calculating the distance of each coordinate pair (x, y) from the starting point, and then decoding the RGB channels as the coordinates corresponding to the calculated distance on the 3D ZigZag curve. The ZigZag curve is quite simple: think of a zigzagging curve in 2D starting at the top and wiggling throught the second dimension and now expand to the third dimension by thinking of a plane wiggling from top to bottom.

Hilbert on Spiral

2023-08-06T21:34:29+02:00

3D Hilbert walk of the RGB color cube projected on a on a 2D Spiral curve starting at (2048, 2048). Generated by calculating the distance of each coordinate pair (x, y) from the starting point, and then decoding the RGB channels as the coordinates corresponding to the calculated distance on the 3D Hilbert curve.

Morton on Spiral

2023-08-05T14:25:33+02:00

3D Morton walk of the RGB color cube projected on a 2D Spiral curve starting at (2048, 2048). Generated by calculating the distance of each coordinate pair (x, y) from the starting point, and then decoding the RGB channels as the interleaved bits of that distance.

3D Hilbert toD Morton

2023-08-05T12:43:39+02:00

3D Hilbert walk of the RGB color cube projected on a 2D Morton (Z) curve. Generated by calculating the 2D Morton distance for each coordinate pair (x, y), and then decoding the RGB channels as the coordinates corresponding to the calculated distance on the 3D Hilbert curve. In a way, it's the inverse of my first upload.

3D Morton toD Hilbert

2023-08-02T14:10:18+02:00

3D Morton walk of the RGB color cube projected on a 2D Hilbert curve. Generated by calculating the 2D Hilbert distance for each coordinate pair (x, y), and then decoding the RGB channels as the interleaved bits of that distance.

Einstein

2023-06-17T09:55:55+02:00

allRGB image of the first aperiodic monotile, a single shape that tiles the plane non-periodically.

Found by David Smith, Joseph Samuel Myers, Craig S. Kaplan, and Chaim Goodman-Strauss in 2023

https://cs.uwaterloo.ca/~csk/hat/

Bayer Matrix

2023-05-29T09:32:03+02:00

4096x4096 Bayer Matrix

Magic Square

2023-05-23T09:08:29+02:00

Pixels sorted using a magic square algorithm

The sum of each row, column, and diagonal is 34359740416

Smart Spectrum Lines

2023-05-05T10:15:12+02:00

The only picture with a smart looking set of 4,096 vertical lines in a magical way. The same attempt as it does generate 16,777,216 colors. (6)

Another ChatGPT

2023-05-03T10:33:37+02:00

Prompted a variation of ACJs prompt, "Write Python code that can generate an image that contains all 16777216 colors of the RGB color model exactly once. Every pixel needs to be a different RGB value. The image should be 4096 by 4096 pixels. Organize the colors in a logical way, diagonally by brightness, top-left corner to bottom-right corner. Each diagonal should be at the same brightness and colors should be ordered so the colors closest to each other in the color cube are nearest to each other in the final image." It took a few corrections to get an image that met the requirements, but it did a unique image, albeit not quite what I prompted.

artist self portrait

2023-04-27T10:51:56+02:00

yep, that's me

Bunny

2023-04-08T11:03:39+02:00

Based on a 10k polygon model of the Stanford Bunny (http://graphics.stanford.edu/data/3Dscanrep/#bunny)

Transform the triangles in the 3D model into 2D and render in depth order writing the index of each triangle. For each triangle, find the closest unused color C in RGB space to the target color. Then for all pixels that have the same index as the triangle, set each pixel to the nearest unused color to C, sorting the pixels by luminosity and their distance to the edge of the triangle. Draw the border of the triangle with colors closest to C/2.

For the background, sort the triangles by distance to the edge of the model. Then choose a target color based on luminosity and hue, and find the closest unused color D to the target. Set each pixel in the triangle to the closest unused colors to D, sorted by luminosity and distance to the longest edge.

Mocha & Java RGB algorithm

2023-03-28T12:08:16+02:00

I revisited my evolutionary algoritm allrgb solver, now found at https://troydev.co.uk/every-rgb. There is a choice of three algorithms, this is the "RGB" algorithm, meaning that two random pixels are swapped if their R, G and B values are on average closer to the target image after the swap.

Mocha & Java HSV algorithm

2023-03-28T12:08:13+02:00

I revisited my evolutionary algoritm allrgb solver, now found at https://troydev.co.uk/every-rgb. There is a choice of three algorithms, this is the "HSV" algorithm, meaning that two random pixels are swapped if their H, S and V values are on average closer to the target image after the swap. Using the HSV (Hue, Saturation, and Value) values of the pixel, rather than the RGB (Red, Green, and Blue) leads to an image that has more accurate light and dark coverage, but less accurate colours. Due to our perception of brightness being more important than colour, the RGB algorithm (not shown here), looks worse, despite the better colour accuracey.

Mocha & Java

2023-03-28T12:08:09+02:00

I revisited my evolutionary algoritm allrgb solver, now found at https://troydev.co.uk/every-rgb. There is a choice of three algorithms, this is the "area averaging" algorithm.

PI

2023-03-14T22:00:36+01:00

Happy PI Day 2023!

Hypotrochoid

2023-01-29T16:11:19+01:00

Created from curves with the parametric form:


  x(t) = (1-k)cos(t) + lk.cos((1-k)t/k)
  y(t) = (1-k)sin(t) – lk.sin((1-k)t/k)

Each curve chooses random values for l and k and then traces the curve, filling only untouched pixels with colours sorted by hue and luminance. This process is repeated until all pixels are filled.

256 Inverted

2023-01-21T21:13:19+01:00

Inverted The Negative Version Of Two Fifty Six. (5)

Visual Frames In Corners

2023-01-11T19:24:57+01:00

These corners from like a plus (+) symbol. (4)

somethingcoolimadewithacoolpixelsortingwebsiteitssocoolitshouldbepopularheyithinkthisisaverylooooooooooooooooooooooooooongnameforthisimagebutidontcareitsacoooooooolnamevvbjbnvjdkncbiuoejchiuf

2023-01-10T15:04:45+01:00

hue

2023-01-07T20:30:14+01:00

Used an image from wikipedia and sorted it with a pixel sorting website

Noisey Gradient

2023-01-06T23:57:14+01:00

An interesting result from plotting every colour onto a canvas, and then swapping those pixels around. Lower `hue`s on the left, and higher `lightness-saturation`s at the top. I only let the program run for two iterations (loop over every column and row once per iteration), and that resulted in the noiseiness

Diagonal Layers

2023-01-01T22:54:14+01:00

This is a flattening of the RGB color cube. I imagined this as balancing the color cube on its black corner and dividing it into its 765 horizontal slices. Each of these slices are stacked diagonally from corner to corner in this image by using a set of rasterization patterns along each slice.

I've got a few variations on this I'm still working on to isolate the saturated and non-saturated colors.

2023

2023-01-01T13:41:33+01:00

Vertical Spectrum Test

2022-12-23T10:56:13+01:00

We almost missed about having vertical lines on an image in allRGB. (3)

AI-Generated Quicksort

2022-12-20T11:10:35+01:00

Inspired by "First attempt (by ChatGTP)" by ACJ, I also used ChatGPT, but instead with the prompt "Create an image containing 16777216 unique RGB colors with a 4096x4096 HTML canvas with the colors sorted using a Quicksort equivalent algorithm" to which ChatGPT responded:

"To create an image containing 16777216 unique RGB colors with a 4096x4096 HTML canvas, sorted using a Quicksort equivalent algorithm, you can use the following code:


<!DOCTYPE html>
<html>
<head>
  <title>RGB Color Palette</title>
</head>
<body>
  <canvas id="canvas" width="4096" height="4096"></canvas>

  <script>
    // Get a reference to the canvas element
    var canvas = document.getElementById('canvas');

    // Get the context of the canvas element
    var ctx = canvas.getContext('2d');

    // Create a new ImageData object
    var imageData = ctx.createImageData(4096, 4096);

    // Initialize an array to hold the RGB values for each pixel
    var pixelValues = [];

    // Populate the array with all possible RGB values
    for (var r = 0; r < 256; r++) {
      for (var g = 0; g < 256; g++) {
        for (var b = 0; b < 256; b++) {
          pixelValues.push([r, g, b]);
        }
      }
    }

    // Sort the array using a Quicksort equivalent algorithm
    quicksort(pixelValues, 0, pixelValues.length - 1);

    // Loop through all the pixels in the image
    for (var i = 0; i < imageData.data.length; i += 4) {
      // Get the RGB values for the current pixel
      var r = pixelValues[i / 4][0];
      var g = pixelValues[i / 4][1];
      var b = pixelValues[i / 4][2];

      // Set the RGB values for the current pixel
      imageData.data[i + 0] = r;
      imageData.data[i + 1] = g;
      imageData.data[i + 2] = b;
      imageData.data[i + 3] = 255;
    }

    // Put the image data on the canvas
    ctx.putImageData(imageData, 0, 0);

    function quicksort(arr, low, high) {
      // Quicksort function to sort the RGB values in the array
      if (low < high) {
        // Partition the array
        var pivot = partition(arr, low, high);

        // Recursively sort the left and right halves of the array
        quicksort(arr, low, pivot - 1);
        quicksort(arr, pivot + 1, high);
      }
    }

    function partition(arr, low, high) {
      // Partition function to divide the array into left and right halves
      var pivot = arr[high];
      var i = low - 1;

      for (var j = low; j < high; j++) {
        if (arr[j][0] <= pivot[0] && arr[j][1] <= pivot[1] && arr[j][2] <= pivot[2]) {
          i++;
          swap(arr, i, j);
        }
      }
      swap(arr, i + 1, high);
      return i + 1;
    }

    function swap(arr, i, j) {
      // Swap function to"

The code got cut off for some reason, so I asked it to continue the code starting from the "function swap(arr, i, j) {" line and it provided the rest of the code along with an explanation:

"Here is the rest of the code to create an image containing 16777216 unique RGB colors with a 4096x4096 HTML canvas, sorted using a Quicksort equivalent algorithm:
    function swap(arr, i, j) {
      // Swap function to swap the values at index i and index j in the array
      var temp = arr[i];
      arr[i] = arr[j];
      arr[j] = temp;
    }
  </script>
</body>
</html>
The swap function is used to swap the values at index i and index j in the array. This is used by the partition function to divide the array into left and right halves and by the quicksort function to recursively sort the left and right halves of the array.

Once the array of RGB values is sorted, it is looped through and the values are used to set the RGB values for each pixel in the image data. Finally, the image data is drawn onto the canvas using the putImageData method.

This should create an image containing 16777216 unique RGB colors with a 4096x4096 HTML canvas, sorted using a Quicksort equivalent algorithm."

Impressively, after saving the code as an HTML file and running it in a browser, it indeed generates an image which contains all the colors sorted using a Quicksort method.

I expected the image to be the same as "quicksort" by tripwire, however it is indeed different.

Image Licence: Public Domain (CC0).

Christmas Tree

2022-12-19T16:44:42+01:00

First attempt (by ChatGPT)

2022-12-11T10:23:35+01:00

This image was generated by artificial intelligence … sort of. I decided to have a little chat with Chatgpt, and feed it the following prompt:

Write Python code that can generate an image that contains all 16777216 colors of the RGB color model exactly once.

This did create a script that iterated over all possible rgb values, but created an image that was only 256 by 256 pixels in size, painting most colors off-canvas.

So, I decided to be more specific:

Write Python code that can generate an image that contains all 16777216 colors of the RGB color model exactly once. The image should be 4096 by 4096 pixels.

Impressively, this did create a script that would generate an image that met the premise of allrgb. However, said image would be exactly the same as the first attempt by Tinnittin, so I would still not be publishing it.

Thus, I added one more rule to the prompt:

Write Python code that can generate an image that contains all 16777216 colors of the RGB color model exactly once. The image should be 4096 by 4096 pixels. Shuffle the colors in an interesting way.

It answered:

Here is some sample code that you can use to generate an image that contains all 16777216 colors of the RGB color model exactly once:
# Import the necessary libraries
import random
from PIL import Image

# Create a new image with the appropriate dimensions
width = 4096  # The image should be 4096 by 4096 pixels
height = 4096
image = Image.new("RGB", (width, height))

# Create a list of all possible colors
colors = [(red, green, blue) for red in range(0, 256) for green in range(0, 256) for blue in range(0, 256)]

# Shuffle the colors using a random number generator
random.shuffle(colors)

# Iterate over all pixels in the image and assign each pixel a randomly shuffled color
for x in range(0, width):
  for y in range(0, height):
    image.putpixel((x, y), colors[x * width + y])

# Save the image to a file
image.save("shuffled_colors.png")
This code creates a new image with dimensions 4096x4096 and then iterates over all possible values of red, green, and blue. For each combination of values, it calculates the x and y coordinates of the corresponding pixel in the image and sets that pixel to the current color. Finally, it saves the image to a file called "all_colors.png". You can adjust the dimensions of the image and the name of the output file as needed.

Now, we could argue about how interesting random.shuffle is, but at least this script is able to generate images that meet all allrgb’s requirements, including not being posted before.

Color wheel v2

2022-09-15T15:47:56+02:00

A second attempt to distribute colors as close to a square color wheel as possible.

General algorithm: for each band/square of untouched pixels expanding out from the center, choose pixels to place in that square based on the following:

Brightest colors get priority
An even distribution of hues are selected within a brightness
An even distribution of saturations are selected within a hue, although higher saturations get priority for being in the "center" of a hue section
Order the hues ascending from 0-6 (magenta = 0, red = 1, green = 3, etc.)
Insert monochrome colors where applicable, trying to minimizes how far it shifts each hue away from its "ideal" location (magenta at top, red 60 degrees left, green at bottom, etc.)
Rotate the list where applicable to get hues close to their "ideal" location
Place hues next to each other in order around that band of pixels

You can see prominent rays from the center towards the 6 primary hues (and between them) where desaturated versions of the colors border them

Disco Laying Squares

2022-09-15T15:47:16+02:00

Trivia: This is my first 1,024 x 16,384 image with the 256 squares laying in a banner disco pattern. (2)

Color wheel v1

2022-09-13T09:33:59+02:00

A first attempt to distribute colors as close to a square color wheel as possible.

General algorithm: for each band/square of untouched pixels expanding out from the center, choose pixels to place in that square based on the following:

Brightest colors get priority
Least-represented hues get priority within a brightness
Most-saturated colors get priority within a hue
Order the hues ascending from 0-6 (magenta = 0, red = 1, green = 3, etc.)
Insert monochrome colors where applicable, trying to minimizes how far it shifts each hue away from its "ideal" location (magenta at top, red 60 degrees left, green at bottom, etc.)
Place hues next to each other in order around that band of pixels

There's a clear point when it changes from one hue set to another, so I'll have to try again prioritizing an even distribution of hues

The Mystery Black Hole

2022-09-13T09:29:39+02:00

My first demo image with all 16,777,216 colors. (1)

Fast Linear Assignment Sorting (FLAS)

2022-08-23T18:46:25+02:00

The colors have been visually arranged using "Fast Linear Assignment Sorting" (FLAS) trying to preserve the 3D color distances in the 2D arrangement as good as possible. https://arxiv.org/pdf/2205.04255.pdf

Euler #6

2022-08-15T13:57:50+02:00

Another pass at Euler's portrait, this time with the signature present and accounted for. Still nowhere near as clean as Al's super nice patterned noise entry.

Letters

2022-07-31T14:21:43+02:00

I repeated sorting the Pixel localy by Hue and brightness. The Result was a simple Rainbow. Then i inverted the sorting-direction on the area of some letters. This is the Result.

Euler #5

2022-07-29T13:30:29+02:00

My contribution to the RedGolpe/llemarie Euler challenge. Note that the resolution is high enough for the date and artist's signature in the upper right corner to be legible.

Newton

2022-07-29T13:25:21+02:00

https://en.wikipedia.org/wiki/Newton_fractal

Independence Day

2022-07-04T09:34:57+02:00

A 19th century train station in Independence, Missouri.

Frank Reynolds

2022-06-06T09:16:58+02:00

Father's Day

2022-06-02T11:34:55+02:00

Mother's Day

2022-05-03T11:09:51+02:00

Phantometry

2022-04-26T23:21:07+02:00

This image is constructed in the same way as Phantoms of Irreducibility except that its starting image is Squircly Anchor (upside down and with some switching/swapping of colour components) instead of Additive Squircles.

Both Squircly Anchor and Additive Squircles are composed of geometrically constructed areas with uniform colouring. The geometry and the colouring are somehow reflected, among the emerging artefacts, in the derived images.

The geometric areas and colours of Squircly Anchor are significantly more numerous than those of Additive Squircles and this results in Phantometry having a stronger "by design" look than Phantoms of Irreducibility.

Image Licence: Public Domain (CC0).

No rhyme or reason

2022-04-25T10:01:05+02:00

All of allrgb, so far

2022-04-25T10:01:03+02:00

Objective of allRGB with Hilbert Curve Colouring

2022-04-19T12:47:53+02:00

The text layout of this image is imported from Base Text and Colours for Objective of allRGB.

Pixels are ordered by their signed distance from the border of the text.

Colours are ordered by a Hilbert curve which traverses the RGB24 colour space.

Pixels and colours are then associated with each other in the given order.

Image Licence: Public Domain.

Hot Core

2022-04-19T09:10:20+02:00

This image is generated using the approach described in Average Pursuit and is similar to Heart of Glass.

With respect to Heart of Glass:

a lower update rate is chosen, so to have a "thicker brush"
colours are chosen so that the circle at the centre of the image appears to be hot rather than cold

Image Licence: Public Domain (CC0).

Tetraspective

2022-04-12T16:03:04+02:00

Imagine printing an image on a transparent film, then folding the film once vertically and once horizontally, and then looking through it, i.e. looking through the four overlapping quadrants of the image.

A similar operation can be performed on a digital image by interleaving its pixels, so to preserve both the size and the omnichromatic property of the image.

This image in particular is the result of applying the transformation to the Drifting Infusion image.

Image Licence: Public Domain (CC0).

Objective of allRGB on Sandy Spiral

2022-04-10T11:26:44+02:00

This image is constructed from:

The idea is to superimpose text on an omnichromatic image in a way that the image remains omnichromatic.

A simple approach is adopted in this experiment:

the base text image is used to determine which pixels are within the text area
within the text area of the omnichromatic image, the colours of pixels are inverted
outside the text area of the omnichromatic image, the colours of pixels that match inverted colours within the text area are also inverted

For most images, this transformation is too disruptive for one reason or another, but for this particular image the inverted text looks reasonably neat and the pixels inverted outside the text area also result in a smooth "sandy" impression.

Image Licence: Public Domain.

Easter

2022-04-04T12:49:42+02:00

Escape from Brownianhood

2022-03-31T18:12:18+02:00

This image is constructed as described in the Brownianhood image, except that the particle moves by a variable number of steps instead of a fixed single step, before one of the pixels that's nearest to the particle and has not already been painted is painted.

The number of steps is proportional to the distance of the particle from the border of the painted area. Fractional number of steps are converted into probability of making the extra step.

The ratio of number of steps to distance from the border can be applied to both the 2D image space and 3D colour space.

Depending on the ratio chosen, the emerging shapes will have different size/granularity and different colour shades.

The aim of applying multiple steps is to prevent the particle from dwelling for too long within a painted area, i.e. to prevent the area being painted from growing too large in a roughly circular shape.

Image Licence: Public Domain (CC0).

The Gilded Age

2022-03-25T16:50:40+01:00

Downton Abbey

2022-03-21T20:14:36+01:00

Clown

2022-03-21T20:13:28+01:00

Pure Bread Dog

2022-03-21T20:11:30+01:00

Borromean Rings

2022-03-21T20:09:49+01:00

Mickey Mouse

2022-03-21T20:08:15+01:00

It is believed that the use of this low-resolution image for personal, non-commercial purposes qualifies as fair use under United States copyright law.

Martini

2022-03-21T20:05:15+01:00

Objective of allRGB

2022-03-21T20:00:09+01:00

An example of monochromatic text converted to allRGB.

Apollonian gasket

2022-03-15T08:21:09+01:00

Z = Z^2 + C

2022-03-15T08:21:06+01:00

SOS to the West

2022-03-14T23:42:20+01:00

Image Licence: Public Domain (CC0).

Shattered

2022-03-12T21:23:33+01:00

Path-traced fractured glass fractal.

Recursive squares

2022-03-08T15:28:32+01:00

The (x,y) plane is divided into 8x8 squares of 2-bit colors; each square is thus mapped to a specific 6-bit color. The procedure is iterated 4 times for each squares, adding 2 less significant bits to each color, each time.

Novaya Square

2022-03-08T15:15:16+01:00

Novaya Square, Moscow

Worm Bay

2022-03-08T15:15:05+01:00

Worm Bay, Victoria, Australia (from Wikimedia Commons).

Queen Elizabeth II

2022-03-02T10:32:56+01:00

Based on a Wikimedia image extracted from a public domain photo by Joel Rouse

Alex Trebek

2022-03-02T10:32:53+01:00

Based on a Wikimedia image extracted from a public domain photo by Anders Krusberg

Abraham Lincoln

2022-03-02T10:14:19+01:00

Based on public domain image from Wikimedia Commons

Heart of Glass

2022-02-26T21:28:46+01:00

This image has been generated using the Average Pursuit algorithm with a rate of about 0.01%.

The emerging shapes happen to draw significant attention towards the circle at the centre of the image.

In the subsequent choice of colours, the central circle could be made even more prominent with the use of yellow and red. There is however something more intriguing in going for the opposite effect, choosing colours to give the coldest appearance to the core of the image.

Image Licence: Public Domain (CC0).

Ottrott

2022-02-23T23:37:16+01:00

Photo I've taken in 2012 in a village called Ottrott.

Legos

2022-02-23T20:50:50+01:00

Legos

Smooth

2022-02-18T21:33:25+01:00

All orthogonally adjacent pixels colors are within distance 2 (in the RGB space).

3600 neighbors are 2 apart.
921600 neighbors are sqrt(2) apart.
32621040 neighbors are 1 apart.

Sorted distances

2022-02-17T15:38:49+01:00

A point P is chosen at random on the (x, y) plane and all points on the square grid are sorted by euclidean distance from P. Then a color C is chosen at random on the (r, g, b) space and all colors on the cubic grid are sorted by euclidean distance from C. Finally, points and colors are matched based on their indexes.

Washington Square Park

2022-02-13T22:24:50+01:00

New York City's Washington Square Park. Derived from photo taken April 24, 2020.

(least sum of) squares

2022-02-13T22:24:47+01:00

This is an attempt to minimize the sum of squares of differences in color between adjacent pixels. The image is constructed dividing the field into 16x16 squares of 256x256 pixels, each a gradient in red and green mapped on x and y. Blue is the same for each square and is sorted diagonally from 0 (top left) to 255 (bottom right). Odd squares are then flipped to minimize distances with adjacent squares. It can probably be improved with a better arrangement of the squares or by using rectangles in place of the squares.

Clusters

2022-02-13T14:33:36+01:00

A first attempt to eliminate dithering. Clusters are smaller than expected, and dithering is still noticeable.

Euler #4

2022-02-12T20:26:14+01:00

Taking on the RedGolpe challenge (:

Scritches

2022-02-11T18:27:30+01:00

A blue and gold macaw happily getting scritches.

Euler #3

2022-02-11T18:27:29+01:00

This algorithm privileges pixels near the center of the image but works otherwise similarly to the one in Euler #1. All in all, a more visually pleasant workaround for the removal of unwanted colors.

Euler #2

2022-02-10T08:45:48+01:00

Same algorithm as Euler #1. Simply adding a border to store the "wrongest" pixels improves the image somehow. Dark areas still problematic.

Euler #1

2022-02-09T16:53:02+01:00

Algorithm based on the minimization of the linear distance between expected color and actual one. Original image is a section of https://en.wikipedia.org/wiki/File:Leonhard_Euler_-_edit1.jpg. Works poorly with images exhibiting large dark areas and large swaths of similar colors (like this one).

Study in black and white

2022-02-08T11:48:42+01:00

Fractal contour, shaded.

Painting of my cat

2022-02-08T11:48:38+01:00

Such grace. Such disdain.

Fractal detail

2022-02-08T11:48:35+01:00

Ray-traced in WebGL. Converted with genetic algorithm.

Cornell Box

2022-02-08T09:35:33+01:00

Ray-traced in WebGL. Converted to all-rgb with a small genetic algorithm javascript program.

Drifting Infusion

2022-02-06T17:11:02+01:00

This image is the outcome of an experiment inspired by the diffusion-limited aggregation process.

What happens if particles that are subject to brownian motion, instead of moving in the environment until they reach the object, move inside the object until they reach the environment?

If the particles originate from a fixed source, they simply form layers around it that tend to be circular in 2D or spherical in 3D.

To introduce some variety, in this experiment the source of particles is also made to drift.

When a particle steps beyond the surface of the object and freezes, if its final distance from the source is above a certain threshold, then the source moves one step closer to that particle, before emitting the next one.

In this particular image the source of particles in the 2D image space starts in middle of the left side of the image and the other source of particles in the 3D colour space starts with the colour white.

Destination pixels and colours from the two sources are then matched one by one.

Image Licence: Public Domain (CC0).

Marbles on a Creeping Stripe Ahead

2022-02-06T17:04:06+01:00

This image is an omnichromatic variant of the Polka Dot 3D Effect image.

The first part of the construction is the same for both images: the 3D RGB colour spectrum is sliced into 256 tiles of size 256 x 256 and the tiles are orderly placed over a 2D 4096 x 4096 area, following a creeping line ahead pattern, while orientating the next tile to ensure a seamless transition from the previous one.

With this layout, the set of 64 circles in the 2D image corresponds in the 3D colour spectrum to a quarter of cylinder whose axis is an edge of the RGB cube.

The colour component that varies along that axis can then be inverted within the circles while retaining the omnichromatic property of the image, but this is not the case for the other two colour components.

The inversion of the colour component along the axis can be pictured as the quarter of cilinder having a plane of symmetry orthogonal to the axis, cutting it through its middle.

The only other plane of symmetry for the quarter of cylinder runs instead along the axis. Applying this other symmetry is equivalent to swapping, rather than inverting, the other two colour components.

After this operation, the colour components of all the pixels in the image are further inverted and/or swapped, in order to give the marbles a coluring similar to the one of the Polka Dot 3D Effect.

Image Licence: Public Domain (CC0).

Brownianhood

2022-01-31T09:49:13+01:00

This image is constructed from a random walk, the discrete equivalent of brownian motion: an imaginary particle moves randomly around the image, from pixel to pixel.

Each step in the walk consists of a horizontal or vertical transition to an adjacent pixel.

After a step, one of the pixels that's nearest to particle and has not already been painted is painted.

The pixel to be painted also needs to be adjacent, horizontally or vertically, to an already painted pixel.

The colour of the pixel is chosen based on an analogous random walk in the 3D colour spectrum.

In this particular image there's a tiny white cloud within a magenta circle: that's where the painting starts, from a white pixel. From that location it is possible to visually follow through the path of the particle.

Depending on how long the particle dwells in a local area, more or less of the neighbouring pixels get painted. This results in sections of rings of varying sizes and colours.

The visual effect is that the path of the particle seems to have a variable thickness, or that disks seem to have been unstably stacked upon each other.

The sections of rings inevitably grow bigger as the walk progresses and local areas to be painted run out.

A general problem with the approach described is that the resulting images tend to come out off-centred. Even if the particle is made to start at the centre of the image, it generally drifts off towards a border or corner, where it more easily loses its ability to reach again the edge of the surrounding disk of painted pixels.

A way to compensate for this, as done here, is to keep shifting the image during the walk, for as long as necessary and possible, to keep the particle 1/8th of the image length away from the image borders.

Image Licence: Public Domain (CC0).

Zeno's Paradox

2022-01-19T11:57:25+01:00

"That which is in locomotion must arrive at the half-way stage before it arrives at the goal."

This image is constructed in the same way as the Up and Down the Shortest Tree image, except for how the 2D and 3D trees grow.

At each step, a new branch grows out of a random point in the tree, orthogonally to its parent branch and in an axial direction (i.e. horizontal/vertical in 2D, or along a colour component in 3D).

The branch stops growing when it "arrives at the half-way stage before it arrives at" a pixel/colour that's either beyond the image/spectrum boundary or has already been reached by another branch.

The image space and the colour spectrum, being composed of a discrete number of elements, introduce a heavy bias towards an atomist answer to Zeno's paradox.

To compensate for that and make sure that the goal isn't reached, fraction of pixels and fractions of colour levels are rounded down.

Image Licence: Public Domain (CC0).

[AUDIO] Dissident by Filmmaker

2022-01-19T11:54:14+01:00

This file is an image and also a song.

When this file is played as audio at 44.1kHz Stereo Signed-24-bit PCM, it plays the song Dissident by Filmmaker.

The 16,777,216 samples which make up the recording were made unique, and therefore could be said to contain all possible 16,777,216 RGB colours in the 24bpp colour space, or in other words all possible 16,777,216 24-bit audio sample amplitude values, or in other words all possible 3-byte strings. If you open the raw file in a text editor, you will find text instructions to play it. This can be done in Audacity by selecting "File" - "Import" - "Raw..." Use offset of 122 bytes to skip beyond the BMP Header.

I came to these ideas through my databending projects which can be found at https://databending.org/

The method of uniquification of values was a simple offset of the amplitude (RGB) value by +/- 1 until a unused value is found.

THE RESULTS ARE VERY LOUD AND NOISY AND DISTORTED AS THE AUDIO PROGRESSES

THIS SOFTWARE IS PROVIDED AS IS WITH ABSOLUTELY NO WARRANTY NOT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO WAY SHALL THE AUTHOR BE LIABLE FOR ANY DAMAGES BE THEY CONSEQUENTIAL, INCONSEQUENTIAL, INCIDENTAL, DIRECT, INDIRECT, POSSIBLE, IMPOSSIBLE, INTENTIONAL, UNINTENTIONAL, FLIPPANT, KNOWN, UNKNOWN, PREMEDITATED, MEDITATED, UNMEDITATED, MEDICATED, OR ACT OF GOD TO THE EXTENT ALLOWABLE BY APPLICABLE LAW.

ENJOY!

Ginger Lisa's Stare

2022-01-18T09:42:49+01:00

This image is an omnichromatic variation of Yet Another Monna Lisa.

The colour components of the original image are swapped and inverted in all possible ways, resulting in 48 images to choose from.

Of these, 2 are shortlisted based solely on the perceived intensity of expression of Monna Lisa's face. This appears to be mostly dependent on the contrast between the pupil and the iris and the rest of the eye.

This image is then ultimatey favoured because it also provides a peculiar ginger hair impression.

The image is finally passed through a process that makes it omnichromatic, which doesn't alter it much, because the original image is already quite colourful.

Image Licence: Public Domain (CC0).

Up and Down the Shortest Tree

2022-01-15T11:23:55+01:00

This image is the result of progressively matching pixels with colours, by running two equivalent and parallel walks, in the 2D image space and 3D colour spectrum.

The walks are constructed by moving back and forth along all the branches of a pre-constructed tree, turning that tree into a Hamiltonian cycle.

To construct the tree in the 2D image space, a grid is formed of square cells that contain 4 pixels each. A root cell is selected, and from there horizontal and/or vertical moves are recursively applied to branch out in any direction, reaching all other cells.

The tree is constructed as a shortest-path tree using the Dijkstra's algorithm, while also choosing at random among any equivalent possibilities.

Once the tree is constructed, a mini-tour is created within the root cell. The mini-tour goes from corner to corner, e.g. top/left to top/right to bottom/right to bottom/left.

Starting from the root cell, all other cells in the tree are then revisited, expanding the tour at each step. The leg in the current cell that is adjacent to the new cell is replaced with a U path in the new cell. By the end of this process the tour has become a Hamiltonian cycle.

An equivalent approach is adopted for the 3D colour space. In this case a grid is formed with cells that are cubes composed of 8 colours. There can be in this case up to three legs in the current cube that are adjacent to the new cube. One of the legs is replaced with a path that visits all the colours in the new cube. Both legs and paths need to be appropriately chosen to avoid ending up with legless surfaces.

This particular image is started by placing a black root at its bottom left corner.

From the root a horizontal branch and a vertical branch form, whose outer side is black-ish and from whose inner side other branches depart, heading at about 45 degrees towards the other side of the image.

Image Licence: Public Domain (CC0).

The True Colours (Blue Spread)

2022-01-10T20:58:22+01:00

Here's the C code which generated this dataset:

  for (int b=0; b<256; b++) {
    for (int ra=0; ra<16; ra++) {
      for (int g=0; g<256; g++) {
	for (int rb=0; rb<16; rb++) {
	  fprintf(f, "%c%c%c", b, g, (ra<<4)|rb);
	}
      }
    }
  }

PillarsOfCreation

2022-01-07T09:59:07+01:00

Another arrangement of the 16x16 tiles of the two color plane lined up in a row, repeated with an iteration of the third color each repetition. The arrangement here almost looks like round pillars with light sources above and below them casting shadows and reflections.

Rastafarian

2022-01-07T09:59:04+01:00

Another arrangement of the 16x16 tiles of the two color plane lined up in a row, repeated with an iteration of the third color each repetition.

Gradient40

2022-01-07T09:58:34+01:00

Another arrangement of the 16x16 tiles of the two color plane lined up in a row, repeated with an iteration of the third color each repetition.

Gradient39

2022-01-07T09:55:42+01:00

Another arrangement of the 16x16 tiles of the two color plane lined up in a row, repeated with an iteration of the third color each repetition.

Gradient38

2022-01-07T09:55:39+01:00

Another arrangement of the 16x16 tiles of the two color plane lined up in a row, repeated with an iteration of the third color each repetition.

Gradient17

2022-01-07T09:53:56+01:00

Another arrangement of the 16x16 tiles of the two color plane lined up in a row, repeated with an iteration of the third color each repetition.

Tuning to Fractals

2022-01-07T00:22:34+01:00

This image is the result of progressively matching pixels with colours, by running two equivalent and parallel walks, in the 2D image space and 3D colour spectrum.

These walks happen to progress only through straight lines with either axial or diagonal orientation, occasionally switching direction and also jumping over other lines when reaching a dead end.

Starting with an empty space, the triangles and rectangles being generated are initially quite large and they delimit areas where the walk tends get trapped.

Within a delimited area, when the walk does not fill the space with a spiral or a creeping line ahead, it produces more nested rectangles and triangles, which become smaller and smaller, repeating similar patterns at different scales.

The behaviour of these walks and consequent emergence of fractals is not actually by design: it only occurs when a parameter of the generating algorithm is fine tuned to a specific range of values.

I wonder if fractals may emerge in the evolution of living organisms in a similar way, by fine tuning driven by natural selection? A particular setting enabling a small part of a genetic recipe to drive growth through a wide range of scales.

Image Licence: Public Domain (CC0).

Funky Town

2022-01-07T00:19:57+01:00

Image Licence: Public Domain (CC0).

The True Colours (Red Blocks)

2022-01-07T00:10:17+01:00

Spreads the G and B channels across X and Y respectively, with 16x16 blocks of R channel throughout

0xE18AD7A78F1F80EC

2022-01-05T14:15:02+01:00

0x770E313A773F3C3F

2022-01-05T14:10:47+01:00

All Colours 127.5

2022-01-03T18:39:04+01:00

The same thing "Touch of 127.5" by ComfortablyNumber did with "Thingy" by ACJ but with "All Colours" by mbona. According to photoshop this is even more grey (and sharpness) than touch of 127.5. Perhaps, though, it's equal (in grey, maybe, in sharpness, no). I'll probably make something even more grey in the future.

Average Pursuit

2022-01-02T20:10:21+01:00

This image has been generated by running the Average Pursuit algorithm, described here below.

The Average Pursuit algorithm is an extension of the Greedy Spaghetti Pandemonium algorithm and tries to make the greedy traversal dwell longer in local areas, in order to smoothen the colour transitions.

The approach consists of selecting, at each step and both from pixels and colours, the closest neighbour to a moving average position, rather than the closest neighbour to the current position.

The exponential moving average is adopted and all coordinates (row, column, red, green and blue) are revised at the same rate, in the range 0% to 100% (0.0 to 1.0):

New Average = Rate * New Sample + (1.0 - Rate) * Current Average

At a rate of 100%, the average position matches the current position and the algorithm behaves as per Greedy Spaghetti Pandemonium.

At a rate of 0%, the average position is fixed and matches the starting position so that the algorithm generates concentric gradients around the starting position.

In between 0% and 100%, my experimental implementation generates a variety of images with evolving characteristics, the most noticeable ones being that from 100% to 0% the paths transition from random to (somewhat counter-intuitively) straight, and their width increases.

This image in particular is generated using a rate of 50% to capture an intermediate stage where the walks keep suddenly changing between random, semi-straight diagonal and straight horizontal/vertical.

Implementation Note - The Average Pursuit algorithm can be extremely slow, especially at low rates. To calculate the nearest pixels and colours, the algorithm operates an R-Tree data structure, holding into that structure only items from the evolving frontier, instead of all the unreached items.

Image Licence: Public Domain (CC0).

Greedy Spaghetti Pandemonium

2022-01-02T14:04:59+01:00

This image is constructed by traversing the 2D image space in parallel with the 3D RGB colour space, in order to assign at each step a unique colour to a unique pixel.

The traversal is driven by the greedy algorithm (https://en.wikipedia.org/wiki/Greedy_algorithm) and randomness when choosing among equally near neighbours.

Visually, the traversal proceeds along a continuous contorted path through adjacent neighbours, until it reaches a dead end, at which point a jump occurs to the nearest location from where the next path can start.

Algorithm Outline:

Select a pixel (e.g. a pixel at the centre of the image).
Select a colour (e.g. the colour white).
Assign the selected colour to the selected pixel.
Finish when all pixels have been assigned a colour.
From the remaining pixels select a pixel that's closest to the last selected pixel; if there is more than one closest pixel, then select one of them at random.
From the remaining colours select a colour that's closest to the last selected colour; if there is more than one closest colour, then select one of them at random.
Repeat from 3.

Image Licence: Public Domain (CC0).

Recursive

2022-01-01T14:09:41+01:00

Julia, antialiased

2021-12-31T23:05:01+01:00

Gradient30

2021-12-31T22:51:01+01:00

There are a lot of arrangements and color swaps that vary the feel of these images.

Gradient15

2021-12-31T22:47:28+01:00

A different traversal of the 256 16x16 tiles of a 2 color palette.

Gradient7

2021-12-31T22:47:23+01:00

This image is produced by splitting a 256x256 pixel Red Blue color palette into 256 16x16 pixel tiles, then aligning those tiles along the edge of the image and repeating this tiling while increasing the Green by one count each time.

Luminance Spiral by Hue

2021-12-30T16:06:01+01:00

The area of this image is partitioned into 4096 concentric rings of 4096 pixels each.

Colours are assigned to rings based on their luminance, so that inner rings have colours with higher luminance than outer rings.

Within each ring, colours are then assigned to pixels based on hue versus angle of pixel with respect to the centre of the image.

The formula used to calculate luminance is:

L = 0.2126 * R + 0.7152 * G + 0.0722 * B

The coefficients have different values and this results in different shades of colour being more or less prominent in the image depending on their distance from the centre. It also results in radial (as well as circular) variations in hue and an overall spiral-like shape.

The setting of 0 degrees reference hue at -90 degrees results in the yellow, magenta and cyan shades taking more vertical directions, from the centre going towards the bottom centre of the image.

Some distortion occurs close to the corners, where rings turn into sections of rings. This is noticeable for instance in the shape of the dark green shade close to the bottom left corner.

As per all seemingly smooth omnichromatic images, on a closer look this image is also affected by dithering.

Image Licence: Public Domain (CC0).

Colorful Sunday

2021-12-18T16:34:27+01:00

Source image is a crop of A Sunday Afternoon on the Island of La Grande Jatte by Georges Seurat.

For each pixel in the source image, the algorithm uses a vantage-point tree to find the closest unused color in the Lab color space, and places it in the output. It iterates over the pixels based on their value in the 4096x4096 Bayer matrix, so the late "bad" pixels are evenly distributed across the image.

This image was produced by a 16-threaded version of this algorithm in 20 minutes.

Chasing a Granger Rainbow

2021-11-06T14:59:51+01:00

This image is derived from an image of a Granger Rainbow.

A very soft and uniform noise is first applied to the original image, increasing/decreasing by 1 the intensity of about 25%/25% of its 4096x4096x3 colour components.

Then the component intensities are altered further, to make the image uniform over the RGB colour spectrum. The change of intensities in a pixel favours making them closer to the intensities of its nearer pixels.

Finally, the colours are made unique by recursive partitioning and readjusting along the red, green and blue axes.

The intent of the subtle noise introduced before the conversion is to prevent artefacts from emerging, however some of the artefacts still emerge and the noise itself is converted into a noticeable texture.

The emerging patterns and texture actually give a peculiar character to the resulting image.

Image Licence: Public Domain (CC0).

256 Shades of Hue

2021-10-10T15:00:10+02:00

This image is composed of 16 x 16 = 256 tiles.

Each tile is allocated colours that are within a range of hue, which is determined based on the angle that the centre of the tile forms with respect to the centre of the image.

The colours within each tile are then distributed so that their lightness varies horizontally and their saturation varies vertically. The direction of change, increase or decrease, switches between one tile and the next.

Image Licence: Public Domain (CC0).

Equilateral Extrapolation

2021-10-06T09:14:34+02:00

Starting with a entirely black image, a few base pixels are selected close to the corners of an imaginary equilateral triangle, whose centre corresponds to the centre of the image.

The base pixels are coloured red, green or blue based on their corner.

The intensities of the colour components of all other pixels is affected by the base pixels in a sort of gravitational way.

Once all pixels are ranked by the inherited intensities of their components, they can be recursively picked and assigned unique colours.

Image Licence: Public Domain (CC0).

Thue-Morse Interleaving of Lightness and Saturation

2021-10-05T11:19:26+02:00

This is a variation on the Radial Interleaving of Lightness and Saturation experiment.

An HSL format (with hue, saturation and lightness dimensions) is adopted for the colour space and a polar coordinate system is adopted for the pixels.

Hue is then matched to angles and both lightness and saturation are matched to distances from the centre of the image.

In this variant lightness and saturation are made to change along the radials using a pattern that helps softening their transitions.

The pattern turns out to reflect the Thue-Morse sequence.

Image licence: Public Domain (CC0).

Recursive Gradients

2021-10-01T22:49:06+02:00

The underlying idea is to generate the equivalent of an image with gradients and uniform in the RGB spectrum (like this RGB Gradient Sample), while also enforcing the uniqueness of its colours.

Outline of the approach:

Start with a single area comprising the whole image and all available colours assigned to it.
Split each area into two equally sized inner and an outer areas, with respect to the centre of the image. Reassign colours with a higher/lower red intensity respectively to the inner/outer area.
Split each area into two equally sized upper and lower areas. Reassign colours with a higher/lower green intensity respectively to the upper/lower area.
Split each area into two equally sized left and right areas. Reassign colours with a higher/lower blue intensity respectively to the right/left area.
Repeat from 2. until all areas are reduced to a pixel with a unique colour assigned to it.

Image Licence: Public Domain (CC0).

Interline Dithered Gradient

2021-10-01T12:48:59+02:00

I took an algorithm I used in C for doing a similar project (but at 15bpp) to display on a gba, and redid it in java to create a 24bpp image.

Phantoms of Irreducibility

2021-09-30T12:31:37+02:00

The approach I used to produce this image is pretty much the same I used to derive the "Cromospilled Bananas" and "Veiled Cell" images.

In this case however the starting image is the very raw and basic Additive Squircles, which only has eight base colours (white, cyan, magenta, yellow, red, green, blue and black) laid out in a way to invite a conversion algorithm to generate a 2D colour spectrum.

A 3D colour space cannot really be reduced to a 2D colour spectrum, but something striking might still come out of attempts to reduce the irreducible.

This image looks like a different image when turned upside down.

Image Licence: Public Domain (CC0).

ziggy

2021-09-27T13:49:58+02:00

corridor

2021-09-27T13:49:53+02:00

Veiled Cells

2021-09-09T17:23:28+02:00

This image is derived from the Glowing Cells image, which is already constructed to be fully uniform throughout the RGB spectrum.

The pixels in the original image are recursively partitioned into 8 equally sized groups, depending on whether their colour is closer to pure black, red, green, blue, cyan, magenta, yellow or white.

The partitioning acts as a binary search of the unique colour to associate to the pixel, at every iteration reducing the range of each component of the colour by half.

Image Licence: Public Domain (CC0).

Mandelbrot

2021-08-28T10:50:42+02:00

allrgb version of https://www.publicdomainpictures.net/en/view-image.php?image=285773&picture=mandelbrot-clasico

Chromospilled Bananas

2021-08-27T21:32:29+02:00

This image is derived from the "yellow bananas" texture at https://www.manytextures.com/ (for details and licensing see the 4096x4096 PNG version at https://www.manytextures.com/texture/258/yellow-bananas/).

The main aspect of the conversion to allRGB performed here is that when differentiating among non-unique colours the algorithm changes them in a way to keep them closer to the colours of neighbouring pixels.

As a result, besides colour differences being amplified, colours also tend to spill across pixels, instead of dithering.

This usually results in derived images with colours that look exaggerated and disruptive, however as an exception, this particular image looks both colourful and relatively smooth.

queens gambit

2021-08-26T12:36:11+02:00

balloons

2021-08-26T12:36:02+02:00

Mona

2021-08-26T12:25:35+02:00

Same algorithm as "tiger". Just doubled all input RGB because source image was quite dark.

strawberries

2021-08-25T11:11:25+02:00

I like how this looks quite red. I expected weirder discoloration.

tiger

2021-08-25T11:10:27+02:00

Pair up the pixels (as 2x1 pixel blocks) and perform hill climbing (swaps on individual pixels), minimizing distance^2 in RGB space (use average color of the 2x1 pixel block for this purpose).

Random Walk

2021-08-18T15:05:00+02:00

A random walk is taken around the 4096x4096 grid in steps of 64x64 pixels, and each time an uncolored chunk is reached, the next 4096 colors are filled into that 64x64 area, until all the colors are used and the entire image filled.

tokyo overpass

2021-08-16T10:22:13+02:00

"a.k.a Gero Tan : Noah's Ark" [Crop]

2021-07-03T18:12:06+02:00

Allrgb approximation of a cropped portion of Takashi Murakami's "a.k.a Gero Tan : Noah's Ark"

Bubbles

2021-07-03T18:11:19+02:00

Along the River During the Qingming Festival [Left]

2021-07-01T11:26:58+02:00

Along the River During the Qingming Festival [Right]

2021-07-01T11:26:54+02:00

Streaks

2021-06-23T10:57:28+02:00

This image is generated by looping through every pixel from the top left to the bottom right. For each pixel, the algorithm finds a color that is close to the pixel above and the pixel to the left.

This creates diagonal streaks of similar colors.

Rough Diamonds

2021-06-23T10:56:14+02:00

Vortex

2021-06-13T11:38:51+02:00

0x7777777

2021-06-13T11:38:45+02:00

each pixel, left to right, top to bottom, is 0x7777777*(n+0x7777777)

random walk

2021-04-14T20:01:40+02:00

unfilled pixels are given the next available color on a simple 24-bit counter. filled pixels are unchanged. Iterate until every single pixel has been walked over.

RGB Sponge

2021-02-22T13:46:45+01:00

Tri-Pivot

2021-02-10T11:40:01+01:00

3 Pivot points are chosen at random. Each pixel's colour is determined by the ratio of the magnitude of the angle between it and each pivot, each one controlling the r, g or b value.

A random sample of 5000 colours is chosen from the unused colour list, the closest matching colour by least distance in a colour cube is given to the pixel.

FractalBrightness

2021-02-08T17:48:03+01:00

Mandelbrot set, centered at -0.74295085 + 0.139442616666667i, radius 0.001, 5000 iterations.

Pixels are sorted by number of iterations (plus a smoothing factor based on final distance to the origin), and matched to colors, sorted by lightness.

Note that I used lightness in CIE color space. This reduces the noise and increases the vibrancy compared to using lightness as a linear combination of R, G, B values.

Random Cube to Plane Bijection

2021-01-27T19:58:07+01:00

I generated a random minimum spanning tree for both a square plane of length 4096 and a cube of length 256. I ordered the points by means of a breadth-first search and created a bijection between the two such that each coordinate point in the plane had a unique coordinate point in the cube which is equivalent to its colour values (X,Y,Z)=(R,G,B)

Fractal Hue

2021-01-01T22:00:51+01:00

Rainbow Portal

2020-12-29T09:59:37+01:00

Finding the best possible position for each color starting with three seeds.

Penrose Tiling

2020-12-29T09:58:04+01:00

Newtonian Fractal #3 Redux

2020-09-13T14:03:34+02:00

Newtonian Fractal #2 Redux

2020-09-13T14:03:32+02:00

Newtonian Fractal #1 Redux

2020-09-13T14:02:59+02:00

Flaming rectangle

2020-08-05T19:17:47+02:00

A random walk through a sequence of all colours.

Mona Lisa YIY

2020-07-15T09:14:58+02:00

I wanted to achieve the best color and shading reproduction with a single-pass algorithm. This image is converted in about 30 seconds using NumPy and SciKit-Image, and I know that further optimizations are possible.

The source image and a full-RGB image are converted to YIQ color space. The Q (purple-green) channel is not very useful, so it is replaced by another Y (brightness) channel to accentuate shading. Each pixel is binned into a channel and sorted, then replaced with the matching pixel from the full RGB image.

sorted by intensity, hue, and saturation

2020-06-26T16:28:57+02:00

All 24-bit RGB colors sorted by intensity, hue, and saturation and written to a 4096x4096 image in row column order.

Badende Mädchen im Waldteich von Otto Mueller

2020-06-22T11:13:45+02:00

Other 3

2020-06-14T23:57:45+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: are-they-parallel
To Image: all-colors
Transform Image: grid-illusion-with-tiles-and-circles

Other 2

2020-06-14T23:57:28+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: value-layers
To Image: recursive-hilbert
Transform Image: all-colors

Other 1

2020-06-14T23:56:59+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: value-layers
To Image: iterative
Transform Image: all-colors

Stripe 5

2020-06-14T23:56:38+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: iterative
To Image: all-colors
Transform Image: grid-illusion-with-tiles-and-circles

Stripe 4

2020-06-14T23:56:20+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: 256x256x256
To Image: all-colors
Transform Image: clouds-1

Stripe 3

2020-06-14T23:51:18+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: value-layers
To Image: <custom>
Transform Image: 256x256x256

Stripe 2

2020-06-14T23:51:11+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: grid-illusion-with-tiles-and-circles
To Image: <custom>
Transform Image: value-layers

Stripe 1

2020-06-14T23:51:06+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: 256x256x256
To Image: hilbert-rainbow
Transform Image: grid-illusion-with-tiles-and-circles

Wave 5

2020-06-14T23:51:00+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: all-colors
To Image: are-they-parallel
Transform Image: clouds-1

Wave 4

2020-06-14T23:43:43+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: clouds-1
To Image: are-they-parallel
Transform Image: grid-illusion-with-tiles-and-circles

Wave 3

2020-06-14T23:42:47+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: value-layers
To Image: are-they-parallel
Transform Image: grid-illusion-with-tiles-and-circles

Wave 2

2020-06-14T23:42:00+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: value-layers
To Image: are-they-parallel
Transform Image: all-colors

Wave 1

2020-06-14T23:41:11+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: grid-illusion-with-tiles-and-circles
To Image: are-they-parallel
Transform Image: 256x256x256

Round 4

2020-06-14T23:08:15+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: <custom>
To Image: grid-illusion-with-tiles-and-circles
Transform Image: clouds-1

Round 3

2020-06-14T23:07:51+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: all-colors
To Image: grid-illusion-with-tiles-and-circles
Transform Image: clouds-1

Round 2

2020-06-14T23:07:19+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: all-colors
To Image: grid-illusion-with-tiles-and-circles
Transform Image: grid-illusion-with-tiles-and-circles

Round 1

2020-06-14T23:07:01+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: 256x256x256
To Image: grid-illusion-with-tiles-and-circles
Transform Image: clouds-1

Square 3

2020-06-14T22:55:01+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: recursive-hilbert
To Image: all-colors
Transform Image: value-layers

Square 2

2020-06-14T22:52:30+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: grid-illusion-with-tiles-and-circles
To Image: iterative
Transform Image: 256x256x256

Square 1

2020-06-14T22:50:33+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: iterative
To Image: 256x256x256
Transform Image: <custom>

Pattern 4

2020-06-14T22:47:35+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: <custom>
To Image: grid-illusion-with-tiles-and-circles
Transform Image: hilbert-rainbow

Pattern 3

2020-06-14T22:04:51+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: value-layers
To Image: grid-illusion-with-tiles-and-circles
Transform Image: 256x256x256

Pattern 2

2020-06-14T22:04:33+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: https://allrgb.com/value-layers
To Image: https://allrgb.com/recursive-hilbert
Transform Image: 256x256x256

Pattern 1

2020-06-14T20:40:28+02:00

Generated with the Recolor script (https://github.com/jankais3r/Recolor)

From Image: recursive-hilbert
To Image: value-layers
Transform Image: hilbert-rainbow

Ex Pulvere

2020-05-01T22:50:34+02:00

This image is generated by starting with randomly allocated unique colours and then swapping adjacent pixels when the swap generally decreases the distances among pixels of similar colours.

Pixels can only move one step at a time and compete with each other along the paths to their desired locations, so that many get stuck, isolated in areas of a generally different colour.

Many other pixels end up gathering together in the same area where pixels of a different colour also gather together, so that the shapes they form are smoothly entangled or interleaved with each other.

These features give the image an overall dusty look.

The image takes an extremely long time to form and this may be a reason for its significant variety of shapes, despite the simple criterion used to swap pixels.

In particular, because of boundary conditions, different shapes tend to emerge at the corners, the borders and the centre of the image.

Image Licence: Public Domain (CC0).

Small pale squares

2020-05-01T22:50:01+02:00

I tried to create an image that is more gray than a recent extremely gray image (by swapping high-contrast tiny 4x4 checkerboards). I think failed, but the results look fairly nice anyway. Fun fact: no two monitors exist in the universe that display this image in the same way.

Here kitty kitty

2020-04-30T10:26:15+02:00

My cat

Gradient Lines3

2020-04-29T10:56:03+02:00

The effect seems a bit different as the colors are swapped.

Gradient Lines2

2020-04-28T12:09:23+02:00

The color swap makes the image compress better.

Gradient Lines

2020-04-28T11:57:40+02:00

This image is an attempt to have a smooth gradient transition with the primary colors obvious in the thumbnail rather than a pastel look like the other images it was inspired by, such as '256x256x256', 'Color Corners', or 'All Colors' combined with 'Psychedelic Grid' or 'Are They Parallel?'. It is effectively a row sorted version of 'Juxtaposition of Blue Color Levels Square on Red-Green Color Levels Array'.

Bristles

2020-04-25T13:33:40+02:00

Another take on my hamiltonian cycles solution, this time with a pattern that reminds me of flowers, or jamming a brush loaded with paint into a canvas.

Touch of 127.5

2020-04-09T12:34:57+02:00

This is simply the original "thingy" image with a checkerboard half of its pixels negated. Or if the same checkerboard half is instead rotated 180. There is probably some way to make an even grayer image by starting with one whose segment boundaries tend to be higher contrast. But that would be a subtle reduction in only a 1D quantity. As far as goes the 2D bulk, this is about as gray as it gets.

Fire on the Mountain

2020-04-03T14:11:58+02:00

I'm revisiting my allRGB solution six years later, taking the same premise (mapping a hamiltonian cycle in the colors to a hamiltonian cycle in the pixels) but different approaches to the spanning tree, and a full rewrite of the code.

In this example, I like the contrast between the lights and darks of similar hues, and how many of the most saturated colors are near the center. I see a green and yellow mountainside with a fire erupting in reds, oranges, and pinks, casting in a shadow in purples, pinks and blues to the right.

Nonsuch Pattern

2020-03-22T17:32:03+01:00

This image is generated by starting with randomly allocated unique colours and then swapping pixels to make them generally closer in colour to their neighbouring pixels.

The outcome of this operation may be different depending on how pixel swaps are prioritised and when the swapping is stopped.

In this variant a fine grained mixture of smooth transitions and sharp edges among colours is emerging.

As pixels are only affected by their closest pixels, specks of colour may only grow up to a small size before being constrained by neighbouring specks; nevertheless certain shapes emerge that span more widely, over different colours.

At the largest scale, different patterns also appear to start forming from the shapes but soon end up constraining each other.

Image Licence: Public Domain (CC0).

sorted by hamming weight

2020-03-08T21:00:53+01:00

pseudocode:

c=0
for i = 0..(256^3)-1:
  w = hamming_weight(i)
  c = count[w]
  weight[w][c]=i
  count[w] = c + 1

for c=0..24:
  w = 0
  do {
    out = weight[c][w]
    if ( out != 0 ^^ c == 0 )
      pixelRGB = out
  } while ( out != 0)

Omnichromatic Polarisation

2020-02-10T09:55:54+01:00

There are two symmetrical poles in this image, one left and the other right of its centre.

Each pixel in the image has a range and an angle.

The range is the square distance from the left pole divided by the linear distance from the right pole.

The angle is with respect to the centre of the image and is positive irrespective of whether it is clockwise or anti-clockwise.

The red component varies monotonically with the range.

Within each constant red area, the green component varies monotonically with the angle ranking within that area.

Within each constant red and green area, the blue component varies monotonically with the composite range and angle ranking within that area. Increase and decrease of both range and angle alternate to make patterns wider and transitions across areas smoother.

Image Licence: Public Domain (CC0).

Grid Illusion with Tiles and Circles

2020-02-08T17:57:07+01:00

This image is composed of three nested levels of tiles, one per colour component.

Within each tile a circular pattern is formed by varying the intensity of the associated colour component.

With the specific allocation of colours in this image an optical illusion emerges: darker dots seemingly appear and disappear at some intersections of the mid-level green/yellow grid.

Image Licence: Public Domain (CC0).

Oh Lenna

2020-02-06T11:56:31+01:00

Another weighted RGB sort, except this time using my own algorithm.

Oh! And I think I found the 'secret' to sort-based palleting... add noise(about 10%) to the image. It really smooths out the large areas of roughly the same color.

Grand Canyon panorama

2020-02-06T09:41:46+01:00

Who says it has to be square?

Circlebits

2019-11-03T15:16:52+01:00

There are 24 circles around the center and each circle is responsible for one bit of color in pixels belonging to that circle. Additional colors are chosen from among the closest to the desired color by calculating the distance in the rgb color space.

Two Fifty Six

2019-10-19T13:57:03+02:00

To celebrate the 256th image uploaded to allRGB, here is a collage of the first 256 uploads (including this one!), thumbnailed to 256×256 pixels each with a random sampling algorithm.

While the pool of undrawn colors is nonempty, pick one at random, find its location in the thumbnail of a random one of the 255 existing images, and draw it there. If another color was already drawn there, bump that color to the corresponding location in the thumbnail of _this_ image, and so on. Colors bumped from the upper-left pixel (which corresponds to itself) move back into the pool to be redrawn later.

https://github.com/andersk/allrgb

Domain warped simplex noise as HSV.

2019-10-18T18:06:22+02:00

I started with 3 simplex noise fields, using double domain warping.

These fields are for H, S and V.

After conversion from HSV to HDR RGB, all pixels are sorted on HDR RGB value.

Then the index after sorting is used to position the colour.

The Sun

2019-09-16T13:59:08+02:00

Wood Rainbow

2019-09-16T13:59:03+02:00

Metallic Rainbow

2019-09-16T13:37:21+02:00

Frosted Rainbow

2019-09-16T13:23:03+02:00

Point of light

2019-09-16T12:49:11+02:00

0x010101

2019-09-11T20:26:04+02:00

starting from black, add 0x010101 to each pixel

0x5eb537

2019-09-07T22:47:15+02:00

just adds the 24-bit big-endian rgb value of each pixel, starting with 0,0=0x5eb537

why this number? look at 7,0

CORALXYZ

2019-09-01T13:49:48+02:00

Diffusion limited aggregation ("coral") using Euclidean distance on the XYZ color space.

Grayscale to Rainbow

2019-07-28T21:22:57+02:00

1. Starting with #000000, create a grayscale gradient to #FFFFFF.

2. Create a gradient from #010000 to #FFFEFE with the correct length to encompass all red values between. Go through each of the 5 other hues possible for the same gradient length.

3. Continue the process, creating a new gradient starting with an increased starting red value and ending with a decreasing green and blue value. Create the rest of the other gradients of the same length at increasing hue values.

4. Repeat step 3 until the starting red value has reached 255, the ending green and blue values have reached 0, and the final hue has been reached.

The image is drawn left to right - row by row - top to bottom.

Image Licence: Public Domain (CC0).

Reversed chilly run

2019-06-20T11:36:44+02:00

Reversed chilly run

First Attempt

2019-06-20T11:36:38+02:00

balloon

2019-05-06T19:45:41+02:00

from arichnad/colorsort on github.

stegano-monogram

2019-04-19T17:09:30+02:00

The “dragonbush” pattern that I posted in 2013 involves a sequence of rotations, all in the same direction. Here is the same algo but with the turns keyed to 23 bits extracted from the letters RGBAL.

The color scheme is chosen (out of more than 2**33 possible) to make the most complex edges stand out.

colordeposit lab-rgb

2019-02-23T12:00:47+01:00

deposited from the center in RGB order

colordeposit lab-desc-lum

2019-02-23T12:00:44+01:00

deposited from the center in order of descending luminance

colordeposit lab-luv+v

2019-02-23T11:55:25+01:00

deposited from the center in ascending LUV-V order

Noisy spiral

2018-10-27T10:25:13+02:00

This is just some Archimedean spiral.

The area encapsulated by the spiral curve is filled with noise (with a rising radius alongside the curve).

Colored Disks

2018-09-10T10:57:08+02:00

The image contains 4096 randomly placed colored discs, each of which has a visible (uncovered) area of exactly 4096 pixels.

Clouds 1

2018-09-10T10:57:06+02:00

Algorithm: Pick a random unused colour and find a place where nearby pixels are similar, then place it there; repeat until all colours are placed.

Code: https://gitlab.com/snippets/1752310

Recursive Hilbert

2018-07-13T10:05:04+02:00

The 3D Hilbert Curve going through the 3D RGB cube mapped to a 2D Hilbert Curve on an image.

Rotated Checkerboard (Smoother variant of Color Corners)

2018-07-09T13:46:51+02:00

Same idea as my first entry, but instead the blue bits go up in their respective squares diagonally, creating diamond shapes.

Image Licence: Public Domain (CC0).

Juxtaposition of Blue Color Levels Square on Red-Green Color Levels Array

2018-07-09T13:46:48+02:00

Similar to All Colors, but has an overall smoother result. A square of 0-255 blue bits is overlaid on an array of 16x16px 0-255 red/green bits, with red levels increasing towards the right and green levels increasing towards the bottom. The key difference is that the darkest corners of adjacent blue squares touch and lightest corners of adjacent blue squares touch, creating smooth transitions.

Image Licence: Public Domain (CC0).

Numbers Lucent

2018-06-10T17:44:37+02:00

My take at image recreation

2018-05-06T16:28:47+02:00

After 10^10 iterations, this image is probably the worst one on this site.

Hue KD Tree

2018-04-14T17:08:58+02:00

Random KD tree with nodes partitioned by hue.

KD: Fixed Edition

2018-04-14T17:05:15+02:00

Fixed KD tree; resolved a faulty assumption, resulting in a brand new, less-noisy image!

A rearrangement of pixels

2018-03-25T13:55:37+02:00

Sort colors with some magic, then select a point in the middle, fill it, select a random point with abs(dx)+abs(dy)<50, fill that, repeat, if stuck for 1000 iterations select a random unfilled point. Given my non-existent optimisation skills took about 2 hours.

Pomeroy

2018-02-10T11:29:32+01:00

Using data from the USGS national map database, elevation measurements around Pomeroy, Washington are divided into 64 levels. Each level is given colors based on a hue sort. The levels are then filled from left to right using a luminance sort.

Squared Away

2018-01-31T10:29:56+01:00

Sorted by sum

2017-12-30T15:58:13+01:00

All colors sorted by sum (r+g+b).

drawn left to right - row by row - top to bottom.

RGB - Spiral

2017-11-29T12:28:26+01:00

Green makes a big spiral with 256 tiles of 256x256 pixels; within each 'Green' tile, Red makes a small spiral with 256 tiles of 16x16 pixels; and within each 'Red' tile there's a tiny spiral of Blue.

G - Spiral

2017-11-15T13:57:35+01:00

Green spirals from dark outside to bright inside; Red and Blue are smooth within each tile.

Sorted hilbert curve

2017-11-04T13:24:43+01:00

All colors placed along hilbert curve while incrementing B and letting it overflow into G and R. Then pixels in every row are sorted by hue and all rows are sorted by average brightness.

Noisy

2017-09-27T22:45:45+02:00

This algorithm increases the brightness of each pixel until it finds an unused color. If that alters the color too much, it picks a random one out of what's left of the 16777216 colors. This is a relatively quick run, but I'll probably try changing the parameters so it runs for a day or so.

Hilbert Rainbow

2017-09-18T11:58:21+02:00

Hilbert traversal through the RGB cube.

Smoothly sliced RGB cube

2017-08-08T09:43:08+02:00

Assume G is the height of the cube.

Then, RB are the 2D slice.

Increasing G, while flipping the slice so the resulted image would look with smooth transitions.

Kleinmond

2017-07-27T23:48:05+02:00

An awesome place in Western Cape I went rock climbing in March 2016.●●●●●●●●●

Curiosity

2017-05-20T10:24:10+02:00

Improved Orion Nebula?

2017-05-17T09:45:12+02:00

Improved Chilly Run

2017-05-07T12:30:47+02:00

Not as fast as Death9 algorithm, but better image quality. Could it be possible to improve the image quality even further?

Beautiful flower

2017-05-07T12:28:47+02:00

Improved Lemur

2017-05-06T17:57:20+02:00

Improved Nevermind

2017-05-06T17:51:45+02:00

Mona Lisa

2017-05-04T09:24:22+02:00

Best allRGB Mona Lisa ever. 8,000,000,000 iterations.

Globos 3

2017-05-03T22:42:42+02:00

I finally was able to make a good algorithm to transform images to allRGB. It has take a lot of work, a lot of trial and fail, a lot of investigation and different aproachs to obtain the very best image possible. Keys for this algorithm are: genetic (evolutive) algorithm, make use of RGB and Lab color spaces, and gaussian dithering (It uses a 7x7 matrix of error dispersion). Next improvements: multithreading and CUDA processing (speed improvements). Right now, It takes two days to compute a good image. I want to reduce it to 30 minutes or less whith the same or better quality.

Improved Whitetail Deer

2017-05-03T22:34:29+02:00

Improved version of the Whitetail Deer originaly made by travislambert. Better color fidelity, better blacks, smooth dithering.

Improved Fruit Basket

2017-04-30T21:45:17+02:00

Improved version of the fruit basket originaly made by travislambert. Better color fidelity, better blacks, smooth dithering.

Improved Signing of the CRA

2017-04-29T17:34:55+02:00

The same image as that of andersk. In this case, Lab color space wheight is x3 for better blacks.

Happy earth day

2017-04-22T22:08:01+02:00

It's my best image-to-allRGB algorithm. It's made whith Processing. It has taken 1-2 days to run, 3,500,000,000 iterations (2 pixels are swaped if it improves the image fidelity)

Algorithm caracteristics:

Genetic (evolutive) algorithm.
7x7 matrix gaussian dithering (error difussion)
It uses RGB and Lab color spaces for better color fidelity.

Algorithm inputs:

allRGB.png noise image (start point). All 16,777,216 colors are in random positions.
Image.png whith 4096x4096 dimensions.
L.png, a.png and b.png whith 4096x4096 dimensions for Lab color space calculations.

Chaos Game Representation of DNA

2017-03-28T20:50:34+02:00

12-mer DNA nucleotides were assigned RGB colors in order and then placed in square according to Chaos Game Representation concept.

RGB Marble

2017-03-18T13:30:10+01:00

made from one of NASA's Blue Marble photos: https://commons.wikimedia.org/wiki/File:Nasa_blue_marble.jpg

Colors were selected from an Lab-color octree-of-color-arrays with each dimension being split 16 times. When a node of the octree runs out of colors, its reference is replaced with a nearby node that still contains colors.

The Most Colorful Kiss

2017-01-08T18:02:51+01:00

Rendered in 462 seconds on a Phenom II X2 555.

Minkowski's Muse

2016-11-22T22:50:32+01:00

The algorithm behind this is similar to my other image, Eye of the Hypnotoad. The main difference is that this one is bounded by the Minkowski distance --- with p = 0.5 --- from the center instead of euclidean. When I say bounded that means that the breadth first traversal can't traverse past a given distance that increases with each iteration. There is also some proprietary tree pruning methods at play.

The Eye of the Hypnotoad

2016-11-22T22:41:37+01:00

Be mesmerized. It is the Hilbert curve of the RGB cube mapped to the image based on the euclidean distance from the center.

Newtonian Fractal #3

2016-10-12T21:45:51+02:00

Newtonian Fractal #2

2016-10-12T21:45:49+02:00

Newtonian Fractal #1

2016-10-11T21:16:23+02:00

KD Tree

2016-10-11T21:15:59+02:00

Pixels are recursively filtered into random axis-aligned binary partitions based on brightness (30*R + 59*G + 11*B). Partitions are rotated at each level. There's a bug causing each split to create 3 instead 2 visually distinct regions, but at the end of the day, isn't it just about making a cool-looking picture?

Scales

2016-08-26T14:20:26+02:00

Pixels written in RGB order, but shifted by a product of primes (17 * 257 * 4097)

Rainbow Squares

2016-07-28T22:08:27+02:00

stained glass

2016-07-13T18:30:00+02:00

Created by (1) making a random Voronoi tiling; (2) segmenting the RGB color space into parts that match the sizes of the tiles as closely as possible, via simulated annealing. (3) Once the colors are determined for each tile, they are sorted by distance to the center color for each tile and plotted. -Jonathan Cross

Signing of the Civil Right Act

2016-07-09T16:59:27+02:00

President Lyndon B. Johnson speaks to the nation before signing the Civil Rights Act of 1964.

http://www.lbjlibrary.net/collections/photo-archive/photolab-detail.html?id=1107

The source image was converted using a fast (quasilinear-time) recursive subdivision algorithm. Let A be the (multi)set of all colors in the source image, and let B be the set of all colors in the RGB cube. Divide A into two sets A₁, A₂ by a plane perpendicular to the principal component of A in a perceptual colorspace. Divide B into B₁, B₂ with a parallel plane such that B₁, B₂ have the same sizes of A₁, A₂. Recurse on A₁ and B₁, then on A₂ and B₂.

random unfolding

2016-07-01T15:47:31+02:00

I imitate andersk's Unfolded Color Cube, randomizing the sequence and direction of folds as well as the assignment of axes to colors, for 6*70*2^8 = 107520 possibilities.

Future extension: the final figure has 15 creases each way; the first fold could be on any of them!

hierarchical Hilbert

2016-06-26T21:22:12+02:00

Since the sophisticated Hilbert (a 3space curve mapped to a 2space curve) has already been done, here's a naïve Hilbert: small squares covering the green range, within mid-size squares covering the red range, within the big square covering the blue range.

Fruit Basket (3x3/5x5)

2016-05-27T14:38:24+02:00

This fruit basket image was created using a multi-stage 3x3/5x5 error diffusion algorithm which seems to concentrate the color better than the 3x3 alone at the expense of making the image too bright.

Fruit Basket (3x3)

2016-05-27T14:36:46+02:00

This fruit basket image was created using a 3x3 error diffusion algorithm which gives the fruit a more realistic appearance over the multi-stage 3x3/5x5 but with a slight haze.

West Virginia Whitetail Deer

2016-05-27T14:09:40+02:00

Babcock State Park in West Virginia

2016-05-27T14:02:40+02:00

Two Parrots

2016-05-27T13:54:41+02:00

Fiery

2016-01-10T02:42:20+01:00

Globos 2

2015-08-18T15:51:10+02:00

It's my second allRGB picture. In this case I used a new genetic algorithm (evolution algorithm) swapping two pixels of an allRGB noise image if the change Improve the allRGB picture. I measure the sum of the squared difference of the two pixels to the original and its exchange, and compare them. If the swap the sum is less, I change. I use the squared difference because generate better results visually. Also, do not calculate the difference in the RGB color space, but in the Lab color space, much more accurate when measuring human visual difference between two colors, as it is based on studies of human perception. My next step to improve even more the algorithm is to use error diffusion (dithering) for better visual results, and multi-threading for faster calculations :)

Es mi segunda imagen allRGB. En este caso he usado un nuevo algoritmo genético (algoritmo evolutivo) que intercambia dos píxeles de una imagen de ruido allRGB si el cambio mejora la imagen allRGB. Mido la suma de los cuadrados de la diferencia de los dos píxeles con respecto a la original y su intercambio, y los comparo. Si la suma del intercambio es menor, hago el intercambio efectivo. He usado la diferencia al cuadrado porque genera mejores resultados visualmente. Además, no he calculado la diferencia en el espacio de color RGB, sino en el espacio de color Lab, mucho más preciso a la hora de medir la diferencia visual humana entre dos colores, ya que está basado en estudios de la percepción humana. Mi siguiente paso para mejorar aún más el algoritmo es usar difusión del error (dithering) para obtener mejores resultados visuales, y procesamiento multi-hilo para cálculos más rápidos :)

Dif_TOTAL = (dif_L^2+delta_a^2+delta_b^2) + (delta_R^2+delta_G^2+delta_B^2)/10

Emergent Fractals

2015-07-23T09:57:35+02:00

These interesting fractal patterns emerged when I had the sigma change over time in my allrgb algorithm.

Iterative

2015-06-24T12:18:28+02:00

Start with an 8x8 base image containing all 6-bit colors. Then iteratively scale the image by a factor of 8, multiply all values by 4 and fill the missing bits using the base image. In this case, maximally smooth (L1 norm, 4 neighbors, periodic boundary) base image was chosen.

Globos

2015-05-02T18:52:24+02:00

This is my first allRGB image. Made with Processing, it has taken a week to run. The algorithm searched the closest color unused, starting at the top.

Esta es mi primera imagen allRGB. Hecho en Processing, ha tardado una semana en ejecutarse. El algoritmo ha usado el color más cercano sin usar, empezando por arriba.

Crystalline

2015-02-25T05:37:12+01:00

Modified version of fejesjoco's algorithm.

http://whoiskylefinn.com/colors.html#paint=3,big,dirs=0xaa,picky=2501,seed=0.397446742746979

PNG 20

2015-02-19T12:32:52+01:00

Portable Network Graphics was born 20 years ago. Congratulations and lets celebrate!

"Me mate Bertie"

2015-01-31T00:58:17+01:00

Painted fully balanced @ 343*343 – Granularity of 49 component Values 0,5,10,15…..240 Resized to 4,096 * 4,096 nearest neighbour & then fully rebalanced – Granularity of 256 component values 0,1,2,3…..255

Structure of a Spectrum

2015-01-28T03:01:01+01:00

Nearest-Neighbor Flood Fill

2014-11-11T18:10:54+01:00

The circle is filled using a flood fill algorithm that walks along the inside border of the circle, filling each pixel with the nearest neighbor to the average of the already-filled in pixels. The circle border is generated by stepping through the Hue-Sorted RGB space for each octant. The outside of the circle is filled using a flood-fill based off of a randomly added to stack. I implemented the nearest neighbor search using an oct-tree.

Recursive Binary Tree

2014-10-11T01:58:56+02:00

This tree has over 600 million branches. Each branch splits off from its origin at an angle of +- pi/8. Sorted by luminance.

Starry Night

2014-09-21T00:45:47+02:00

Converted using a repetitive sort & shake of used colors in the colorspace. Takes many hours for 4096*4096 images. Triangulaton would be best conversion method for keeping color adjacency, but need to define the hull first off and have not ascertained how this can be done. This was done two years ago and have not worked on them since then.

Irises

2014-09-12T03:49:17+02:00

High definition van Gogh Irises converted to allRGB using a repetitive sort & shake sort method on colors when in the colorspace. Has minimal dithering. Still have not managed to get triangulation conversion method functioning.

shards

2014-08-25T06:20:13+02:00

Funky voronoi

The Mandelbrot

2014-08-11T18:18:28+02:00

I generated a mandelbrot set and applied all colors sorted by total r+g+b value to pixels sorted by number of fractal iterations

La Gioconda

2014-08-01T22:39:49+02:00

Evolved from an image containing all the 2^24 colors by comparing an average color of two 3x3 pixel areas with the original picture colors and possible swapping.

Who said interlacing reduces compressibility?

2014-07-25T13:11:11+02:00

It is known that interlacing reduces compressibility. But not with this image! I created it especially to be well compressible with PNG's Adam7 interlacing. Try to save it without interlacing and see the difference...it is huge.

Delicate Arch 2

2014-06-24T11:02:33+02:00

Another permutation of the random shuffle with quality metric performed on pic of Delicate Arch, Arches National Park, Utah, USA.

Delicate Arch

2014-06-24T10:58:55+02:00

Initialize a random image, pick two pixels at random and swap if the quality metric improves. Various quality metrics give various results.

This version used a picture of Delicate Arch in Arches National Park, Utah, USA as a quality metric.

Unfolded Color Cube

2014-06-23T12:34:53+02:00

Imagine taking the 4096×4096 square and folding it in half eight times, being careful with the edges so as not to break continuity. The result fits into the 256×256×256 RGB color cube. This is what you get after unfolding that back to a square.

Growing Squares

2014-05-29T19:29:16+02:00

Squares originate at random points and grow until they hit the edge of the image or another square. Sorted by hue.

Sunset

2014-05-20T20:26:43+02:00

Sorted by dividing red by blue modulus green

Luminance Spiral

2014-05-20T20:08:33+02:00

Colors sorted by luminance and then spiraled inwards.

NevermindRGB

2014-05-18T23:22:09+02:00

Color-mapped with the Processing language using an oct-tree data structure and algorithm

Kruskal

2014-04-29T10:53:45+02:00

Generate a random spanning tree of the RGB cube, and a random spanning tree of the pixel grid, by randomising the edge weights and finding a minimal spanning tree, then do a simultaneous breadth-first search of these trees to obtain a bijection between the RGB cube and the pixel grid. Compare with http://allrgb.com/wilson-00

Spirals - Rainbow Candy

2014-04-29T06:37:26+02:00

Spirals drawn from random points until they hit something. Colors sorted by value, then saturation, then hue.

Spirals - Big Colorful Circles

2014-04-29T06:32:44+02:00

Spirals drawn from random points until they hit something. Colors sorted by hue, then saturation, then value.

Spirals - Hot and Cold

2014-04-29T06:25:54+02:00

Spirals drawn from random points until they hit something. Colors sorted by raw hex value.

Evolved Mona

2014-04-19T19:37:18+02:00

A genetic algorithm transforms a uniform image containing a grid-like pattern of every colour. It uses a reference image and swaps two pixels at a time, but only if the swap makes the image closer to the reference image. This image was run for ~5,000,000,000 generations (12 hours on my old laptop). You can find out more and download the program here: https://troydev.co.uk/every-rgb. It is fully open source and in C++, feel free to use the source code as you wish =]

Spaceships and Elbows

2014-04-18T08:08:12+02:00

An alternating recursion between an elbow shape and a blob that looks like a spaceship.

Storm

2014-04-17T21:53:48+02:00

Growing Variant 2

2014-04-15T23:12:31+02:00

Le jardin de Monet à Giverny

2014-04-13T09:23:01+02:00

moonrise

2014-04-06T05:22:30+02:00

Kinda Lorenzian in principle, making a miniscule tweak to the sort heuristic midway. Reminds me of a calm sea.

fabrics

2014-04-05T18:55:32+02:00

Colours split into buckets based on angle from the six coloured corners of the RGB cube.

Lady in gray fur

2014-03-30T15:49:50+02:00

Different zoom levels produce various moire effects because of the regular structure.

Algorithm design by Christoph Stamm.

Las grupas de Sorolla

2014-03-28T00:34:37+01:00

In homage to one of the great Valencian Impressionists.

Psychedelic Grid

2014-03-23T19:21:20+01:00

Standard red-green color-charts combined with blue spiral. Algorithm design by Christoph Stamm

Grayscale

2014-03-23T19:12:51+01:00

All colors ordered by the sum of their (R+G+B) intensity. Non-gray pixels appear in triples of red-, green-, and blue-dominant colors. Algorithm design by Christoph Stamm

Randomiser

2014-03-19T01:18:03+01:00

Random walks across both the RGB cube for pen colors and pen location. A least delta search is performed on collisions with used up colors and pixels.

RGB Snails

2014-03-18T20:53:35+01:00

An edge-wrapped growth variant (the image tiles seamlessly), picking colours from a list in "for R for G for B" order, and placing to minimise RGB delta to neighbouring pixels.

First All RBG

2014-03-17T06:38:05+01:00

Making sure I've got this allrgb thing working.

Rainbow Fractal

2014-03-16T00:29:06+01:00

A rainbow rendering of the mandelbrot set. This created by sorting every colour by Hue, then randomly shuffling each set of pixels that share the same iteration in the fractal via histogram generation.

tutti frutti

2014-03-15T20:39:30+01:00

A hundred circles grow outward from bright colours at their centres.

At the same time, the space between them is filled with dark colours.

CHL

2014-03-15T11:47:13+01:00

All colours sorted by Chroma, and placed into the image top-left to bottom right. Rows are then sorted by Hue, the image is transposed, then all rows are sorted by Luminosity.

Starlight

2014-03-15T03:40:16+01:00

for each color c1:
    for each color c2 already used:
        if |c1 - c2| < threshold:
            place c1 next to c2
    if c1 hasn't been placed yet:
        place c1 at a random location

Pi Day

2014-03-14T18:21:43+01:00

A thin ring of light colours is thickened by adding colours which closely match their neighbours.

Twist

2014-03-14T06:20:05+01:00

A harmonograph traces a path. The first pixel is white. For subsequent pixels, a colour which is close to its neighbours is chosen.

Hamiltonian 1

2014-03-14T00:56:36+01:00

Pick an arbitrary (but not really uniformly random) Hamiltonian Cycle over the 4096x4096 pixel grid, and another over the 256x256x256 color cube. Starting at (2048, 2048) and (128, 128, 128), walk along the hamiltonian cycles in-step, placing colors at corresponding pixel locations.

The hamiltonian cycles were generated from a spanning tree of the half-size grids. For the grid, I joined sets of four pixels into separate cycles, and joined them together when they were joined by an edge of the spanning tree. For the pixel cube, I used sets of 8 pixels arranged in a cube.

RGB Pride

2014-03-13T22:19:15+01:00

All colours are placed randomly, rows are sorted by Luminosity, the image is transposed, then all rows are sorted by Hue.

zCR 1

2014-03-13T00:06:53+01:00

All colours are placed randomly, rows are sorted by Chroma, the image is transposed, then all rows are sorted by Luminosity.

Luminosity is calculated as (0.2126*r) + (0.7152*g) + (0.0722*b).

Chroma is calculated as Max(r,g,b) - Min(r,g,b).

Julia Set

2014-03-12T21:34:32+01:00

my two-penn'orth

Waterfalls

2014-03-12T00:39:33+01:00

This looks like waterfalls. Just a few sorts, first the whole image by hue, then a few vertical and horizontal hue and lightness sorts.

Workbench

2014-03-11T15:25:54+01:00

A workbench.

Random Triangles

2014-03-10T21:12:08+01:00

This is an incarnation of a random walk.

The start position the upper-left for the image and a random color random for the cube.

Both the path in the color cube and the path in the image are random walks, with a twist (actually a straight). All diagonally connected pixels are a valid direction. That's 8 directions for the image walk and 26 directions for the color walk. Once a direction is chosen, it keeps going straight. Only when it can't go straight anymore it chooses an available random direction at random. When it hits a dead end and can't turn anywhere, the path it traced is traced in reverse until a previously visited point is found for which a valid direction exists.

Unicorn Vomit

2014-03-10T20:21:14+01:00

A growth variant using a colour list sorted by chroma.

Burst 2

2014-03-10T19:57:17+01:00

Quilty

2014-03-10T17:41:00+01:00

A few colours are placed at random locations. Randomly selected colours are then placed next to similar colours in the image. Initially, all locations are confined to a rectangular grid (until the grid is full). Diamond shapes emerge.

Growing Variant

2014-03-10T01:09:55+01:00

Growing from multiple points using local similarity.

Blood start, blood end.

2014-03-09T12:57:46+01:00

Made with FJ_RGBGenerator.exe via script .bat:

FJ_RGBGenerator.exe 256 4096 4096 32 63 50 0 11111111 hue-1 one

Lemur

2014-03-09T05:46:58+01:00

Created as a part of the question that spawned so many of the recent submissions.

Chrome disc

2014-03-08T22:41:53+01:00

This is created by an algorithm inspired by fejesjoco (in the same challenge). Start with a black pixel in the center. Iterate every pixel in the image, from closest to the center to furthest from the enter. For each pixel, calculate the average color of all placed pixels out of the 8 neighboring pixels. Find colors in the color cube that are not already taken and as close as possible to the calculated color. The closeness measure is the distance between gray-scale values. If multiple equally close colors are found, take the ones closest to black, using the negative-infinity norm (min(r, g, b)). If multiple of these are found, choose a random one. Place the found color at the found point.

Growing Shards

2014-03-08T00:20:31+01:00

This is created by an algorithm inspired by fejesjoco (in the same challenge). Start with a black pixel in the center. For every pixel placed, mark the 8 surrounding pixels as available (if not already placed). Find one marked point by searching all pixels in the image in a specific order until a marked pixel is encountered. This specific order is a random permutation of all pixel positions. Every time all points are checked, the permutation is shuffled again. Then, calculate the average color of all placed pixels out of the 8 neighboring pixels. Find colors in the color cube that are not already taken and as close as possible to the calculated color. The closeness measure is the infinity norm (max(dr, dg, db); the skin of a cube). If multiple equally close colors are found, take the ones closest to black, using the negative-infinity norm (min(r, g, b)). If multiple of these are found, choose a random one. Place the found color at the found point.

Burst

2014-03-08T00:10:46+01:00

Wilson 00

2014-03-06T00:51:39+01:00

Generate a random spanning tree of the RGB cube, and a random spanning tree of the pixel grid, using Wilson's algorithm, then do a simultaneous breadth-first search of these trees to obtain a bijection between the RGB cube and the pixel grid. Code at https://gist.github.com/robinhouston/9360681

Growing 4

2014-03-04T17:46:07+01:00

I made it with a program that grows this with an algorithm. You can find the description and the program on my blog at joco.name.

Growing 3

2014-03-03T22:01:54+01:00

I made it with a program that grows this with an algorithm. You can find the description and the program on my blog at joco.name.

Growing 2

2014-03-03T22:00:06+01:00

I made it with a program that grows this with an algorithm. You can find the description and the program on my blog at joco.name.

Hilbert

2014-03-03T21:55:48+01:00

I walked a 3-dimensional Hilbert curve in the RGB space to cover all values, and placed them in the image along a 2-dimensional Hilbert curve

Growing 1

2014-03-03T21:33:08+01:00

I made it with a program that grows this with an algorithm. You can find the description and the program on my blog at joco.name.

Diamonds

2014-03-01T04:04:04+01:00

Tileable, diamonds created by walking paths through color cube and projecting them onto paths through image.

4 Levels of Value Iteration

2014-02-19T07:04:13+01:00

This is based on 4^3=64. And since 64^4=16777216, there are 4 levels of cube within cube. I skipped over 3 levels, because it requires one at 2^12 and two at 2^6, and so lacks a certain iterational symmetry, let's say. But this one is the most cube levels you can also arrange into a square. I will probably do the three level image after deciding on the ideal configuration.

Value Layers OF Value Layers

2014-02-16T17:34:22+01:00

This is as if the color cube was diced into 64^2=4096=16^3 little cubes, and each of them was diced again into 4096 single-color cubes, and both cube sets were arranged in value layers. 16^6=16,777,216.

Gray ortho shuffle

2013-12-02T07:03:19+01:00

Another of 4 7900 1600 (?) versions of this concept.

dragonbush B

2013-12-02T07:00:42+01:00

Another of 94 6551 1770 color assignments for this concept.

Value Layers

2013-11-30T10:22:46+01:00

This shows all 766 value layers (sections where coordinate sums are equal) of the 256 edged cube. It is composed of 256 square segments like the "Thingy" image, but in this case 254 of the squares contain 3 layers (2 triangles and a hexagon) and the remaining 2 squares, in the upper left and lower right, contain 2 triangles each. In a typical cube these would all be regular polygons, but for the purposes of this square image, it is as if a distorted cube was sectioned, giving polygons that have 45, 90, and 135 degree angles.

Gray shuffle

2013-11-17T09:56:02+01:00

Coordinates of each pixel are converted to Gray code; the bits thereof assigned to the three channels; the result converted from Gray code.

dragonbush tile

2013-11-17T09:53:25+01:00

Coordinates of each pixel are expressed as a complex number in base (-1±i). The bits thereof are assigned to the color channels in one of more than nine billion permutations. This figure tiles; 81 (smaller) versions of it rotate as my computer's background.

Diffusive

2013-10-03T14:59:17+02:00

Color diffusion algorithm, inspired by the works of ita.

Horses

2013-09-30T12:07:41+02:00

RGB color space with error diffusion. Thanks to Eric Burnett for inspiration!

Wedding Table

2013-09-28T18:15:09+02:00

Rewrote in OpenCL - now runs very quickly.

Sadie Improved

2013-09-20T13:05:27+02:00

Improved algorithm, same image. Much less visible noise, and better color matching.

Flower Improved

2013-09-20T13:03:18+02:00

Improved algorithm, same image. Much less visible noise, and better color matching.

Sadie

2013-09-19T19:49:19+02:00

Experiment with blacks, whites, grays, and different textures.

Flower

2013-09-19T09:38:59+02:00

Surprising colors are still representable.

Gray's Code

2013-09-05T01:16:23+02:00

Rearanged the Colors So they follow Gray's Code with base 255 :)

QR Code

2013-08-16T20:02:52+02:00

Separated colors by intensity and randomized. The contrast is pretty low, so it makes the QR code hard to read. Maybe there is a better criterion for splitting the colors.

Earth

2013-08-11T18:28:19+02:00

Generated using https://github.com/beardtree/allrgb

clearly all RGB

2013-07-08T16:30:28+02:00

colors randomized and divided into mostly red, mostly green, mostly blue (and mostly gray)

For p in primes

2013-04-02T16:06:34+02:00

Colors from 0-16777215. Where 0 is 0, 0, 0 and 16777215 is 255, 255, 255.
Position from 0-16777215. Where 0 is top left and 16777215 is bottom right. For each prime number these two rules are applied. To use allRGB and give contrast to the prime numbers, all non prime numbers reverse the color: position 0 (0,0) is color 16777215 (255,255,255).

Odd and even

2013-03-27T13:02:40+01:00

All RGB colors from 0-16777215. Where 0 = 0, 0, 0 and 16777215 = 255, 255, 255. All even numbers are in the upper half of the image. All odd numbers in the lower.

for r for g for b

2013-03-25T15:53:12+01:00

l = []

for r in range(256):
    for g in range(256):
        for b in range(256):
            if x < w:
                pix[x, y] = (r, g, b)
                x += 1
            else:
                #Don't use this color yet. Creates the diagonal.
                l.append((r, g, b))
                x = 0   
                y += 1

#this is the last row of pixels                
for i in l:
    pix[x, y] = i
    x += 1

ChillyRun2

2013-03-22T23:14:47+01:00

This is my 5th algorithm to convert pictures into AllRGB images. Note the subtle gradients, lack of blockiness and even error distribution. This algorithm uses Nvidia CUDA and takes about 90 seconds, compare that to my first algorithm (in 2009) which took several days to compute.

Spirals

2012-07-18T22:23:44+02:00

A mix of Spiral and fGrid.

BOB16M

2012-06-06T18:14:52+02:00

This is my take on the iconic video game character "Bob" from Bubble Bobble.

Diagonal 2x2x4-4095

2012-06-06T18:13:19+02:00

Pretty simple design that groups the colors first by bits 7-6, then 5-4 and finally 3-0. The diagonal lines are caused by using a stride of 4095.

Spring Palette

2012-03-30T01:19:36+02:00

16,777,216 colors arranged in a bright and cheery 16x16 grid. Just in time for Spring!

All Colors

2012-03-30T01:18:35+02:00

All images contain all 2^24 = 16M = 16.777.216 RGB colors exactly once. Algorithm design by Christoph Stamm, 2011.

Gradient

2011-12-06T14:11:50+01:00

All RGB colors arranged according to brightness.

Hexagon

2011-10-07T20:55:45+02:00

Recursive Hexagons made of hexagons.

Skull

2011-07-24T16:30:08+02:00

Made with php.

Peafowl

2011-07-20T00:06:35+02:00

In the preview/from a distance, you only see a pattern of blue and green lines. In the full version/from nearby, circular patterns emerge. Rendered with Processing.

Z

2011-07-19T16:11:44+02:00

Created by interleaving the bits of the three RGB components of each color, then deinterleaving into X and Y coordinates. Partly inspired by #33, this variation effectively replaces the Hilbert curve with a Z-order curve, producing a distinctly different texture and effect.

The Space Needle

2011-07-14T12:24:53+02:00

Space Needle - Seattle, WA USA

Half and Half

2011-01-11T16:30:48+01:00

Taking an HSV-sorted colour blend, selecting random pixels and pulling ones with a higher red component towards the centre of the image

What a Horrible Carpet

2011-01-11T11:26:14+01:00

Gloriously tasteless piece based on a Sierpinski carpet

Boogie

2011-01-07T16:07:46+01:00

Remix of Thingy, inspired by De Stijl.

Orion Nebula

2010-11-22T00:55:24+01:00

This image demonstrates that forcing an image to use every color may be useful. The conversion has given prominence to some features and this may have a use in imaging. The image takes less than two minutes to convert. The conversion process is still in development as I have been unable to determine the best method of forcing clumped 3D data into a uniform 3D space. Any assistance would be appreciated.

glenn@thorpies.com

Recursive 64 by 64

2010-11-19T16:14:31+01:00

This image consists of 4,096 64 by 64 pixel images. There are eleven images which are replicated many times. Each of these small images is initially comprised of the same 4,096 colored pixels. These 4,096 colors are an evenly spaced subset of the rgb colorspace. There are 16 values, or a spacing of 17, for each r,g & b component.

Each of these initial images has slight adjustments made when they are imported into the large image. These slight changes result in every pixel becoming uniquely colored. It is my intent to have 4,096 unique starting images. At the moment I only have 11 images. If anyone is interested in contributing a face for the final please contact at glenn@thorpies.com.

Sinus waves

2010-07-31T03:17:25+02:00

zig-zag

2010-07-31T02:36:22+02:00

Crystal Lizard

2010-04-23T17:45:53+02:00

The 120 rotation matrix can be approximated by the following rational matrix:

-1/2, -7/8
 6/7, -1/2

which differs from the real matrix only by 1% error. The three kinds of lizards are mapped to each other by this matrix. The tiling period of these lizards is (512, 512*7/8), and each lizard has 64*64*64 *7/8 colors, taken from 64x64x64 cube in the RGB space, excluding colors whose RGB value is all even. The lizard template shape is further divided into polygons by Voronoi decomposition.

Then distribution of 64x64x64x7/8 colors in the template is optimized to minimize neighbor pixel color L2 distances. Here pairs of pixels which belong to different polygons have opposite contribution to the total score and they try to be different colors. We now have 4x4x4 lizards of different colors (4=256/64). 4x4x4 color box can be grouped into 4 hexagons of 37 pieces + 19 pieces + 7 pieces + 1 piece.

Only 37 pieces hexagons are used to draw lizards. The colors in the eyes and back stripes are changed by R-G-B permutation. The rest lizard is decomposed into small hexagons of 16x16x16x7/8 colors and periodicity (64, 64x7/8).

They are sorted by their hue and placed according to it. The larger the hue is, the further it is placed from the center. Finally, the 128x128x128 colors which are excluded from the lizards and hexagons are distributed in the interim region according to their hue.

Escher Reptiles

2010-04-06T20:19:34+02:00

Famous Escher's tiling. Large lizards consists of 512^2 pixels and small lizards has 64^2.

Since the screen does not have 3-fold symmetry, three kinds of pieces are not similar.

64 colors are grouped into 4 gray colors and 20 triplets of R-G-B permutation.

The 4 gray lizards do not fit into anywhere, so they are mashed into smaller pieces and filled the margin.

Tetris

2010-04-01T12:41:23+02:00

Each piece has 16x16x16 colors in RGB space and 32x32x4 pixels on screen.

Choose block and orientation randomly.
First, try to place it at the lowest place. Do not allow overhang. If not possible, try random place.
At later stages, regard left-side wall as a bottom line and disallow overhang in this view too.

Big flower

2010-03-29T21:09:35+02:00

Same as flowers, with only one color seed.

Flowers

2010-03-29T21:09:17+02:00

Played with DLA code and unexpectedly got this.

DLA

2010-03-29T15:40:54+02:00

DLA (Diffusion-Limited Aggregation) is a growth model of bacterial colonies and tree-like crystals. For details, see http://en.wikipedia.org/wiki/Diffusion-limited_aggregation

Rules are modified a bit here.

0a: Divide color-space into two sets, in the present case high-saturation colors C1 for solids and low saturation C2 for background.

0b: Place solid seeds randomly, colors chosen from C1.

1: Starting from random position, do random walk until the walker reaches any neighbor site of solid atom.

2: The walker is absorbed onto the solid. Choose a color which is close to the neighbor solid atom, from unused color in C1. Goto 1.

3: If no color is available, cancel absorption and continue random walk.

4: If no color is available for any absorption site, terminate the simulation.

5: Fill unoccupied pixels with unused colors.

Source code: http://d.hatena.ne.jp/ita/00010414/p1

Mosaic

2010-03-24T15:50:03+01:00

Simulated annealing of neighbor pixel distances, using bitwise distance d(x,y)= MSB(x XOR y), where MSB stands for Most Significant Bit. The top-level, bit-7 cluster is imported from smaller 512x512 size simulation and expanded, then annealed just long enough to round off 8x8 square jaggies. Otherwise it would have taken years to form the cluster if I started from completely random configuration. Anyway formation of lower level clusters took almost a week on my PC.

Mona Lisa Overdrive

2010-03-23T13:21:12+01:00

Simulated annealing process of 512x512, 6x3 bit Mona Lisa using different definition of "Energy", where Energy = A*(squared neighbor pixel color differences) + B*(squared color differences to the target). I used "l2-norm", namely (Ri-Rj)^2 + (Gi-Gj)^2 + (Bi-Bj)^2. The ratio of coefficients A:B is, from top to bottom, 256:1, 64:1, 16:1, 4:1, 1:1, 1:4, 1:16, 1:64. Images from right to left shows equilibrium state at higher to lower temperature. The annealing process consists of standard Metropolis update as follows:

Choose a pixel i
Choose another pixel j, which modestly differs in color with i. To do this, one must maintain color-to-position pointers.
Calculate energy change by swapping i and j (=dE).
If dE<0, accept the change. Otherwise accept it with a probability exp(-dE/T) where T is a temperature.

Repeating this process drives the system to a Boltzmann distribution in which a state of energy E appears with probability proportional to exp(-E/T). Starting from large T and gradually decreasing T drives the system to lower energy state.

quicksort

2010-03-21T18:54:05+01:00

Metamorphosis of Narcissus

2010-03-20T21:18:11+01:00

The same algorithm as http://allrgb.com/barcelona , except this one uses error diffusion to trick the eye into seeing the right colours.

See http://www.thelowlyprogrammer.com/2010/03/visualizing-rgb-take-two-update.html for details.

Lake Sunset

2010-03-17T00:04:06+01:00

Used a basic algorithm that tries to use pixels from a given image, and tweaks them up to a certain point to avoid re-using colors. If the color will be too different from the original, it gives up and pulls it from a linear list of remaining colors.

Reddtrip

2010-02-25T18:13:30+01:00

acid pants

Museum of Color

2010-02-25T17:28:50+01:00

Used simulated annealing to minimize: (neighbor pixel color distance)^2 + Const (color distance to the target)^2 where I used Const = 4. The method works best for Seurat portrait for obvious reason, and worst for Rubens (my apology for desecrating his work).

Some preliminary article on the method I used is here: http://d.hatena.ne.jp/ita/20100222/p1

All original images are from wikimedia commons. From left to right, top to bottom: Gogh, Gauguin, Miro, Monet, Seurat, Cezanne, Hokusai, Leonardo da Vinci, Mucha, Chagall, Manet, Renoir, Rubens, Dali, Millet, Picasso, Seurat.

Mona-Lisa-YCrBr

2010-02-25T16:37:19+01:00

I used similar software that I previously used in the High Quality Wedding Render

This one took about 4 days to render (30 iterations of optimal random permutations of 32 pixels).

The color distance here was calculated by YCrBr with a 4X multiplier on Y (luminance).

The colors are too hot in my opinion. The algorithm is ignorant of the perceptual importance of neighboring pixels and what a selection of pixels really gives to the perception of an image. Ignorant of information etc.

* Fine Details are handled well
* Colors are off
* Colors are too hot

Software: http://churchturing.org/y/24bit-randomschedule-ycbcr

Original Mona Lisa from Wikipedia that was cropped: http://churchturing.org/y/Mona_Lisa-4096.png

I ran: permuter Mona-Lisa.jpg 32

Stripe Aurora

2010-02-21T20:57:17+01:00

I'm new to programming, decided to try this out in Java without using anything but the API. My first attempt didn't have all 16.8 million colors, but this one does. Enjoy.

High quality render of wedding photos

2010-02-20T17:34:35+01:00

Please zoom in and look at the fine details.

This image was generated from the same image used in Noise Wedding. The main improvement is instead of rearranging colours in 128 continuous pixel blocks. Colours here are randomly scheduled (shuffled) and then blocks of these shuffled Colours are taken and then swapped. We used a block-size of 32. This image took probably 60 hours because we ran iterated over it 30 times.

Step 1: make a random image of all Colours

Step 2: make a random pixel schedule

Step 4: for each N (32) pixels of the schedule

Step 4.1: use Munrkes/Hungarian method to find the best permutation of these 32 randomly placed noise pixels from the random image that has the minimum the colour distance to the input image. Use YUV colour distance and use a 4X multiplier on the Y difference.

Step 4.2: Once we have the minimum permutation, swap/permute those pixels as per the calculation

Step 5: optionally take this output image and input back as the "random image" in step 2

So what's important here? We use YUV colour distance instead of RGB colour distance. I did tests and I found RGB colour distance resulted in "brighter" results but the colours were off and it make people in the photos look like clowns. YUV focused on perceptual qualities, such as luminance, and therefore is better for an image that estimates another one. The main difference between his picture and the original photo is the tints in this photo are off, and her arm in the top left is not actually green.

Another detail I want you to be aware of, zoom in, view this image 4096x4096. Go look at her dress, go look at the woodwork on the wall. Go look at the dorky little birdy in the cage. See how the detail at the pixel level is very clean and clear, there is not a lot of extraneous noise. The error has not been shuffled down to this detail. This method has preserved fine grained details and the picture looks like the original regardless of zoom level.

* Took ~60 hrs

* High quality render (details are in tact)

* YUV colour distance used (I am experimenting with YCrBr colour distance and not finding much improved performance)

* 32 pixels were randomly chosen optimally permutated at the same time, compared using YUV colour distance

Q: what if you used 2 pixel swapping?
A: If you 2 pixel swapping and repeat 30 times the results are quite acceptable but there is a lot of noise in the details stiff, but it is often good enough (also it runs in less than 30 minutes if you do 2 pixel swapping). 8 pixel permutations are much higher quality.

Q: Why 32 pixel blocks?
A: Because 128 pixel blocks take 45 hrs per image and 8 pixel blocks take less 20 minutes. Remember I repeated this 30 times. 32 pixel blocks take over an hour per iteration. Munrkes is O(N^3)

Source code: http://churchturing.org/y/24bit-randomschedule/

Git: git clone http://churchturing.org/y/24bit-randomschedule/.git/

Munkres: http://en.wikipedia.org/wiki/Hungarian_algorithm

Barcelona

2010-02-20T15:12:37+01:00

My second algorithm for generating allRGB images. Iterates through the pixels randomly and looks for the "closest" unused colour to assign to each. http://www.thelowlyprogrammer.com/2010/02/visualizing-rgb-take-two.html

Find That Color

2010-02-18T14:29:03+01:00

Similar as Recursive I and Recursive II, with color names shown in inverted color text. The names are from NetPBM's rgb.txt.

Convert This Image to Grayscale

2010-02-18T14:04:42+01:00

This image is a fairly classic, even highly compressible (537 kB), fairly efficient, RGB to Grayscale implementation graphical representation. Some graphics programs will convert this image into a perfect black to white gradient. Superior sRGB-based(or similarly gamma corrected CS) programs should not(Photoshop, for instance).

Irfanview uses the same method. Test it out for yourself.

Formula: Gray = (77 * Red + 150 * Green + 28 * Blue) / 255

Mona in Color

2010-02-18T10:15:10+01:00

Used weighted RGB sorting(similar to a grayscale conversion, but instead of green given more significance, red was)..Sorting is done by a mergeSort, which takes around one minute to process an image on my computer.

Recursive II

2010-02-17T09:54:25+01:00

Find a space-filling, 8-pixel shape (octlith).
Cluster 8 of them in a similar way as to make the octlith.
Repeat the process.

The image file is fairly small (~1 Mb)

Recursive i

2010-02-17T09:41:43+01:00

Find a space-filling, 8-pixel shape (octlith).
Cluster 8 of them in a similar way as to make the octlith.
Repeat the process.

The image file is fairly small (~1 Mb)

Order from Chaos II

2010-02-16T11:13:24+01:00

Same as 42, with more crude optimization. the system fails to reach global minimum and breaks up into smaller patterns which are locally minimum.

Noise Wedding

2010-02-15T21:52:41+01:00

This image was generated by combining wedding photos with random noise. Per each 128 block of noise pixels, those noise pixels were optimally rearranged (according to YUV Euclidean color distance) using the Hungarian/Munkres algorithm. Munkres is very slow, O(N^3), so I had to do it in small blocks. Future work will be scheduling the blocks differently, maybe rearranging pixels in a random order instead of linear 128 pixel blocks. This picture took 40 hrs to create in OCaml. I attempted a different color schedule (Hamiltonian path and perfect permutation but the results were very similar).

Other images and source code is found here: http://churchturing.org//y/valentines/

Munkres: http://en.wikipedia.org/wiki/Hungarian_algorithm

Random Similarity

2010-02-15T13:16:25+01:00

CROP

2010-02-14T21:55:42+01:00

Just put this algorithm together in a couple of minutes.

It's not as good as I expected but it'll get better.

Planet Earth RGB

2010-02-13T20:52:19+01:00

My first try using Python & simulated annealing.

Old Laser Printer

2010-02-13T14:08:40+01:00

The bad vertical lines on the old laser printers ... in color.

Colman's Mustard 2

2010-02-12T22:36:08+01:00

A comparison with the other Colman image.

reddit.com

2010-02-12T16:24:40+01:00

reddit ftw!

Circles

2010-02-12T12:13:51+01:00

Order from Chaos

2010-02-12T12:06:51+01:00

Used simulated annealing to make the image as smooth as possible. You can see the generation process in which the pattern emerges from seething chaos:

The quick brown fox...

2010-02-12T10:45:59+01:00

flowers

2010-02-12T09:44:02+01:00

C# program that randomly swapps pixels 'n stuff

change

2010-02-12T08:18:44+01:00

I wrote a little C# program to do hill climbing against a reference image.

Mona Lisa Groovy

2010-02-11T03:27:00+01:00

Hue-ordered sort

256x256x256

2010-02-10T23:04:08+01:00

generated with a simple python script

Grid One

2010-02-10T09:19:08+01:00

You mentioned that "the obvious way" was a 16x16 grid, but to me the obvious way was to loop through red, green, and blue, setting the pixels as I went.

Written in PHP.

http://www.puremango.co.uk/2010/02/allrgb-entry-php-image-manipulation/

Lenna

2010-02-10T01:09:50+01:00

A version of the classic test image of Lenna (http://en.wikipedia.org/wiki/Lenna).

Mandelbrot

2010-02-02T05:40:05+01:00

An image of the mandelbrot set, transformed by sorting pixels by colour on the hilbert curve then colouring them from it. http://www.thelowlyprogrammer.com/2010/01/visualizing-rgb.html

A Hilbert-curve traversal of the RGB colour cube, projected onto a Hilbert curve traversal of the plane

2010-01-27T04:43:25+01:00

For more info on the construction of this curve, see: http://corte.si/posts/code/hilbert/portrait/index.html

frames

2009-12-09T00:06:09+01:00

apparently unicolored lines arranged in a frame pattern. this is another application of the hilbert curve, this time a 3d hilbert curve for traversing the rgb space (and plotting the colors onto a spiral in xy space)

In Technicolor

2009-11-22T20:50:34+01:00

Fractal

2009-09-17T03:42:00+02:00

distributing the colors along the hilbert curve

Space Shuttle

2009-06-26T19:14:51+02:00

just my version of "I can turn a photo into an allrgb entry"... took 3 days of computation

Are they parallel?

2009-05-22T17:52:47+02:00

Variation of http://allrgb.com/thingy with mirrored blocks and sinus offset for the x coordinate

chessboard

2009-05-16T22:08:07+02:00

divided the colors in dark and light, scrambled each subset and arranged in chessboard pattern. using c++ & psp7

Naamloos-1

2009-04-09T13:16:06+02:00

Used techniques: PHP, MySQL.

Pinstripe

2009-03-18T19:03:11+01:00

A lot like Silky, but with a pattern of light blue stripes.

Scrambled

2009-03-18T13:37:48+01:00

allHSV

2009-02-08T21:00:51+01:00

same as http://allrgb.com/tvlines, but used HSV rather than RGB as sorting criteria

Chilly Run

2009-01-31T19:22:47+01:00

I took this picture early one frosty morning just before my running clubs cross country run. You can see the original picture here http://www.flickr.com/photos/31300185@N06/3095354838/in/set-72157610953101450/

This is my 3rd algorithm to convert pictures into allRGB entries. If anyone has any suggestions, comments or links to pictures they'd like to see converted please drop me an email at allrgb@death9.co.uk

Black and White

2009-01-12T20:20:52+01:00

Black, white, and everything in between: All 24 bit RGB colors, ordered by brightness.

VibrantMustard

2009-01-12T17:21:11+01:00

Crossroad

2009-01-10T17:36:59+01:00

Color Corners

2009-01-09T21:36:50+01:00

Four colors appear to be prominent in this picture; blue, lime, magenta, and yellow. This effect is especially strong in smaller previews/ seen from from a distance.

Suave

2009-01-07T23:35:28+01:00

No hard lines in this one.

Silky

2009-01-07T03:24:16+01:00

After the “most colorful” entry, now the “least colorful”. Of course, this only concerns the perception of colorfulness, as both entries — and all the other entries for that matter — use exactly the same colors (all 24 bit RGB colors).

Peace

2008-12-16T19:53:30+01:00

Simply sorted all the Colors by hue. Results in some nice clear colors =)

Rhomb Patterns

2008-11-21T15:46:34+01:00

In contrast to my previous image, which was 200 times bigger, I tried to use as few bytes as possible while still showing a nice and unique pattern. Created with C# and IrfanView.

Flowers

2008-11-20T19:36:51+01:00

An image almost completely made of Moiré patterns. The compression ratio is quite bad (35 MB) because Deflate is not made for such cases. Created with C# and IrfanView.

Is it random?

2008-11-19T15:53:15+01:00

M.I

2008-10-12T19:54:07+02:00

A picture of my eye. The title has various meanings. This one might take some time to load as it is about 18 MB. Created with Photoshop and Processing.

Marilyn

2008-10-12T17:22:40+02:00

A tribute to Andy Warhol, for Wendy.

deIdee

2008-10-12T13:34:34+02:00

The logo of my design company, deIdee, 65,793 times over.

DotMatrix

2008-10-12T12:47:16+02:00

This one might take some time to load as its file size is a lot larger than that of the other images (about 21.5 MB). Created with Processing.

Bling

2008-10-07T10:28:29+02:00

This is the seventh one I did, and brings us back to the basics: No (pseudo) randomness, and nothing figurative; just plain old logic. However, it is of course possible to see different kind of things in this. (Think of the blocks in Mario Brothers or the floor in Saturday Night Fever.)

ACJ’s

2008-10-03T22:08:33+02:00

This is the sixth one I did, but the first one that is not completely abstract: The placement of the reds is based on the shortcut icon of my personal website; ACJ’s.

Semi

2008-10-03T12:14:35+02:00

This is the fifth one I did, and the first that is not completely logically structured: The placement of the reds uses an algorithm of (pseudo) randomness. This, combined with the woven like pattern of green and blue give it a semi Scottish pattern.

Radiator

2008-06-22T13:06:22+02:00

This is the fourth one I did. The reds appear to be radiating through the image as if the greens and blues are glowing.

Tv-lines

2008-06-22T13:06:15+02:00

This is the first one I did outside the scope of my work at the Royal Academy of Art. The results remind me of tv-lines (or rather tv-line filters for popular graphics software). Hence the name.

Spiral

2008-06-22T13:06:00+02:00

This is the second one I did, still working up to my final project at the Royal Academy of Art. If you happen to have anaglyph filters laying around, try them on and focus on the center of this image for rather trippy results.

Thingy

2008-06-22T01:10:08+02:00

Working up to my final project at the Royal Academy of Art, I did a series of experiments of creating visuals with code (programming). One of said experiments was to create an image that included exactly one pixel for every possible rgb value. This one right here was the first. It was also the most obvious, and therefor been done many times before (which triggered me to find other ways, and essentially started project allRGB).