Un renderere terminale a base di un glyfo- basato sulla formaM SK1algoritmi di corrispondenza. Sostenisce le immagini ,GIF animatiMST4 videoM ST5 riproduzioni su YouTubeMst6 e sottotitoli in diretta con diversi modi di rendere, tra cui il Braille per il maggior dettaglioMS ST7
L'obiettivo non è l'accuratezza dei pixel; ma la visibilità sotto limiti di larghezza di banda estrema.
Questo è uno dei miei piccoli progetti che costruisco come un esercizio di tempo limitato.
Questo progetto in particolare è iniziato quando ho incontrato Alex Harri's excellent article on ASCII rendering. Il suo approccio alla forma - la combinazione piuttosto che la semplice mappatura della luminosità era affascinante, e ho pensato " potevo costruirlo in CM SK4 Quello che iniziava come semplice visualizzatore di immagini ASCII è diventato un sistema grafico terminale con diversi modi di renderingMST5 supporto videoM ST6 e persino una strata di integrazione AIM st7
Il codice sorgente completo è disponibile su GitHub: https://githubMSC1com/scottgalM SK3mostlylucidMスク4consoleimage
Download the latest release: Rilasci di GitHub
Pacchetti NuGet:
mostlylucid.consoleimage - Core rendering librarymostlylucid.consoleimage.video - Support video (FFmpeg)mostlylucid.consoleimage.transcription Generazione di sottotitoli +mostlylucid.consoleimage.player - riproduzione del documentomostlylucid.consoleimage.player.spectre - Spectre.I renderabili di riproduzione della consolemostlylucid.consoleimage.spectre - Spectre.Integrazione con la consoleConsoleImage è un singolo CLI che trasforma i media in glyfi-video terminale guidato. il punto non sono precisi pixelsM SK2 ma l'affidabilità sotto restrizioni brutali .
Il modo più facile per iniziare è scaricare la versione più recente del binario. Rilasci di GitHub E dobbiamo assicurarci che le cose siano in ordine. consoleimage è sul vostro computer. PATH.
consoleimage photo.jpg
consoleimage "https://youtu.be/dQw4w9WgXcQ" --subs whisper
ConsoleImage è cresciuto silenziosamente in un intero lettore multimediale terminale. Versione 4.0 aggiunisce il playback su YouTubeM SK2 auto - dipendenze scaricateMSC4 e sottotitoli artificiali viventi alimentati da WhisperMST5 tutti copricati nello stesso MST6un comando e funziona soloM ST7 flussoM st8
Le dipendenze vengono trascinate durante il primo uso e archiviate localmente, così le nuove caratteristiche funzionano senza installazioni manuali:
| Componente | ||
|---|---|---|
FFmpeg ~/.local/share/consoleimage/ffmpeg/ |
||
| ytM SK1dlp | Prima URL YouTube SSK3 ~/.local/share/consoleimage/ytdlp/ |
|
| Whisper Runtime | Primo --subs whisper |
~/.local/share/consoleimage/whisper/runtimes/ |
| Whisper Models | First transcription | ~/.local/share/consoleimage/whisper/ |
Su Windows, i cache vivono sotto %LOCALAPPDATA%\consoleimage\.
Sul macOS, i cache vivono sotto l'utente-local app data folder M SK2 tipicamente ~/Library/Application Support/consoleimage/).
Usare -y / --yes a auto-confirmare tutti i download.
I URL di YouTube suonano direttamente nel terminale tramite yt-dlp, che passa attraverso la stessa pipeline di render come i file localiM SK2 Questo significa che gli stessi modi, larghezze, e i format di output si applicano anche se state guardando in diretta o sto conservando un clipM SK2 Se avete già avere un yt personalizzato-dlp install, ConsoleImage può puntare su di essoM SK2
I sottotitoli provengono da tre fonti: file esistenti, sottotitole su YouTubeM SK2 o traduzione dal vivo di Whisper . Whissper funziona in
il background in 15-secondi chunks, rimane prima del playbackM SK2 e dei caci .vtt file, quindi le riprese sono instantanee. Soporta
Numeri di modelli multipli, selezione linguistica, e punti di fine ospitati in modo che si possa scambiare velocità per precisione o spegnere il lavoro
Transcript-Suspende anche solo il risultato, che trasforma ConsoleImage in un generatore di sottotitoli che può alimentare altri strumenti senza rendere video.
La puntate verso un folder e diventa una slideshow di immagini con controlli per la tastiera, shuffle opzionale, e manuale o programmato. anticipo.
Quello che cominciò come progetto weekend per implementare l'algoritmo di Alex Harri è diventato qualcosa di più ambizioso.
L'incrocio dello spettro era reale, ma ogni aggiunta si sentiva naturale e utile. Adesso gestisce immaginiM SK2 GIFs , videoMSC4 e fornisce persino un server MCP per l'integrazione degli strumenti AIMST5
ConsoleImage offre tre modi distinti per rendere le immagini nel terminale, ciascuno con il suo commercioM SK1offs:
flowchart LR
A[Source Image] --> B{Choose Mode}
B --> C[ASCII]
B --> D[ColorBlocks]
B --> E[Braille]
C --> F[Shape-matched characters]
D --> G[Unicode half-blocks]
E --> H[2×4 dot patterns]
style A stroke:#4a9eff
style B stroke:#ff6600
style C stroke:#00aa00
style D stroke:#00aa00
style E stroke:#00aa00
| Modo | Commando | risoluzione | La migliore per | ||||
|---|---|---|---|---|---|---|---|
| Braille | consoleimage photo.jpg |
8× pixels per ogni cellula DEFAULT - dettagli maximi | |||||
| ASCII | consoleimage photo.jpg -a |
||||||
| ColorBlocks | consoleimage photo.jpg -b |
2× verticale ( metà - blocchi S) | foto M, alta fideltà R |
Il braille è il predefinito. Usare -a per ASCII o -b per ColorBlocks.
Alcuni terminali supportano protocolli grafici inline (iTerm2, KittyM SK2 SixelMSC3 ConsoleImage può indirizzare questi modi per: pixel-rendere accurato mantenendo la stessa tubatura e gli strumenti.
Ecco lo stesso GIF animato riprodotto in ogni modo:
| ASCII | Braille MSC2 Braile MSC3MonoMSc4 ESC5 ColorBlocks ESC6 | |||||
|---|---|---|---|---|---|---|
 |
|
 |
 |
|||
| FormeM SK1 caratteri corrispondenti | 2×4 schemi di puntine | Compacto |
Il risultato ASCII mostra la forma-la corrispondenza al lavoro - l'uso dei bordi diagonali / e \Usazione delle curve , ( e ), e diverse densità usano caratteri come @, #, *, e .. La versione in braille monochrome è più piccola delle modalità di colore, mantenendo la risoluzione completa dei punti.
L'avanza della risoluzione è chiara con la classica palla di lancio Amiga - un'animazione che richiede curve e diagonali pulite:
| Braille (MonochromeM SK2 | Braile SSK4Color) | |
|---|---|---|
 |
 |
|
| 8× risoluzione, niente colore | \8× risoluzione |
Entrambi usano la stessa griglia di punti 2×4 pixels per ogni cellula di caratteri ). La versione monochrome elimina completamente i codici di colore ANSI
Per riproduzioni rapide, Session SSH, o larghezza di bandaM SK2ambiente limitatiMSC3 braille monochromo MST4--mono) abbassa completamente la colorazioneM SK1
consoleimage animation.gif --mono -w 120
I risultati sono: 3-5x più piccolo rispetto ai modi di colore mantenendo la risoluzione completa. Quella animazione da boingball sopra? La versione monochrome è M SK2 KB contro 863 KB per il braille coloratoMSC4 Per il testoMST5Contenente pesante o artistica in lineaM ST6 il monochromo spesso assomiglia migliore. Perché non c'è alcun rumore di colore che compete con l'informazione sulla forma.
L'arte tradizionale ASCII usa la mappatura della luminosità - pixel più scuri ricevono caratteri più densi come @ o #, pixel più leggeri diventano sparsi come questi. . o . Funziona, ma ignora il vero La forma di caratteri.
Alex Harri' l'approccio è più intelligente: analizza la forma visiva di ogni personaggio , poi corrisponde le regioni dell'immagine ai personaggi con forme similiM SK3 Una linea diagonale dovrebbe mappare / o \, non solo qualsiasi carattere di luminosità simileM SK1
Una volta trattato ogni personaggio come un minuscolo 2Shape D,Il rendering diventa il più vicinoM SK2Succesione vicina in uno spazio bassaMSC3dimensionale "Shapes Space
Ogni carattere viene analizzato usando un 6-grid di campionamento a punti in un modello 3×2 incerto:
[0] [1] [2] ← Top row (staggered vertically)
[3] [4] [5] ← Bottom row
I cerchi di sinistra sono abbassati e i cerchi destri sono alzati per minimizzare le differenze evitando l'incrocio. Ogni cerchio di campione misura M SK1incubo di inchiostro" a quella posizioneMSC3 creando un vectore di forma 6-dimensionale
Qui' è l'output ASCII di nuovo come riferimento mentre parliamo della griglia di campione:
// Staggered sampling positions (3x2 grid as per Harri's article)
private static readonly (float X, float Y)[] InternalSamplingPositions =
[
(0.17f, 0.30f), // Top-left (lowered)
(0.50f, 0.25f), // Top-center
(0.83f, 0.20f), // Top-right (raised)
(0.17f, 0.80f), // Bottom-left (lowered)
(0.50f, 0.75f), // Bottom-center
(0.83f, 0.70f) // Bottom-right (raised)
];
Quando il renderere inizialisca, renderà ogni carattere ASCII ad una piccola immagine e mostra le regioni 6
private void GenerateVectors(string characterSet, string? fontFamily, int cellSize)
{
var font = GetFont(fontFamily, cellSize);
foreach (var c in characterSet.Distinct())
{
var vector = RenderCharacterVector(c, font, cellSize);
_vectors[c] = vector;
}
// Normalise vectors for comparable magnitudes
NormalizeVectors();
}
Il risultato è una tavola di ricerca che mappa ogni carattere alla sua firma di forma.
Per trovare il miglior carattere per ogni cellula di un'immagine bisogna cercare 6-spazio dimensionale. Una ricerca lineare naiva sarebbe lentaM SK2 quindi usiamo K-D per la ricerca veloce più vicina-neighbour lookups:
flowchart TD
A[Image Cell] --> B[Sample 6 regions]
B --> C[Create shape vector]
C --> D[K-D tree lookup]
D --> E[Nearest character match]
style A stroke:#4a9eff
style C stroke:#ff6600
style D stroke:#00aa00
style E stroke:#00aa00
L'informazione figura nella parte dispositiva. K-D fornisce scoperte O(log n) invece di O (nM SK3 e i risultati sono archiviati usando vettori quantificati per scoperte ripetute ancora più veloci.
Il corrispondenzamento della forma nera può sembrare piatto. L'algoritmo applica due tipi di accelerazione del contrasto:
Contrasti Globali - Funzione di potenza che abbassa i valori verso zero
value = (value / max)^power × max
Contrasto orientativo - 10 cerchi di campione esterni rilevano le bordure dove il contenuto incontra lo spazio vuoto:
// 10 external sampling positions for directional contrast
private static readonly (float X, float Y)[] ExternalSamplingPositions =
[
(0.17f, -0.10f), // Above top-left
(0.50f, -0.10f), // Above top-center
(0.83f, -0.10f), // Above top-right
(-0.15f, 0.30f), // Left of top-left
(1.15f, 0.20f), // Right of top-right
(-0.15f, 0.80f), // Left of bottom-left
(1.15f, 0.70f), // Right of bottom-right
(0.17f, 1.10f), // Below bottom-left
(0.50f, 1.10f), // Below bottom-center
(0.83f, 1.10f) // Below bottom-right
];
Il renderer contiene diversi trucchi di performance:
Vector128/Vector256/Vector512 per i calcoli di distanza.// Pre-computed sin/cos lookup tables (major performance optimisation)
private static readonly (float Cos, float Sin)[] InnerRingAngles = PrecomputeAngles(6, 0);
private static readonly (float Cos, float Sin)[] MiddleRingAngles = PrecomputeAngles(12, MathF.PI / 12);
private static readonly (float Cos, float Sin)[] OuterRingAngles = PrecomputeAngles(18, 0);
Il modo di braille è stato il più grande salto tecnico. L'ASCII tradizionale ti dà uno "pixelM SK2 per ogni cellula di caratteri . Unicode braille characters pack 8 pixels in ogni cellula, e ConsoleImage tratta quei punti come un temporale. il segnale, non solo una mappa di bit statica . Il risultato è un tipo di glyfo- livello MSC3super risoluzioneM SK4 dove il movimento e la stabilità del frammentoMST5~MST6 rendeno il dettaglio percepito significativamente più alto di quello che suggerirebbe la griglia puraMSST7
Character in braille (UM SK1 - U+28FFMSC4 codificano un modello di 8-dot in una griglia SSK6
┌─────┬─────┐
│ 1 │ 4 │ ← Row 0
├─────┼─────┤
│ 2 │ 5 │ ← Row 1
├─────┼─────┤
│ 3 │ 6 │ ← Row 2
├─────┼─────┤
│ 7 │ 8 │ ← Row 3
└─────┴─────┘
Col0 Col1
Ogni punto corrisponde a un bit:
// Dot bit positions in braille character
// Pattern: 1 4
// 2 5
// 3 6
// 7 8
// Listed in 2×4 scan order: 1,4,2,5,3,6,7,8.
private static readonly int[] DotBits = { 0x01, 0x08, 0x02, 0x10, 0x04, 0x20, 0x40, 0x80 };
Il codice di carattere è semplice. 0x2800 + (bit pattern). Una cellula di braille vuota è ⠀ (U+2800), un blocco completo è ⣿ (U+28FFM SK2
flowchart LR
A[Source Image] --> B[Resize to W×2, H×4]
B --> C[Grayscale conversion]
C --> D[Otsu threshold + temporal stabilisation]
D --> E[Atkinson dithering]
E --> F[Build braille codes]
F --> G[Hybrid colours + perceptual compensation]
G --> H[Terminal output]
style A stroke:#4a9eff
style D stroke:#ff6600
style E stroke:#ff6600
style G stroke:#00aa00
Dato che ogni cellula di braille codifica una griglia di punti 2×4 , il renderere opera su un'immagine interna più ampia e più alta delle dimensioni del carattere bersaglio.
La conversione in braille richiede decisioni binari - ogni punto è acceso o spento. Un limite fisso ( come MSC3 luminositàMSC4 non funziona per immagini che sono predominantemente luminose o scureM SK5
Il metodo Otsu's Trova il soffitto ottimale ottimizzando la variazione tra il primo e lo sfondo. L'algoritmo:
Questo si adatta automaticamente ad ogni immagine - le immagini oscure ricevono limiti bassi , le foto luminose ricevovano limiti alti BrailleRenderer source.)
In pratica, il limite naïvo di Otsu è insufficiente per l'animazione. Le strati di implementazione coerenza temporale M SK2l'isteresia : la hysteresia così che le decisioni su doti non ribaltano la fotogrammaMSC4la fotogrammA5la telegramma) e la compensazione percezionale sopra la fotogramma, questo è il motivo per cui il risultato rimane stabile in movimento piuttosto che sfrecciare tra i fotogrammiMNK8
La soglia binaria crea bordi forti. Dithering Diffusi l'errore di quantizzazione ai pixel vicini, creando l'illusione dei toni intermediiM SK1
Noi usiamo. La distorsione di Atkinson ( sviluppato da Bill Atkinson per l'originale Macintosh) invece della più comune Algorithmo Floyd-Steinberg:
X 1 1
1 1 1
1
(each "1" receives 1/8 of the error)
Perché Atkinson funziona meglio per il braille:
| Aspect | FloydM SK2Steinberg | Atkinson SSK4 | ||||
|---|---|---|---|---|---|---|
| L'errore è diffuso | 100% (16/16) | 4 | 5 | 6 | 7 | |
| Pattern di diffusione | 4 pixels S | \6\ pixels | ||||
| Resulto | Gradienti più morbidi | Constritto più alto S | ||||
| Perfetto per | Foto |
Atkinson discardò deliberatamente 25% dell'errore, producendo bordi più forti - critico per i piccoli modelli di puntiniM SK3
private static void ApplyAtkinsonDithering(Span<short> buffer, int width, int height, byte threshold)
{
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
int idx = y * width + x;
short oldPixel = buffer[idx];
byte newPixel = oldPixel > threshold ? (byte)255 : (byte)0;
buffer[idx] = newPixel;
short error = (short)(oldPixel - newPixel);
short diffuse = (short)(error / 8); // 1/8 of error
// Diffuse to 6 neighbours (only 6/8 = 75% of error)
if (x + 1 < width)
buffer[idx + 1] += diffuse;
if (x + 2 < width)
buffer[idx + 2] += diffuse;
if (y + 1 < height)
{
if (x > 0)
buffer[idx + width - 1] += diffuse;
buffer[idx + width] += diffuse;
if (x + 1 < width)
buffer[idx + width + 1] += diffuse;
}
if (y + 2 < height)
buffer[idx + width * 2] += diffuse;
}
}
}
I colori terminali rappresentano una sfida: possiamo solo stabilire una colore di primo piano. per carattere, ma il braille rappresenta 8 diversi pixel della fonte.
Con una mediazione di tutte le colori 8 pixel producono un aspetto "solarizzato" Colori - si mescolano in grigi marroneM SK4 InveceMSC5 noi Solo campioni di colori da pixel dove i punti sono illuminati.:
flowchart TD
A[2×4 Pixel Block] --> B{Which pixels are lit?}
B -->|Dots 1,4,7| C[Sample only those 3 pixels]
B -->|Dots 2,3,5,6,8| D[Sample only those 5 pixels]
C --> E[Average lit pixel colours]
D --> E
E --> F[Apply colour boost]
F --> G[Set as foreground colour]
style A stroke:#4a9eff
style B stroke:#ff6600
style E stroke:#00aa00
style F stroke:#00aa00
Questo assicura che il colore mostrato corrisponda a quello che l'utente vede veramente - i punti illuminati.
I caratteri di braille sono inerentemente sparsi - un carattere con solo 2-3 punti illuminati sembra sombrere rispetto a un blocco solidoM SK2 Senza compensazione, il risultato del braille appare obiettivamente " correttoMSC5 ma visivamente noiosoMNK6
Per ripristinare il cromo percepito piuttosto chesagerare la colore:
Innalzamenti predefiniti (tunabile):
// Apply gamma correction and boost saturation/brightness for braille
(r, g, b) = BoostBrailleColor(r, g, b, _options.Gamma);
Per un output di caratteri 100×50
| Modo | Pixel efficaci | ||||||
|---|---|---|---|---|---|---|---|
| ASCII | 100 | 3 | 4 | 5 | 6 | 7 | |
| ColorBlocks | 100 ≥× \100 | 5 | 6 | 7 | |||
| Braille | 200 \× | 200 |
Il Braille fornisce 8x la risoluzione di ASCII e 4x la risoluzione di blocchi di colore.
La migliore dimostrazione della risoluzione del braille' è con gradienti flessibili e dettagli finissimiM SK1 Questa fotografia del paesaggio mostra come il braille cattura sottili variazioni tonali che si perdono in ASCII:
A quel punto mi resi conto che non stavo più guardando l'arte ASCII "ASCII " SSK3 era un'immagine riconoscibile.
Notate come i gradienti del cielo e i dettagli del terreno rimangono visibili anche alla risoluzione terminale. Con la standard ASCII, questi diventano bloccati e perdono le loro smooth transitionsM SK2 La griglia di punti 2×4 fornisce una risoluzione spaziale sufficiente che l'occhio integri il modello come immagine continua piuttosto che come caratteri discretiMSC4
C'è anche un -M bandiera per un effetto di sovrapposizione digitale della pioggia Matrix, perché perché non?. Composisce le correnti di katakana che cadono sulla vostra immagine sorgente.
L'animazione in terminali è complicata - approcci naivi causano un flicker visibileM SK1 ConsoleImage usa diverse tecniche:
DECSET 2026 Output sincronizzato - una funzione terminale che ti permette di "commettere" un intero riquadro all'improvvisoM SK3 prevenire la rottura | supportato in diversi terminali moderni | , ignorato silenziosamente altrove |
// Start synchronised output
Console.Write("\x1b[?2026h");
// Write entire frame
Console.Write(frameContent);
// End synchronised output
Console.Write("\x1b[?2026l");
Rendimento della Delta - Solo l'update delle cellule cambiate:
public (string output, CellData[,] cells) RenderWithDelta(
Image<Rgba32> image,
CellData[,]? previousCells,
int colorThreshold = 8)
{
var cells = RenderToCells(image);
var height = cells.GetLength(0);
var width = cells.GetLength(1);
// First frame or dimension change - full redraw
if (previousCells == null)
return (RenderCellsToString(cells), cells);
// Delta render - only output changed cells
var sb = new StringBuilder();
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
var current = cells[y, x];
var previous = previousCells[y, x];
// Skip if cell hasn't changed
if (current.IsSimilar(previous, colorThreshold))
continue;
// Position cursor and output
sb.Append($"\x1b[{y + 1};{x + 1}H");
sb.Append(current.ToAnsi());
}
}
return (sb.ToString(), cells);
}
Questo in genere riduce la produzione di 70-90% per i contenuti video dove la maggior parte del frammento è statico.
Per spostare il contenuto, piccoli perM SK1 cambiamenti di colore del frammento possono schimmeri. ConsoleImage include un pass dejitter che fa schiacciare. Cambie di colore tra le fotogramme, miglioramento della stabilità percepita, specialmente in braille e coloreM SK2smodi blocchiMSC3
I file video e i URL di YouTube sono gestiti tramite FFmpeg e yt-dlp M SK1auto-downloaded on first use ). Si può iniziare con offsetsMSC4 Dueture di riproduzione, Modi di rendering di interruttore, aggiungere sottotitoliM SK2 e esportarlo in forma GIF o documento usando lo stesso nucleo di renderamento .
Controlli di riproduzione video:
| chiave | azione |
|---|---|
Space |
Pause/Resume |
Q / Esc |
Qui |
ConsoleImage può salvare il risultato rappresentato a documenti connessi a se stessi- che riproducono senza la fonte originale. .cidz
Il formato usa la compressione GZip con il codice delta (o spesso ~7:1 contro JSON crudo), e i video lunghi possono essere trasmesso come NDJSON.
Quindi i frammenti sono scritti in modo incrementale invece di essere tamponati nella memoria.
C'è anche un pacco di giocatori leggeri (ConsoleImage.Player) che può ripetere i documenti senza ImageSharp o FFmpeg,
Il che rende fattibili i logo CLI animati senza un insieme di dipendenze pesanti.
C'è un intero API C# per rendere immagini , GIFs, videoM SK3 e documenti con idoneiMSC4opzioni di rendere ristretteMST5 Lo stesso renditori restituiscono il CLI, in modo da poter inserire gli algoritmi nelle proprie strumenti senza riimplementare la pipeline.
Spectre.L'integrazione con la console è disponibile sia per renderi in diretta che per riproduzioni di documenti, che permette di trattare le immagini come renderabili all'interno dei layout. Le pagine del README e NuGet coprono in dettaglio la superficie dell'API.
Se volete il dettaglio tecnico completo, queste sono le docce canoniche:
ConsoleImage include un MCP (Model Context Protocol) server che lo trasforma in una "probe visivaM SK3 per i flussi di lavoro dell'AIMSC4 Invece di essere solo "integrazione dell'IA perché il trend",la cosa\M SK7è effettivamente utile: il modello può chiedere una visuale ridotta dei media\ , misurare segnali semplici SSK10colore\MST11 movimento\M ST12 cambiamento\M st13 e solo allora decidere cosa tenere\M SST14\
Dato che ConsoleImage può rendere previews sensazionalmente significative, un'IA può ragionare sul contenuto video in maniera iterativa: campioneamentoM SK2 confrontazione , e raffinamento invece di consumare video interi a occhio nudoMSC4
Con l'integrazione MCP, un'AI può:
Mentre stavo scrivendo questo articolo, Ho usato ConsoleImage come strumento MCP per trovare buoni esempi di clips.
→ extract_frames (low-res preview at various timestamps)
→ compare_render_modes (ASCII vs braille at promising scenes)
→ render_to_gif (final export of selected clips)
Qui'è una piccola preview in braille a 30 di caratteri ampi - abbastanza per individuare la composizione e il movimento
⣿⣿⣿⣿⣿⣿⣿⣿⡿⢃⠌⡱⢈⠱⣈⠱⣈⠱⢈⠛⢿⠿⠟⢛⠛⢛⣿⣿⣿⣿⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣿⣿⠇⡌⠒⡄⢃⢲⣾⣷⠶⡉⠤⡀⢆⠢⢉⠢⡘⢄⢂⠉⣺⣽⢿⣞⣷⣻⣞⣷⣻⣞⣷⣿
⣿⣿⣿⣿⣿⣿⣿⣿⠐⡈⢅⠢⡁⣾⣿⡏⠤⠑⡂⢅⠢⣕⢨⣔⠡⠌⣂⠱⠘⠯⠿⣾⣽⣳⠯⣝⡗⢿⣞⣿
Questo mi permette di scansionare velocemente il contenuto per identificare frammenti interessanti piuttosto che rendere tutto in piena risoluzione.
La configurazione è un singolo indirizzo MCP server; consultate il MCP README per i dettagli.
Gli strumenti chiave includono: render_image, render_to_gif, extract_frames, e compare_render_modes.
flowchart TB
subgraph Core["ConsoleImage.Core (NuGet)"]
AR[AsciiRenderer]
BR[BrailleRenderer]
CB[ColorBlockRenderer]
CM[CharacterMap]
AP[AnimationPlayer]
DOC[Document Format]
end
subgraph Video["ConsoleImage.Video.Core"]
FF[FFmpegService]
VP[VideoPlayer]
end
subgraph CLI["ConsoleImage CLI"]
MAIN[Unified CLI]
end
subgraph MCP["ConsoleImage.Mcp"]
TOOLS[AI Tools]
end
MAIN --> Core
MAIN --> Video
TOOLS --> Core
style Core stroke:#4a9eff
style Video stroke:#ff6600
style CLI stroke:#00aa00
style MCP stroke:#9933ff
Quello che iniziava come una rapida implementazione dell'algoritmo di rendere ASCII di Alex Harri si è trasformato in un sistema grafico terminale.
Principali scoperte:
Il codice è dominio pubblico (Non licenziare) - usarlo come voleteM SK3 Contributions welcome on GitHub.
Un'altra volta è l'outil -. lucidVIEW - un piccolo cliente di Avalonia rapidoM SK1 che rende Markdown bene senza usare WebView.
Di più sulla parte 2.
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.