Converta la luminosità di un’immagine in arte ASCII
Trasformi una griglia rettangolare di campioni di luminosità in scala di grigi in arte ASCII nitida e ripetibile.
Esegui gratis nel browser
Fornisca numeri interi da 0 per il nero a 255 per il bianco, quindi scelga una scala di caratteri ordinata dal più scuro al più chiaro. Il convertitore associa ogni campione alla posizione più vicina della scala e conserva la griglia come righe di testo. È utile per anteprime nel terminale, renderer solo testo, programmazione creativa, lezioni di elaborazione delle immagini e flussi che calcolano già medie di pixel o celle.
Prepari una griglia di luminosità adatta
Inizi con un array rettangolare nel quale ogni array interno rappresenta una riga di output e ogni valore una cella di carattere. I campioni devono essere numeri interi compresi tra 0 e 255: 0 indica il buio completo, 255 la luminosità piena e i valori intermedi descrivono i diversi grigi. Se la sorgente è una fotografia ad alta risoluzione, la riduca prima di chiamare il convertitore. Calcoli la media di un blocco di pixel per ciascuna posizione di carattere, perché associare ogni pixel a un carattere produce spesso un risultato enorme e accentua le diverse proporzioni di pixel e glifi. Mantenga tutte le righe della stessa lunghezza. Un’anteprima da terminale può usare da 40 a 120 colonne e meno righe, dato che i caratteri sono normalmente più alti che larghi. Ricevendo dati di luminosità anziché un file, lo strumento Le lascia controllare prima ridimensionamento, ritaglio, colore, trasparenza e contrasto. Una volta fissate tali scelte, la stessa griglia genera sempre lo stesso testo.
Scelga e interpreti la scala ASCII
Scriva la scala partendo dal carattere destinato al campione più scuro e terminando con quello del più chiaro. Una sequenza come <code>@%#*+=-:. </code> passa da segni visivamente densi a uno spazio finale: le aree nere diventano simboli marcati e quelle bianche si confondono con lo sfondo. Invertendo l’ordine ottiene una resa chiara su fondo scuro; con <code>#.</code> crea invece un risultato netto a due toni. Ogni carattere Unicode conta come una posizione, inclusi spazi ed emoji, anche se i normali caratteri monospaziati garantiscono l’allineamento più prevedibile. Per ogni campione, il convertitore distribuisce l’intervallo 0–255 sulle posizioni disponibili e arrotonda alla più vicina. Gli estremi sono esatti: 0 seleziona sempre il primo carattere e 255 l’ultimo. È possibile ripetere caratteri per allargare intenzionalmente una fascia tonale. Una scala vuota viene rifiutata. Ricordi che uno spazio finale è significativo anche quando risulta difficile da vedere in un modulo o visualizzatore JSON.
Utilizzi il testo e i metadati restituiti
Il risultato include <code>art</code>, un’unica stringa separata da ritorni a capo e pronta per un terminale, un file di testo, un log o un blocco di codice. Include inoltre <code>lines</code> come array, più comodo quando un programma deve aggiungere rientri, bordi, colori ANSI o numeri di riga senza dividere nuovamente il testo. Il numero di righe e colonne consente di verificare le dimensioni prima della visualizzazione o dell’archiviazione, mentre <code>ramp_length</code> registra quanti caratteri Unicode sono stati usati. Non viene applicato dithering casuale, quindi luminosità vicine possono condividere un carattere quando la scala è breve. È un comportamento intenzionale e riproducibile. Se desidera il dithering, applichi prima una diffusione d’errore deterministica o una matrice ordinata e invii la griglia ottenuta. Per un allineamento fedele usi un font monospaziato e conservi gli spazi. In HTML inserisca il risultato come testo in un elemento preformattato, non come markup, soprattutto se la scala contiene parentesi angolari o e commerciali.
Casi d'uso
Crei anteprime per il terminale
Converta celle in scala di grigi ridotte in testo compatto per shell, log e strumenti da riga di comando.
Spieghi la quantizzazione della luminosità
Mostri come valori di grigio apparentemente continui diventino fasce tonali definite da una scala finita.
Produca grafica testuale deterministica
Generi risorse ASCII riproducibili per documentazione, test, interfacce rétro o progetti di programmazione creativa.
Domande frequenti
In quale ordine va scritta la scala?
Ordini i caratteri dal simbolo che rappresenta la luminosità 0 fino a quello che rappresenta 255. Una scala dal denso al leggero crea il consueto stile scuro su fondo chiaro.
Cosa accade se la scala è vuota?
La richiesta non riesce e restituisce un errore di input non valido, perché non è disponibile alcun carattere per rappresentare la luminosità.
Sono accettati valori decimali di luminosità?
No. Ogni campione deve essere un intero da 0 a 255 inclusi, così il contratto e la conversione restano riproducibili.
Il convertitore ridimensiona un’immagine?
No. Converte una griglia rettangolare già pronta. Ridimensioni la sorgente e calcoli i valori di grigio prima dell’invio.
Quanto costa una richiesta API?
Ogni richiesta API costa $0.002. La stessa conversione deterministica può essere eseguita gratuitamente anche nel browser.
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo stack
curl -X POST https://api.kit.forhosting.com/image/ascii-art-map \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"samples":[[0,64,128,192,255],[255,192,128,64,0]],"ramp":"@%#*+=-:. "}'const res = await fetch("https://api.kit.forhosting.com/image/ascii-art-map", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"samples": [
[
0,
64,
128,
192,
255
],
[
255,
192,
128,
64,
0
]
],
"ramp": "@%#*+=-:. "
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/image/ascii-art-map",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"samples": [
[
0,
64,
128,
192,
255
],
[
255,
192,
128,
64,
0
]
],
"ramp": "@%#*+=-:. "
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/image/ascii-art-map", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"samples":[[0,64,128,192,255],[255,192,128,64,0]],"ramp":"@%#*+=-:. "}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"samples":[[0,64,128,192,255],[255,192,128,64,0]],"ramp":"@%#*+=-:. "}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/ascii-art-map", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Esempio di richiesta
{
"samples": [
[
0,
64,
128,
192,
255
],
[
255,
192,
128,
64,
0
]
],
"ramp": "@%#*+=-:. "
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "image.ascii_art_map",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Limiti
max_mb | 15 |
max_megapixels | 12 |
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |