Interpolation de couleur Bézier cubique
L’interpolation de couleur par Bézier cubique calcule la couleur exacte atteinte entre deux extrémités hexadécimales après transformation de la fraction demandée par une courbe temporelle.
Lancer gratuitement
Indiquez les couleurs de départ et d’arrivée, une fraction comprise entre zéro et un, ainsi que les quatre coordonnées de contrôle utilisées par l’easing cubic-bezier de CSS. Le résultat fournit la fraction lissée, les couleurs normalisées, la valeur hexadécimale et les canaux RGB, afin de reproduire les transitions dans les outils de conception, pipelines d’animation, tests et ressources générées sans dépendre de l’horloge d’animation d’un navigateur.
Distinguez la progression temporelle de celle de la couleur
Un mélange linéaire assimile cinquante pour cent du temps écoulé à cinquante pour cent de la distance entre deux couleurs. Les interfaces réelles exigent souvent un autre rythme : une transition peut démarrer doucement, accélérer en son milieu, puis ralentir près de sa destination. Cette capacité applique une courbe temporelle de Bézier cubique avant de mélanger les canaux RGB. L’entrée t reste la fraction de la chronologie, tandis que eased_t indique la fraction de couleur produite par la courbe. Cette distinction facilite l’examen et la réutilisation du résultat. À l’instant zéro, la couleur initiale est renvoyée ; à l’instant un, c’est la couleur finale. Entre ces extrémités, la courbe détermine la vitesse d’évolution des canaux. Comme l’opération reçoit des nombres explicites et ne consulte aucune horloge, des requêtes identiques produisent une sortie identique. Un moteur de rendu, un exporteur de conception, une suite de tests ou un processus de build peut ainsi cibler la même image de transition sans exécuter d’animation ni estimer l’affichage du navigateur à un instant donné.
Méthode de résolution de la fraction de Bézier cubique
Une courbe de Bézier cubique de type CSS part de zéro, arrive à un et possède deux points de contrôle fournis lors de l’appel. La fraction temporelle demandée appartient à l’axe x de la courbe : évaluer directement le polynôme y avec ce même nombre serait donc incorrect pour la plupart des courbes. Le calculateur recherche d’abord le paramètre interne dont la coordonnée x correspond à la fraction demandée. Il emploie une recherche de Newton bornée lorsque la pente convient, puis une recherche par bissection à nombre d’étapes fixe comme solution de repli stable. Il évalue ensuite la coordonnée y au paramètre obtenu. Les coordonnées x de contrôle doivent rester entre zéro et un afin de préserver la monotonie du temps et l’unicité de la réponse. Les contrôles y peuvent aller de moins dix à dix pour autoriser anticipation et dépassement. Si l’easing sort de l’intervalle normal, les canaux RGB interpolés sont limités à des octets valides. Les décimales affichées sont arrondies uniformément et les canaux à l’entier le plus proche. Ces règles éliminent toute dépendance envers le moteur du navigateur, la cadence d’images ou l’échantillonnage propre à une plateforme.
Choisissez les entrées et exploitez la couleur renvoyée
Saisissez chaque couleur sous la forme de trois ou six chiffres hexadécimaux, éventuellement précédés d’un dièse. Les formes courtes sont développées et toutes les couleurs acceptées reviennent normalisées sur six chiffres minuscules. Fournissez t entre zéro et un, puis x1, y1, x2 et y2 dans l’ordre habituel de cubic-bezier. Par exemple, la forme ease-in-out courante utilise 0.42, 0, 0.58 et 1. La réponse conserve les extrémités normalisées et la courbe, expose la fraction lissée calculée et fournit à la fois une couleur hexadécimale et les canaux rouge, vert et bleu séparés. Utilisez la valeur hexadécimale dans CSS, SVG, des jetons de conception ou des instructions d’image ; préférez l’objet de canaux pour des données numériques structurées. Pour créer une série d’images, répétez l’opération avec des fractions temporelles régulièrement espacées sans modifier les extrémités ni les contrôles. La validation refuse les couleurs mal formées, nombres non finis, fractions hors chronologie, contrôles x non monotones et contrôles y excessifs, empêchant ainsi toute configuration invalide de produire silencieusement un échantillon trompeur.
Cas d’usage
Générez des images d’animation déterministes
Échantillonnez une transition colorée lissée à des fractions exactes pour un moteur de rendu ou un pipeline de ressources, sans horloge réelle.
Testez les couleurs de transition d’une interface
Calculez la valeur hexadécimale intermédiaire attendue pour des tests visuels et de composants utilisant une courbe de Bézier cubique documentée.
Créez une gamme lissée de jetons de conception
Produisez des jetons colorés dont l’espacement reprend le rythme d’accélération et de stabilisation d’une animation d’interface.
Questions fréquentes
Quel est le prix d’une requête ?
Chaque requête API coûte $0.002. La version pour navigateur peut s’exécuter localement sans transmettre le calcul à l’API.
Est-ce identique à un mélange linéaire de couleurs ?
Non. Un mélange linéaire emploie directement la fraction fournie ; cette opération la transforme d’abord au moyen de la courbe de Bézier cubique.
Pourquoi x1 et x2 doivent-ils rester entre zéro et un ?
Cette contrainte maintient une progression temporelle monotone, respecte les règles temporelles CSS et permet d’inverser x sans ambiguïté.
La courbe d’easing peut-elle produire un dépassement ?
Oui. y1 et y2 peuvent sortir de l’intervalle de zéro à un. La fraction lissée indique le dépassement et les canaux RGB sont limités à des valeurs valides.
Quels formats de couleur sont acceptés ?
Les couleurs RGB hexadécimales à trois ou six chiffres sont acceptées, avec ou sans dièse initial. Les canaux alpha et les noms de couleur sont exclus.
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/bezier-interpolate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"color1":"#ff6600","color2":"#3366ff","t":0.5,"x1":0.42,"y1":0,"x2":0.58,"y2":1}'const res = await fetch("https://api.kit.forhosting.com/color/bezier-interpolate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"color1": "#ff6600",
"color2": "#3366ff",
"t": 0.5,
"x1": 0.42,
"y1": 0,
"x2": 0.58,
"y2": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/color/bezier-interpolate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"color1": "#ff6600",
"color2": "#3366ff",
"t": 0.5,
"x1": 0.42,
"y1": 0,
"x2": 0.58,
"y2": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/color/bezier-interpolate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"color1":"#ff6600","color2":"#3366ff","t":0.5,"x1":0.42,"y1":0,"x2":0.58,"y2":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"color1":"#ff6600","color2":"#3366ff","t":0.5,"x1":0.42,"y1":0,"x2":0.58,"y2":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/color/bezier-interpolate", 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
{
"color1": "#ff6600",
"color2": "#3366ff",
"t": 0.5,
"x1": 0.42,
"y1": 0,
"x2": 0.58,
"y2": 1
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "color.bezier_interpolate",
"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. |