ForHosting KIT · Imagens

Despremultiplicar alfa RGBA e recuperar canais diretos

Desfaça o alfa premultiplicado de um pixel: vermelho 0,125, verde 0,25 e azul 0,375 com alfa 0,5 voltam a ser 0,25, 0,5 e 0,75, e o alfa não muda. Alfa zero e cores maiores que alfa são recusados. Grátis no seu navegador.

Grátis
Funciona no seu navegador
Sem cadastro
Seus dados não saem do seu aparelho

Executar grátis Ver a API

Use pelo WebAPIE-mailTelegramApp em breve

Exemplo resolvido

Se você digitar

Red: 0,125
Verde: 0,25
Azul: 0,375
Alfa: 0,5

Você obtém

Red: 0,25
Verde: 0,5
Azul: 0,75
RGBA: 0,25, 0,5, 0,75, 0,5

A ferramenta de despremultiplicação de alfa RGBA recupera os canais diretos vermelho, verde e azul de um pixel normalizado premultiplicado. Você informa quatro canais numéricos entre 0 e 1, e a calculadora divide cada componente de cor por alfa, preservando o alfa original. Ela também verifica se nenhuma cor premultiplicada ultrapassa alfa e rejeita alfa zero, situação em que a cor original não pode ser recuperada. A resposta determinística traz canais nomeados e um array RGBA ordenado para uso em ferramentas gráficas, testes, conversores e fluxos de processamento de imagens.

Entenda alfa premultiplicado e alfa direto

Dados RGBA podem representar transparência de duas maneiras comuns. Com alfa direto, os valores originais de vermelho, verde e azul ficam armazenados independentemente da opacidade. Com alfa premultiplicado, cada cor é gravada depois de ser multiplicada por alfa.

Por exemplo, um vermelho direto de 0.8 com alfa 0.5 vira um vermelho premultiplicado de 0.4. A premultiplicação simplifica várias operações de composição e reduz certos artefatos nas bordas transparentes, mas os canais armazenados deixam de descrever diretamente a cor original. Esta capacidade reverte essa conta para um pixel normalizado: divide vermelho, verde e azul por alfa e devolve alfa sem alteração.

As entradas usam o intervalo de 0 a 1, em vez de bytes de 0 a 255, para manter explícita a relação fracionária. A resposta apresenta cada canal recuperado pelo nome e inclui também um array RGBA na ordem vermelho, verde, azul e alfa para consumidores que preferem valores posicionais.

Saiba por que alfa zero gera erro

A despremultiplicação só é definida quando alfa é maior que zero. Se alfa for zero, todo canal corretamente premultiplicado também será zero, qualquer que tenha sido a cor direta antes da multiplicação. Assim, um pixel transparente com vermelho 0, verde 0, azul 0 e alfa 0 pode ter vindo de qualquer cor RGB, e uma divisão por zero não recupera uma resposta única.

Retornar preto, manter os canais zerados ou criar outra alternativa pareceria determinístico, mas atribuiria à entrada uma informação que ela não contém. Ela também recusa números não finitos, canais fora do intervalo normalizado e qualquer vermelho, verde ou azul premultiplicado maior que alfa. A última validação preserva a regra esperada para dados normalizados e impede resultados diretos acima de 1.

Esses controles expõem problemas antes que um pixel inválido chegue a um renderizador, shader, conversor de ativos ou comparação automatizada.

Use a recuperação determinística no seu fluxo

Envie um pixel pelos campos vermelho, verde, azul e alfa. Os valores premultiplicados 0.125, 0.25 e 0.375 com alfa 0.5 retornam os canais diretos 0.25, 0.5 e 0.75, mantendo alfa 0.5. Não há arredondamento, conversão de espaço de cor, correção de gama, limitação, quantização em bytes, fonte aleatória, relógio ou formatação regional.

Para imagens inteiras, incorpore a operação a um fluxo limitado por pixels e confirme sempre que a origem realmente contém dados premultiplicados.

Casos de uso

Converter saídas de APIs gráficas

Recupere cores diretas normalizadas antes de enviar pixels premultiplicados a uma interface que espera RGB e alfa independentes.

Validar cálculos de composição

Teste amostras premultiplicadas conhecidas e compare os canais recuperados com os valores de alfa direto esperados.

Normalizar registros de ativos

Transforme registros RGBA individuais em uma representação consistente de alfa direto antes de serializar, inspecionar ou converter.

Perguntas frequentes

Qual intervalo de canais é aceito?

Os quatro canais devem ser números finitos normalizados entre 0 e 1, e alfa precisa ser maior que zero.

Por que uma cor premultiplicada não pode ultrapassar alfa?

Multiplicar uma cor normalizada não maior que 1 por alfa nunca produz um valor acima de alfa; essa entrada seria inconsistente.

A ferramenta converte espaços de cor ou corrige gama?

Não. Ela faz apenas a despremultiplicação aritmética dos canais informados; interprete e converta o espaço de cor separadamente.

O resultado arredonda ou limita os canais recuperados?

Não. Entradas válidas já garantem o intervalo normalizado, e cada cor resulta da divisão direta de seu valor premultiplicado por alfa.

Qual é a diferença entre alfa direto e alfa premultiplicado?

O alfa direto guarda a cor original separada da opacidade; o premultiplicado guarda cada cor já multiplicada por alfa. Um vermelho direto de 0,8 com alfa 0,5 fica guardado premultiplicado como 0,4.

Ferramentas relacionadas

Para desenvolvedores — acesso via API

Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.

Endpoint

POSThttps://api.kit.forhosting.com/color/unpremultiply

Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.

Chame do seu código

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)

Exemplo de requisição

{
  "red": 0.125,
  "green": 0.25,
  "blue": 0.375,
  "alpha": 0.5
}

Exemplo de resposta

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "color.unpremultiply",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.

Preço

por chamadaUS$ 0,002

Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.

Erros

HTTP	Código	O que significa
`401`	`unauthorized`	Token ausente ou inválido. Confira o header Authorization.
`402`	`insufficient_balance`	Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo.
`404`	`unknown_type`	Esse tipo de tarefa não existe. Confira o campo type no catálogo.
`429`	`rate_limited`	Muitas requisições em pouco tempo. Espere um instante e tente de novo.

Notas técnicas

Saiba por que alfa zero gera erro

Por isso, a calculadora rejeita alfa zero com `invalid_input`.

Use a recuperação determinística no seu fluxo

Use esta operação quando uma biblioteca de imagens, API gráfica, exportação de canvas, pipeline de texturas ou ativo serializado fornecer canais normalizados premultiplicados, mas o próximo sistema exigir alfa direto. O cálculo usa divisão direta segundo as regras numéricas do ECMAScript; portanto, a mesma entrada JSON válida gera a mesma saída no navegador e na API. A API custa US$ 0,002 por solicitação.

Perguntas técnicas

O que acontece quando alfa é zero?

A solicitação falha com `invalid_input`, pois dados premultiplicados totalmente transparentes não preservam uma cor direta única.

Ver a documentação completa do KIT →

Executar grátis

Exemplo resolvido

Entenda alfa premultiplicado e alfa direto

Saiba por que alfa zero gera erro

Use a recuperação determinística no seu fluxo

Casos de uso

Converter saídas de APIs gráficas

Validar cálculos de composição

Normalizar registros de ativos

Perguntas frequentes

Ferramentas relacionadas

Para desenvolvedores — acesso via API

Endpoint

Chame do seu código

Exemplo de requisição

Exemplo de resposta

Preço

Erros

Notas técnicas

Saiba por que alfa zero gera erro

Use a recuperação determinística no seu fluxo

Perguntas técnicas

obrigado