Stampa un modello di prova a 256 colori nel terminale

Come posso stampare un modello di prova a 256 colori nel mio terminale?

Voglio verificare che il mio terminale supporti correttamente 256 colori.

Modello di prova a 256 colori

Per ottenere l'immagine qui sotto, utilizzare:

curl -s https://gist.githubusercontent.com/HaleTom/89ffe32783f89f403bba96bd7bcd1263/raw/ | bash

Il succo bash/ zshcodice è shellcheckpulito, e supporta anche "Guarda mamma, senza sottoprocessi!".

In alternativa, per una bashrapida:

for i in {0..255} ; do
    printf "\x1b[48;5;%sm%3d\e[0m " "$i" "$i"
    if (( i == 15 )) || (( i > 15 )) && (( (i-15) % 6 == 0 )); then
        printf "\n";
    fi
done

Per eccesso totale, il nonno del lotto è terminal-colors, uno script di 572 righe con più formati di output .

È anche possibile stampare un modello di prova a colori reali (24 bit) .

Ho trovato una bella sceneggiatura Python per quella su GitHub scritta da Justin Abrahms che stampa anche i codici esadecimali dei colori.

Scarica lo script nella directory di lavoro corrente

wget https://gist.githubusercontent.com/justinabrahms/1047767/raw/a79218b6ca8c1c04856968d2d202510a4f7ec215/colortest.py

dategli il permesso di esecuzione

chmod +x colortest.py

Eseguirlo:

./colortest.py

Ecco lo script per intero in caso di link-rot:

#!/usr/bin/env python
# Ported to Python from http://www.vim.org/scripts/script.php?script_id=1349

print "Color indexes should be drawn in bold text of the same color."
print

colored = [0] + [0x5f + 40 * n for n in range(0, 5)]
colored_palette = [
    "%02x/%02x/%02x" % (r, g, b) 
    for r in colored
    for g in colored
    for b in colored
]

grayscale = [0x08 + 10 * n for n in range(0, 24)]
grayscale_palette = [
    "%02x/%02x/%02x" % (a, a, a)
    for a in grayscale 
]

normal = "\033[38;5;%sm" 
bold = "\033[1;38;5;%sm"
reset = "\033[0m"

for (i, color) in enumerate(colored_palette + grayscale_palette, 16):
    index = (bold + "%4s" + reset) % (i, str(i) + ':')
    hex   = (normal + "%s" + reset) % (i, color)
    newline = '\n' if i % 6 == 3 else ''
    print index, hex, newline, 

Anche se non del tutto un "modello di prova", ho xterm-color-chooser :

Ancora un altro script, scritto da me, si trova nel repository VTE: https://git.gnome.org/browse/vte/plain/perf/256test.sh?h=vte-0-38 .

Richiede una finestra di 120 o più colonne, ma organizza i colori del cubo 6x6x6 in modo piacevole e compatto. Le prime cifre degli indici sono spogliate per compattezza, puoi facilmente capirle. Le barre verticali offrono la possibilità di esaminare l'esatto RGB del colore di primo piano senza dare il via all'antialiasing (come accade alle cifre).

La parte superiore dell'output (non mostrato nello screenshot seguente) dimostra la follia che gira intorno all'ambiguità audace contro brillante, ovvero che la sequenza di escape di audacia combinata con una delle sequenze di escape di 8 colori legacy per il primo piano passa anche a il brillante colore della controparte, mentre con le sequenze di escape del nuovo stile (con capacità di 256 colori) non è più così, nemmeno per i primi 8 colori. Almeno è così che si comportano xterm e VTE (Terminale GNOME ecc.).

Questa schermata mostra circa la metà dell'output:

Forse superfluo, ma ho scritto una versione che stampa i 256 colori usando lo sfondo con il rilevamento automatico della larghezza della shell in modo che i colori siano più facilmente visibili.

https://gist.github.com/WoLpH/8b6f697ecc06318004728b8c0127d9b3

#!/usr/bin/env python
from __future__ import print_function

import os
import shutil
import subprocess


def get_width(default=80):
    '''Attempt to detect console width and default to 80'''
    try:
        columns, rows = shutil.get_terminal_size()
    except AttributeError:
        try:
            _, columns = subprocess.check_output(['stty', 'size']).split()
        except OSError:
            columns = os.environ.get('COLUMNS', default)

    columns = int(columns) - 77
    # Since we have 6 columns with 1 space on each side, we can increment the
    # size for every 12 extra columns
    return max(0, columns / 12)


# Loosely based on https://gist.github.com/justinabrahms/1047767
colored = [0] + list(range(95, 256, 40))
colored_palette = [
    (r, g, b)
    for r in colored
    for g in colored
    for b in colored
]


grayscale_palette = [(g, g, g) for g in range(8, 240, 10)]


esc = '\033['
# Reset all colors sequence
reset = esc + '0m'
# Regular color
normal = esc + '38;5;{i}m'
# Bold color
bold = esc + '1;' + normal
# Background color
background = esc + '48;5;{i}m'

pattern = (
    '{normal}{background}{padding:^{width}}{i:^3d} '  # pad the background
    '{r:02X}/{g:02X}/{b:02X}'  # show the hex rgb code
    '{padding:^{width}}'  # pad the background on the other side
    '{reset}'  # reset again
)

base_context = dict(reset=reset, padding='', width=get_width())

for i, (r, g, b) in enumerate(colored_palette + grayscale_palette, 16):
    context = dict(i=i, r=r, g=g, b=b, color=r + g + b, **base_context)
    context.update(bold=bold.format(**context))
    context.update(background=background.format(**context))

    # Change text color from black to white when it might become unreadable
    if max(r, g, b) > 0xCC:
        context.update(normal=normal.format(i=0))
    else:
        context.update(normal=normal.format(i=255))

    print(pattern.format(**context), end='')

    # Print newlines when needed
    if i % 6 == 3:
        print()
    else:
        print(' ', end='')

Una fodera

colore di sfondo

for i in {0..255}; do printf '\e[48;5;%dm%3d ' $i $i; (((i+3) % 18)) || printf '\e[0m\n'; done

colore di primo piano

for i in {0..255}; do printf '\e[38;5;%dm%3d ' $i $i; (((i+3) % 18)) || printf '\e[0m\n'; done