Démultiplier l’alpha RGBA et retrouver les canaux directs
Annulez la prémultiplication d'un pixel : rouge 0,125, vert 0,25 et bleu 0,375 avec un alpha de 0,5 redeviennent 0,25, 0,5 et 0,75, l'alpha restant inchangé. L'alpha nul et les couleurs supérieures à l'alpha sont refusés. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Red
- 0,125
- Vert
- 0,25
- Bleu
- 0,375
- Alpha
- 0,5
- Red
- 0,25
- Vert
- 0,5
- Bleu
- 0,75
- RGBA
- 0,25, 0,5, 0,75, 0,5
L’outil de démultiplication de l’alpha RGBA retrouve les canaux directs rouge, vert et bleu d’un pixel normalisé prémultiplié. Vous fournissez quatre canaux numériques compris entre 0 et 1 ; le calculateur divise chaque composante colorée par l’alpha et conserve l’alpha d’origine. Il vérifie aussi qu’aucune couleur prémultipliée ne dépasse l’alpha et refuse un alpha nul, qui ne permet pas de retrouver la couleur initiale. La réponse déterministe contient les canaux nommés et un tableau RGBA ordonné, directement exploitable dans les outils graphiques, tests, convertisseurs et chaînes de traitement d’images.
Distinguez alpha prémultiplié et alpha direct
Les données RGBA représentent généralement la transparence de deux façons. Avec un alpha direct, les valeurs originales de rouge, vert et bleu sont stockées indépendamment de l’opacité. Avec un alpha prémultiplié, chaque couleur est enregistrée après multiplication par l’alpha.
Ainsi, un rouge direct de 0.8 associé à un alpha de 0.5 devient un rouge prémultiplié de 0.4. Cette représentation simplifie plusieurs opérations de composition et limite certains défauts sur les contours transparents, mais les canaux stockés ne décrivent plus directement la couleur initiale. Cette capacité inverse le calcul pour un pixel normalisé : elle divise rouge, vert et bleu par l’alpha, puis restitue l’alpha sans modification.
Les entrées utilisent l’intervalle de 0 à 1 plutôt que des octets de 0 à 255, ce qui rend la relation fractionnaire explicite. La réponse fournit chaque canal retrouvé sous un nom clair ainsi qu’un tableau RGBA dans l’ordre rouge, vert, bleu, alpha.
Comprenez pourquoi un alpha nul est refusé
La démultiplication n’est définie que lorsque l’alpha est strictement positif. Si l’alpha vaut zéro, tous les canaux correctement prémultipliés valent également zéro, quelle que soit leur couleur directe avant multiplication. Un pixel transparent rouge 0, vert 0, bleu 0, alpha 0 peut donc provenir de n’importe quelle couleur RGB ; une division par zéro ne permet pas d’obtenir une réponse unique.
Renvoyer du noir, conserver les zéros ou choisir une autre valeur créerait une information absente de l’entrée. Il refuse également les nombres non finis, les canaux hors de l’intervalle normalisé et toute composante prémultipliée supérieure à l’alpha. Cette dernière vérification respecte l’invariant des données normalisées et empêche un résultat direct supérieur à 1.
Les anomalies sont ainsi détectées avant qu’un pixel incorrect n’atteigne un moteur de rendu, un shader, un convertisseur de ressources ou un test automatisé.
Intégrez une récupération déterministe des canaux
Envoyez un pixel avec les champs rouge, vert, bleu et alpha. Les valeurs 0.125, 0.25 et 0.375 avec un alpha de 0.5 donnent les canaux directs 0.25, 0.5 et 0.75, tout en conservant l’alpha 0.5. Aucun arrondi, changement d’espace colorimétrique, correction gamma, écrêtage, quantification en octets, hasard, horloge ou format régional n’intervient.
Pour une image complète, intégrez cette opération à un traitement borné par pixel et vérifiez que la source est réellement prémultipliée.
Cas d’usage
Contrôler les calculs de composition
Testez des échantillons prémultipliés connus et comparez les canaux retrouvés aux valeurs directes attendues.
Normaliser des ressources graphiques
Transformez chaque enregistrement RGBA en représentation à alpha direct avant sérialisation, examen ou conversion.
Questions fréquentes
Quelle plage de canaux est acceptée ?
Les quatre canaux doivent être des nombres finis normalisés entre 0 et 1, avec un alpha strictement positif.
Pourquoi une couleur prémultipliée ne peut-elle dépasser l’alpha ?
Multiplier par l’alpha une couleur normalisée au plus égale à 1 ne produit jamais une valeur supérieure à l’alpha.
Cet outil convertit-il l’espace colorimétrique ou le gamma ?
Non. Il effectue uniquement la démultiplication arithmétique des canaux fournis ; réalisez les autres conversions séparément.
Le résultat arrondit-il ou écrête-t-il les canaux ?
Non. Une entrée valide garantit déjà la plage normalisée, et chaque couleur est divisée directement par l’alpha.
Quelle différence entre alpha droit et alpha prémultiplié ?
L'alpha droit conserve la couleur d'origine à part de l'opacité, tandis que l'alpha prémultiplié stocke chaque couleur déjà multipliée par l'alpha. Un rouge droit de 0,8 avec un alpha de 0,5 est stocké prémultiplié à 0,4.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre 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)Exemple de requête
{
"red": 0.125,
"green": 0.25,
"blue": 0.375,
"alpha": 0.5
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "color.unpremultiply",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Comprenez pourquoi un alpha nul est refusé
Le calculateur renvoie alors `invalid_input`.
Intégrez une récupération déterministe des canaux
Utilisez cette opération lorsqu’une bibliothèque d’images, une API graphique, un export de canevas, une chaîne de textures ou une ressource sérialisée fournit des canaux normalisés prémultipliés alors que le système suivant attend un alpha direct. Le calcul applique une division directe selon les règles numériques ECMAScript : une même entrée JSON valide produit donc la même sortie dans le navigateur et par API. L’API coûte $0.002 par requête.
Cas d'intégration
Convertir la sortie d’une API graphique
Retrouvez des couleurs directes normalisées avant d’envoyer les pixels vers une interface qui sépare RGB et alpha.
Questions techniques
Que se passe-t-il lorsque l’alpha vaut zéro ?
La requête échoue avec `invalid_input`, car des données prémultipliées entièrement transparentes ne conservent aucune couleur directe unique.