Convertir HSL en RGB
Obtenez de simples nombres de rouge, vert et bleu à partir d’une couleur HSL : teinte 210, saturation 80 % et luminosité 45 % donnent rouge 23, vert 115 et bleu 207. Une valeur hors plage est signalée, jamais corrigée en silence. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Hue
- 210
- Saturation
- 80
- Luminosité
- 45
- Red
- 23
- Vert
- 115
- Bleu
- 207
Convertissez une couleur HSL en canaux rouge, vert et bleu attendus par de nombreux outils graphiques, formats d’image et interfaces logicielles. Indiquez la teinte en degrés, puis la saturation et la luminosité en pourcentages afin d’obtenir trois entiers de 0 à 255. Le convertisseur valide chaque composante avant tout calcul : une valeur hors plage produit donc une erreur explicite plutôt qu’une couleur réajustée ou bouclée de manière inattendue. Ce calcul pur et déterministe convient aux vérifications interactives, aux exemples de documentation, aux chaînes de jetons de conception et aux transformations automatisées reproductibles.
Comprendre les valeurs HSL fournies
Le modèle HSL décrit une couleur au moyen de trois notions souvent plus simples à régler que les canaux rouge, vert et bleu pris séparément. La teinte est un angle sur une roue chromatique. 0 degré correspond au rouge, 120 degrés au vert, 240 degrés au bleu et 360 degrés revient à la même position rouge que 0. La saturation détermine l’intensité colorée du résultat.
À 0 %, la teinte n’a aucun effet visible et la sortie est une nuance de gris. À 100 %, la couleur atteint le chroma maximal disponible pour la teinte et la luminosité choisies. La luminosité place le résultat entre le noir et le blanc : 0 % donne toujours du noir, 50 % produit la forme la plus vive d’une teinte entièrement saturée et 100 % donne toujours du blanc.
Fournissez une teinte finie comprise entre 0 et 360, ainsi qu’une saturation et une luminosité finies comprises entre 0 et 100. Les bornes sont admises. Les valeurs extérieures sont rejetées au lieu d’être normalisées silencieusement.
Cette règle révèle les jetons de conception incorrects et empêche une teinte négative ou un pourcentage supérieur à 100 de produire une couleur crédible, mais involontaire.
Comment la conversion calcule les canaux RGB
Le calcul ramène d’abord la teinte sur un cercle unité et transforme les pourcentages de saturation et de luminosité en fractions. Lorsque la saturation vaut 0, la couleur est achromatique : les trois canaux RGB reçoivent alors la même valeur, issue de la luminosité. Dans les autres cas, l’algorithme calcule deux bornes intermédiaires à partir de la saturation et de la luminosité.
Il échantillonne ensuite trois positions du cercle de teinte, séparées d’un tiers de tour : une pour le rouge, une pour le vert et une pour le bleu. Une interpolation par morceaux projette chaque position entre les bornes intermédiaires. Enfin, chaque fraction de canal est multipliée par 255 puis arrondie à l’entier le plus proche.
La réponse contient les champs rouge, vert et bleu, tous garantis comme entiers de 0 à 255. Il s’agit d’une arithmétique déterministe, sans réseau, hasard, horloge, paramètre régional ni état mémorisé. La teinte 360 est également traitée comme l’extrémité de la roue équivalente à 0, tout en respectant la plage fermée annoncée.
Aucune entrée n’est écrêtée, afin que les erreurs de validation restent visibles.
Exploiter le résultat de façon fiable
Utilisez les canaux renvoyés partout où un système demande des valeurs RGB sur huit bits. Une feuille de style peut les insérer dans une expression rgb(), une routine d’image peut les écrire dans un pixel ou une entrée de palette, et une compilation de jetons de conception peut les sérialiser pour les plateformes qui ne lisent pas directement le HSL.
Pour un contrôle manuel, saisissez une couleur connue : une teinte de 0, une saturation de 100 et une luminosité de 50 donnent un rouge à 255, un vert à 0 et un bleu à 0. En automatisation, distinguez les échecs des réponses valides : un champ absent, un nombre non fini ou une composante hors plage constitue une entrée incorrecte qui doit être corrigée, et non relancée sans changement.
Conservez les valeurs HSL sources si l’équipe de conception doit effectuer plus tard des ajustements perceptifs, car cette capacité assure uniquement la conversion directe et ne reconstitue pas le HSL d’origine depuis RGB. La sortie entière est immédiatement exploitable par les consommateurs RGB classiques, sans politique d’arrondi supplémentaire susceptible de créer un écart d’une unité entre applications.
Cas d’usage
Compiler des jetons de conception
Transformez les jetons HSL de marque et de thème en canaux RGB entiers pour les applications et builds exigeant des composantes couleur sur huit bits.
Vérifier les calculs colorimétriques
Créez des références déterministes pour la documentation, les tests unitaires, les scripts de migration et la comparaison d’implémentations couleur.
Questions fréquentes
Quelles plages sont acceptées ?
La teinte doit être comprise entre 0 et 360. La saturation et la luminosité doivent chacune se situer entre 0 et 100. Toutes les bornes sont incluses.
Que se passe-t-il si une valeur sort de sa plage ?
Les valeurs ne sont ni bouclées ni écrêtées.
Pourquoi les valeurs RGB sont-elles entières ?
Les résultats normalisés sont multipliés par 255 et arrondis afin de servir directement dans les interfaces RGB courantes sur huit bits.
Les teintes 0 et 360 sont-elles équivalentes ?
Oui. Elles désignent toutes deux l’extrémité rouge de la roue chromatique et sont valides dans la plage fermée de 0 à 360.
Quels nombres RVB correspondent à teinte 210, saturation 80 % et luminosité 45 % ?
Rouge 23, vert 115 et bleu 207. Chaque canal est un nombre entier entre 0 et 255 : vous pouvez le saisir tel quel dans un logiciel graphique ou un réglage d’image.
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/hsl-to-rgb \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"hue":210,"saturation":80,"lightness":45}'const res = await fetch("https://api.kit.forhosting.com/color/hsl-to-rgb", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"hue": 210,
"saturation": 80,
"lightness": 45
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/color/hsl-to-rgb",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"hue": 210,
"saturation": 80,
"lightness": 45
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/color/hsl-to-rgb", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"hue":210,"saturation":80,"lightness":45}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"hue":210,"saturation":80,"lightness":45}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/color/hsl-to-rgb", 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
{
"hue": 210,
"saturation": 80,
"lightness": 45
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "color.hsl_to_rgb",
"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
Comment la conversion calcule les canaux RGB
Des entrées identiques produisent donc le même JSON dans un navigateur, une suite de tests ou une intégration API.
Exploiter le résultat de façon fiable
Le calcul dans le navigateur convient aux vérifications rapides ; une requête API coûte $0.002 lorsque la transformation s’intègre à une chaîne reproductible.
Cas d'intégration
Préparer des valeurs graphiques
Convertissez un choix HSL en valeurs rouge, verte et bleue pour canvas, les outils d’image, les graphiques, les palettes et les API de rendu.
Questions techniques
Combien coûte la conversion par API ?
Chaque requête API réussie utilise le tarif de base publié de $0.002. L’outil du navigateur exécute localement le même calcul déterministe.