Calcular kernel de enfoque
Esta calculadora de kernels de enfoque convierte un único valor de intensidad en la matriz de convolución 3x3 exacta de una máscara de enfoque gaussiana.
Ejecutar — gratis
Resulta útil cuando una biblioteca de imágenes, un shader, un flujo de Canvas o un procesador propio requiere coeficientes en lugar de un control deslizante. El resultado es determinista, está normalizado para conservar el brillo constante y puede copiarse directamente al código. Introduzca una intensidad finita entre 0 y 5 para consultar los pesos centrales, laterales y de esquina sin cargar ni procesar ninguna imagen.
De un control de enfoque a coeficientes concretos
Una interfaz suele describir el enfoque mediante un solo control deslizante, pero un motor de convolución necesita nueve números dispuestos en forma de matriz. Esta calculadora conecta ambas representaciones. Parte del kernel de desenfoque gaussiano 3x3 normalizado, cuyas filas son proporcionales a 1–2–1, y genera una máscara de enfoque sumando la señal original y restando una señal desenfocada multiplicada por la intensidad. En notación compacta, el kernel es (1 + strength)I − strength·G, donde I representa la matriz identidad y G el kernel gaussiano. La matriz resultante tiene coeficientes iguales en las esquinas, otros iguales en los lados y un coeficiente central mayor. Con intensidad cero, se obtiene la identidad y cada píxel permanece intacto. Al aumentar la intensidad, los píxeles vecinos aportan valores negativos y crece el peso central, lo que realza el contraste local de los bordes. La suma de coeficientes se mantiene exactamente en uno después del redondeo estable, por lo que una región uniforme conserva su nivel general.
Cómo interpretar y aplicar la matriz 3x3
El resultado presenta el kernel como tres arreglos en orden por filas. Para calcular cada píxel de salida, alinee el centro de la matriz con ese píxel, multiplique cada coeficiente por el píxel correspondiente de su vecindad 3x3 y sume los nueve productos. Aplique la operación por separado a cada canal de color, salvo que su sistema especifique un flujo basado únicamente en luminancia. El tratamiento de los límites queda fuera de esta estimación porque las bibliotecas ofrecen políticas diferentes: repetir el píxel más cercano, reflejar la imagen, envolver las coordenadas o ignorar vecindades incompletas. Estas opciones modifican el aspecto junto al marco, pero no el kernel. Algunas bibliotecas exigen una lista plana; en ese caso, concatene las filas devueltas de arriba abajo. Otras aplican correlación en lugar de convolución, pero este kernel es simétrico respecto a la rotación, así que ambas orientaciones generan los mismos coeficientes. El campo `coefficient_sum` permite comprobar la normalización y `size` confirma la dimensión esperada para un consumidor programático.
Cómo elegir una intensidad útil y entender el límite
Comience con una intensidad moderada y evalúe el resultado sobre imágenes representativas, no solo sobre un recorte de alto contraste. El enfoque aumenta el contraste local: puede aclarar detalles auténticos, pero también amplificar ruido del sensor, bloques de compresión, oscilaciones y halos. El intervalo admitido va de 0 a 5, ambos incluidos. Este límite explícito detecta porcentajes mal colocados y otras entradas accidentales antes de producir coeficientes extremos. Un valor de 1 combina la imagen original con un residual completo entre la fuente y su desenfoque gaussiano; los valores fraccionarios producen una corrección más suave y los mayores exageran el residual. El cálculo no examina ninguna imagen y, por tanto, no puede recomendar un ajuste estéticamente ideal. Solo estima el kernel matemático exacto del parámetro solicitado. Para obtener flujos reproducibles, registre la intensidad junto con el tratamiento de bordes, el espacio de color, la política de canales y cualquier recorte o cuantización posterior. Esas decisiones suelen explicar las diferencias visuales entre herramientas con la misma intensidad nominal.
Qué puede hacer con ella
Configurar una biblioteca de imágenes
Convierta una intensidad legible en los nueve coeficientes que requiere una función de convolución genérica.
Crear un filtro con shader o Canvas
Genere un kernel normalizado para un shader de GPU, un efecto WebGL o un flujo de procesamiento con Canvas.
Documentar un flujo de imagen reproducible
Registre la matriz exacta asociada a un ajuste para que otra implementación pueda reproducir la misma operación matemática.
Preguntas frecuentes
¿Cuánto cuesta una solicitud API?
Cada solicitud API cuesta $0.002. El mismo cálculo determinista está disponible gratis en el navegador.
¿Qué valores de intensidad se admiten?
La intensidad debe ser un número finito entre 0 y 5, ambos incluidos. Los valores externos al intervalo devuelven un error de entrada no válida.
¿Qué devuelve una intensidad de cero?
Devuelve el kernel identidad 3x3: el coeficiente central es 1 y todos los coeficientes vecinos son 0.
¿Por qué los coeficientes suman uno?
Una suma unitaria conserva las regiones constantes y evita alterar el brillo general cuando todos los píxeles vecinos tienen el mismo valor.
¿Esta herramienta enfoca mi imagen?
No. Solo calcula el kernel. Aplique la matriz devuelta mediante una biblioteca de imágenes, una función de convolución, un shader u otro procesador.
¿Equivale al control de enfoque de cualquier aplicación?
No necesariamente. Las aplicaciones pueden usar radios, umbrales, espacios de color, bordes o procesos no lineales diferentes. Este resultado sigue la fórmula documentada de máscara gaussiana 3x3.
Para desarrolladores — acceso por API
Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.
Endpoint de API
¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.
Llámela desde su stack
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)Ejemplo de solicitud
{
"strength": 1
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "image.sharpen_estimate",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.
Precio
Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.
Límites
max_mb | 15 |
max_megapixels | 12 |
Errores
| HTTP | Código | Significado |
|---|---|---|
401 | unauthorized | API key ausente o inválida. |
402 | insufficient_balance | El saldo no cubre el precio de la tarea. |
404 | unknown_type | El tipo de tarea no existe. |
429 | rate_limited | Demasiadas peticiones. Use el webhook en vez de sondear. |