Rimuovere la premoltiplicazione alfa RGBA
Annulli la premoltiplicazione di un pixel: rosso 0,125, verde 0,25 e blu 0,375 con alfa 0,5 tornano a 0,25, 0,5 e 0,75, e l'alfa resta invariato. Alfa zero e colori superiori ad alfa vengono rifiutati. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Red
- 0,125
- Verde
- 0,25
- Blu
- 0,375
- Alfa
- 0,5
- Red
- 0,25
- Verde
- 0,5
- Blu
- 0,75
- RGBA
- 0,25, 0,5, 0,75, 0,5
Lo strumento per rimuovere la premoltiplicazione alfa RGBA recupera i canali diretti rosso, verde e blu da un pixel normalizzato premoltiplicato. Lei fornisce quattro canali numerici tra 0 e 1; il calcolatore divide ogni componente cromatica per alfa e conserva il valore alfa originale. Verifica inoltre che nessun colore premoltiplicato superi alfa e rifiuta alfa zero, caso in cui il colore iniziale non può essere ricostruito. La risposta deterministica include canali denominati e un array RGBA ordinato, pronto per strumenti grafici, test, convertitori e pipeline di elaborazione delle immagini.
Distingua l’alfa premoltiplicato da quello diretto
I dati RGBA possono rappresentare la trasparenza in due modi comuni. Con alfa diretto, i valori originali di rosso, verde e blu vengono memorizzati indipendentemente dall’opacità. Con alfa premoltiplicato, ogni colore viene salvato dopo essere stato moltiplicato per alfa.
Per esempio, un rosso diretto di 0.8 con alfa 0.5 diventa un rosso premoltiplicato di 0.4. La premoltiplicazione semplifica diverse operazioni di compositing e riduce alcuni artefatti lungo i bordi trasparenti, ma i canali registrati non descrivono più direttamente il colore originale. Questa capacità inverte il calcolo per un pixel normalizzato: divide rosso, verde e blu per alfa e restituisce alfa invariato.
Gli input usano l’intervallo da 0 a 1, anziché byte da 0 a 255, rendendo esplicito il rapporto frazionario. La risposta riporta ogni canale recuperato con il proprio nome e include anche un array RGBA nell’ordine rosso, verde, blu e alfa per i sistemi che preferiscono valori posizionali.
Comprenda perché alfa zero genera un errore
La rimozione della premoltiplicazione è definita solo quando alfa è maggiore di zero. Se alfa è zero, tutti i canali premoltiplicati correttamente sono anch’essi zero, qualunque fosse il colore diretto prima della moltiplicazione. Un pixel trasparente con rosso 0, verde 0, blu 0 e alfa 0 potrebbe quindi derivare da qualsiasi colore RGB; la divisione per zero non può restituire una risposta univoca.
Scegliere il nero, mantenere gli zeri o inventare un ripiego attribuirebbe all’input informazioni inesistenti. Rifiuta anche numeri non finiti, canali fuori dall’intervallo normalizzato e qualunque componente premoltiplicata superiore ad alfa. Quest’ultimo controllo applica l’invariante previsto per dati normalizzati e impedisce risultati diretti superiori a 1.
Gli errori emergono così prima che un pixel non valido raggiunga un renderer, uno shader, un convertitore di risorse o un confronto automatizzato.
Inserisca il recupero deterministico nel flusso
Invii un pixel nei campi rosso, verde, blu e alfa. I valori 0.125, 0.25 e 0.375 con alfa 0.5 producono i canali diretti 0.25, 0.5 e 0.75, conservando alfa 0.5. Non vengono applicati arrotondamento, conversione dello spazio colore, correzione gamma, limitazione, quantizzazione in byte, casualità, orologio o formattazione locale.
Per immagini complete, integri l’operazione in una pipeline limitata per pixel e verifichi sempre che la sorgente sia davvero premoltiplicata.
Casi d'uso
Verificare calcoli di compositing
Controlli campioni premoltiplicati noti nei test e confronti i canali recuperati con i valori diretti previsti.
Normalizzare record di risorse
Trasformi singoli record RGBA in una rappresentazione coerente ad alfa diretto prima di serializzazione, esame o conversione.
Domande frequenti
Quale intervallo di canali viene accettato?
Tutti e quattro i canali devono essere numeri finiti normalizzati tra 0 e 1, con alfa maggiore di zero.
Perché un colore premoltiplicato non può superare alfa?
Moltiplicando per alfa un colore normalizzato non superiore a 1 non si ottiene mai un valore maggiore di alfa.
Lo strumento converte spazi colore o corregge la gamma?
No. Esegue solo la rimozione aritmetica della premoltiplicazione; interpreti e converta lo spazio colore separatamente.
Il risultato arrotonda o limita i canali recuperati?
No. Gli input validi garantiscono già l’intervallo normalizzato e ogni colore deriva dalla divisione diretta per alfa.
Che differenza c'è tra alfa diretto e alfa premoltiplicato?
L'alfa diretto conserva il colore originale separato dall'opacità, mentre quello premoltiplicato salva ogni colore già moltiplicato per alfa. Un rosso diretto di 0,8 con alfa 0,5 viene salvato premoltiplicato come 0,4.
Strumenti correlati
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/color/unpremultiply \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"red":0.125,"green":0.25,"blue":0.375,"alpha":0.5}'const res = await fetch("https://api.kit.forhosting.com/color/unpremultiply", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"red": 0.125,
"green": 0.25,
"blue": 0.375,
"alpha": 0.5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/color/unpremultiply",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"red": 0.125,
"green": 0.25,
"blue": 0.375,
"alpha": 0.5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/color/unpremultiply", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"red":0.125,"green":0.25,"blue":0.375,"alpha":0.5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"red":0.125,"green":0.25,"blue":0.375,"alpha":0.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/color/unpremultiply", 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
{
"red": 0.125,
"green": 0.25,
"blue": 0.375,
"alpha": 0.5
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "color.unpremultiply",
"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.
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. |
Note tecniche
Comprenda perché alfa zero genera un errore
Il calcolatore restituisce quindi `invalid_input`.
Inserisca il recupero deterministico nel flusso
Usi questa operazione quando una libreria di immagini, un’API grafica, un’esportazione canvas, una pipeline di texture o una risorsa serializzata fornisce canali normalizzati premoltiplicati, mentre il sistema successivo richiede alfa diretto. Il calcolo è una divisione diretta secondo le regole numeriche ECMAScript, quindi lo stesso input JSON valido genera la stessa uscita nel browser e tramite API. L’API costa $0.002 per richiesta.
Casi di integrazione
Convertire output di API grafiche
Recuperi colori diretti normalizzati prima di passare pixel premoltiplicati a un’interfaccia che richiede RGB e alfa separati.
Domande tecniche
Che cosa accade quando alfa è zero?
La richiesta fallisce con `invalid_input`, perché dati premoltiplicati del tutto trasparenti non conservano un colore diretto univoco.