Calcular kernel de nitidez
Esta calculadora de kernel de nitidez transforma um único valor de intensidade na matriz de convolução 3x3 exata de uma máscara de nitidez gaussiana.
Executar grátis
Ela é útil quando uma biblioteca de imagens, um shader, um fluxo com Canvas ou um processador próprio exige coeficientes em vez de um controle deslizante. O resultado é determinístico, normalizado para preservar o brilho constante e pronto para ser copiado no código. Informe uma intensidade finita entre 0 e 5 para consultar os pesos centrais, laterais e dos cantos sem enviar nem processar uma imagem.
De um controle de nitidez a coeficientes concretos
Uma interface geralmente representa a nitidez com um único controle deslizante, mas um mecanismo de convolução precisa de nove números organizados como matriz. Esta calculadora faz a ligação entre essas duas representações. Ela começa com o kernel gaussiano 3x3 normalizado, cujas linhas são proporcionais a 1–2–1, e cria uma máscara de nitidez somando o sinal original e subtraindo um sinal desfocado multiplicado pela intensidade. Em notação compacta, o kernel é (1 + strength)I − strength·G, em que I é a matriz identidade e G é o kernel gaussiano. A matriz resultante apresenta coeficientes iguais nos cantos, outros iguais nas laterais e um coeficiente central maior. Com intensidade zero, a matriz é a identidade e mantém cada pixel inalterado. Ao aumentar a intensidade, os pixels vizinhos passam a contribuir negativamente e o peso central cresce, destacando o contraste local nas bordas. A soma dos coeficientes continua exatamente igual a um depois do arredondamento estável, portanto uma região totalmente uniforme preserva seu nível geral.
Como interpretar e aplicar a matriz 3x3
O resultado apresenta o kernel como três arrays em ordem de linhas. Para calcular cada pixel de saída, alinhe o centro da matriz ao pixel, multiplique cada coeficiente pelo pixel correspondente da vizinhança 3x3 e some os nove produtos. Aplique a mesma operação separadamente aos canais de cor, a menos que o sistema determine um fluxo exclusivo de luminância. O tratamento das bordas não faz parte desta estimativa, pois bibliotecas de convolução oferecem políticas diferentes, como repetir o pixel mais próximo, refletir a imagem, envolver coordenadas ou ignorar vizinhanças incompletas. Essas políticas podem alterar a aparência junto à moldura, mas não modificam o kernel. Algumas bibliotecas exigem uma lista plana; nesse caso, concatene as linhas retornadas de cima para baixo. Outras usam correlação em vez de convolução, porém este kernel tem simetria rotacional e produz os mesmos coeficientes nas duas orientações. O campo `coefficient_sum` permite conferir a normalização, enquanto `size` confirma a dimensão esperada para integrações programáticas.
Como escolher uma intensidade útil e entender o limite
Comece com uma intensidade moderada e avalie o resultado em imagens representativas, não apenas em um recorte de alto contraste. O aumento de nitidez amplia o contraste local: pode deixar detalhes reais mais claros, mas também pode reforçar ruído do sensor, blocos de compressão, oscilações e halos. O intervalo aceito vai de 0 a 5, inclusive. Esse limite explícito detecta porcentagens inseridas por engano e outras entradas acidentais antes que gerem coeficientes extremos. O valor 1 combina a imagem original com um residual completo entre a fonte e seu desfoque gaussiano; valores fracionários oferecem uma correção mais suave, enquanto valores maiores exageram o residual. O cálculo não examina uma imagem e, portanto, não consegue recomendar uma configuração esteticamente ideal. Ele estima somente o kernel matemático exato correspondente ao parâmetro solicitado. Para criar fluxos reproduzíveis, registre a intensidade junto com o tratamento de bordas, o espaço de cor, a política de canais e qualquer recorte ou quantização posterior. Essas escolhas costumam explicar diferenças visuais entre ferramentas com a mesma intensidade nominal.
Casos de uso
Configurar uma biblioteca de imagens
Converta uma intensidade fácil de entender nos nove coeficientes exigidos por uma função de convolução genérica.
Criar um filtro com shader ou Canvas
Gere um kernel normalizado para um shader de GPU, um efeito WebGL ou um fluxo de processamento no Canvas.
Documentar um fluxo de imagem reproduzível
Registre a matriz exata associada a uma configuração para que outra implementação reproduza a mesma operação matemática.
Perguntas frequentes
Quanto custa uma solicitação API?
Cada solicitação API custa US$ 0,002. O mesmo cálculo determinístico está disponível gratuitamente no navegador.
Quais valores de intensidade são aceitos?
A intensidade deve ser um número finito entre 0 e 5, inclusive. Valores fora desse intervalo retornam um erro de entrada inválida.
O que uma intensidade zero retorna?
Ela retorna o kernel identidade 3x3: o coeficiente central é 1 e todos os coeficientes vizinhos são 0.
Por que os coeficientes somam um?
A soma unitária preserva regiões constantes e impede mudanças no brilho geral quando todos os pixels vizinhos têm o mesmo valor.
Esta ferramenta aumenta a nitidez da minha imagem?
Não. Ela apenas calcula o kernel. Aplique a matriz retornada com uma biblioteca de imagens, função de convolução, shader ou outro processador.
O resultado equivale ao controle de nitidez de qualquer aplicativo?
Não necessariamente. Aplicativos podem usar raios, limiares, espaços de cor, políticas de borda ou processos não lineares diferentes. Este resultado segue a fórmula documentada da máscara gaussiana 3x3.
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
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/image/sharpen-estimate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"strength":1}'const res = await fetch("https://api.kit.forhosting.com/image/sharpen-estimate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"strength": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/image/sharpen-estimate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"strength": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/image/sharpen-estimate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"strength":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"strength":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/sharpen-estimate", 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
{
"strength": 1
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "image.sharpen_estimate",
"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
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Limites
max_mb | 15 |
max_megapixels | 12 |
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. |