Hispanopedia Wiki
Articulo de referencia

Algoritmos de escalado de pixel art

Imagen de un televisor (centro) redimensionada mediante escalado simple del vecino más cercano (izquierda) y el algoritmo de interpolación 2xSaI (derecha). Comparación de algori...

Hispanopedia WikiContenido en espanolLectura gratuita
Imagen de un televisor (centro) redimensionada mediante escalado simple del vecino más cercano (izquierda) y el algoritmo de interpolación 2xSaI (derecha).
Comparación de algoritmos comunes de escalado de pixel art. Visualice la imagen en resolución completa para apreciar las diferencias.

Los algoritmos de escalado de pixel art son filtros gráficos que buscan mejorar la apariencia de las imágenes pixeladas 2D dibujadas a mano . Estos algoritmos constituyen una forma de mejora automática de la imagen. Los algoritmos de escalado de pixel art emplean métodos significativamente diferentes a los métodos comunes de reescalado de imágenes , cuyo objetivo es preservar la apariencia original.

Dado que los gráficos pixel art se utilizan habitualmente a resoluciones muy bajas , emplean una coloración precisa de cada píxel. Esto da como resultado gráficos que dependen de una gran cantidad de señales visuales estilizadas para definir formas complejas. Se han desarrollado varios algoritmos especializados [ 1 ] para gestionar el reescalado de dichos gráficos.

Estos algoritmos especializados pueden mejorar el aspecto de los gráficos pixelados, pero al hacerlo introducen cambios. Dichos cambios pueden resultar indeseables, especialmente si el objetivo es reproducir fielmente el aspecto original.

Dado que una aplicación típica de esta tecnología es mejorar la apariencia de los videojuegos de cuarta generación y anteriores en emuladores de arcade y consolas , muchos algoritmos de escalado de pixel art están diseñados para ejecutarse en tiempo real para imágenes de entrada suficientemente pequeñas a 60 fotogramas por segundo . Esto impone restricciones al tipo de técnicas de programación que se pueden usar para este tipo de procesamiento en tiempo real. Muchas funcionan solo con factores de escala específicos. 2× es el factor de escala más común, mientras que 3×, 4×, 5× y 6× existen, pero se usan con menos frecuencia.

Algoritmos

SAA5050 'Suavizado diagonal'

El chip generador de caracteres de teletexto Mullard SAA5050 (1980) utilizaba un algoritmo primitivo de escalado de píxeles para generar caracteres de mayor resolución en la pantalla a partir de una representación de menor resolución de su ROM interna . Internamente, la forma de cada carácter se definía en una cuadrícula de 5 × 9 píxeles, que luego se interpolaba suavizando las diagonales para obtener un carácter de 10 × 18 píxeles, con una forma angular característica, rodeado en la parte superior e izquierda por dos píxeles de espacio en blanco. El algoritmo solo funciona con datos fuente monocromáticos y asume que los píxeles fuente serán lógicamente verdaderos o falsos dependiendo de si están "encendidos" o "apagados". Se asume que los píxeles "fuera del patrón de la cuadrícula" están apagados. [ 2 ] [ 3 ] [ 4 ]

El algoritmo funciona de la siguiente manera:

ABC --\ 1 2 DEF --/ 3 4 1 = B | (A & E & !B & !D) 2 = B | (C & E & !B & !F) 3 = E | (!A & !E & B & D) 4 = E | (!C & !E & B & F)

Cabe destacar que este algoritmo, al igual que el algoritmo Eagle que se describe a continuación, presenta un fallo: si aparece un patrón de 4 píxeles con forma de diamante hueco, este quedará oculto por la expansión. La ROM de caracteres interna del SAA5050 evita cuidadosamente utilizar este patrón.

El caso degenerado:

 * * * *

se convierte en:

 ** **** ****** ****** **** **

EPX/Scale2×/AdvMAME2×

El algoritmo de expansión de píxeles de Eric (EPX) fue desarrollado por Eric Johnston en LucasArts alrededor de 1992, al portar los juegos del motor SCUMM de la IBM PC (que funcionaba a 320 × 200 × 256 colores) a las primeras computadoras Macintosh a color, que funcionaban a aproximadamente el doble de esa resolución. [ 5 ] El algoritmo funciona de la siguiente manera, expandiendo P en 4 nuevos píxeles en función del entorno de P:

El algoritmo EPX expande el píxel P en cuatro píxeles nuevos.

1=P; 2=P; 3=P; 4=P; SI C==A => 1=A SI A==B => 2=B SI D==C => 3=C SI B==D => 4=D Si de A, B, C, D, tres o más son idénticos: 1=2=3=4=P

Las implementaciones posteriores de este mismo algoritmo (como AdvMAME2× y Scale2×, desarrolladas alrededor de 2001) son ligeramente más eficientes, pero funcionalmente idénticas:

1=P; 2=P; 3=P; 4=P; SI C==A Y C!=D Y A!=B => 1=A SI A==B Y A!=C Y B!=D => 2=B SI D==C Y D!=B Y C!=A => 3=C SI B==D Y B!=A Y D!=C => 4=D

AdvMAME2× está disponible en DOSBox a través de la opción scaler=advmame2xdosbox.conf .

El algoritmo AdvMAME4×/Scale4× es simplemente EPX aplicado dos veces para obtener una resolución 4×.

Scale3×/AdvMAME3× y ScaleFX

EPX se puede usar para escalar fuentes de mapa de bits. De arriba abajo: a) tamaño de fuente original; b) escalado de vecino más cercano 2×; c) escalado EPX 2×; d) escalado de vecino más cercano 3×; e) escalado EPX 3×.

El algoritmo AdvMAME3×/Scale3× (disponible en DOSBox mediante la opción scaler=advmame3xdosbox.conf ) puede considerarse una generalización de EPX al caso 3×. Los píxeles de las esquinas se calculan de forma idéntica a EPX.

AdvMAME3x/Scale3x escala el píxel E en 9 nuevos píxeles.

1=E; 2=E; 3=E; 4=E; 5=E; 6=E; 7=E; 8=E; 9=E; SI D==B Y D!=H Y B!=F => 1=D SI (D==B Y D!=H Y B!=F Y E!=C) O (B==F Y B!=D Y F!=H Y E!=A) => 2=B SI B==F Y B!=D Y F!=H => 3=F SI (H==D Y H!=F Y D!=B Y E!=A) O (D==B Y D!=H Y B!=F Y E!=G) => 4=D 5=E SI (B==F Y B!=D Y F!=H Y E!=I) O (F==H Y F!=B Y H!=D Y E!=C) => 6=F SI H==D Y H!=F Y D!=B => 7=D SI (F==H Y F!=B Y H!=D Y E!=G) O (H==D Y H!=F Y D!=B Y E!=I) => 8=H SI F==H Y F!=B Y H!=D => 9=F

También existe una variante mejorada de Scale3× llamada ScaleFX, desarrollada por Sp00kyFox, y una versión combinada con Reverse-AA llamada ScaleFX-Hybrid. [ 6 ] [ 7 ] [ 8 ]

Águila

Eagle funciona de la siguiente manera: por cada píxel de entrada, generaremos 4 píxeles de salida. Primero, asignamos a los 4 el color del píxel que estamos escalando actualmente (como vecino más cercano). A continuación, observamos los tres píxeles situados arriba, a la izquierda y en diagonal arriba a la izquierda: si los tres tienen el mismo color, asignamos ese color al píxel superior izquierdo de nuestro cuadrado de salida, en lugar del color del vecino más cercano. Repetimos el proceso para los cuatro píxeles y luego pasamos al siguiente. [ 9 ]

Supongamos una matriz de entrada de 3 × 3 píxeles, donde el píxel central es el que se va a escalar, y una matriz de salida de 2 × 2 píxeles (es decir, el píxel escalado).

primero: |Entonces . . . --\ CC |STU --\ 1 2 . C . --/ CC |VCW --/ 3 4 . . . |XYZ | SI V==S==T => 1=S | SI T==U==W => 2=U | SI V==X==Y => 3=X | SI W==Z==Y => 4=Z

Por lo tanto, si tenemos un solo píxel negro sobre un fondo blanco, este desaparecerá. Esto es un error del algoritmo Eagle, pero otros algoritmos como EPX, 2xSaI y HQ2x lo solucionan.

2×SaI

2×SaI , acrónimo de 2× Scale and Interpolation engine (motor de escalado e interpolación doble), se inspiró en Eagle. Fue diseñado por Derek Liauw Kie Fa, también conocido como Kreed, principalmente para su uso en emuladores de consolas y ordenadores , y ha mantenido una popularidad considerable en este nicho. Muchos de los emuladores más populares, como ZSNES y VisualBoyAdvance , ofrecen este algoritmo de escalado como una característica. Existen varias versiones ligeramente diferentes del algoritmo de escalado, a las que se suele denominar Super 2×SaI y Super Eagle .

La matriz de píxeles circundantes que Super2xSaI utiliza para escalar un solo píxel.

La familia 2xSaI funciona en una matriz de píxeles de 4 × 4 donde el píxel marcado con la letra A a continuación se escala:

IEFJ GABK --\ WX HCDL --/ YZ MNOP

Para píxeles de 16 bits, se utilizan máscaras de píxeles que cambian según si el formato de píxel de 16 bits es 565 o 555. Las constantes colorMask, lowPixelMask, qColorMask, qLowPixelMask, redBlueMask, y greenMaskson máscaras de 16 bits. Los 8 bits inferiores son idénticos en ambos formatos de píxeles.

Se describen dos funciones de interpolación:

INTERPOLAR(uint32 A, UINT32 B). -- punto medio lineal de A y B Si (A == B) devolver A; devolver ( ((A & colorMask) >> 1) + ((B & colorMask) >> 1) + (A y B y lowPixelMask) ); Q_INTERPOLATE(uint32 A, uint32 B, uint32 C, uint32 D) -- interpolación bilineal; promedio de A, B, C y D x = ((A & qColorMask) >> 2) + ((B & qColorMask) >> 2) + ((C & qColorMask) >> 2) + ((D & qColorMask) >> 2); y = (A & qLowPixelMask) + (B y qLowPixelMask) + (C y qLowPixelMask) + (D y qLowPixelMask); y = (y >> 2) & qLowPixelMask; devolver x + y;

El algoritmo comprueba si A, B, C y D coinciden en diagonal, de modo que A==Dy B!=C, o viceversa, o si ambos son diagonales o si no hay coincidencia diagonal. Dentro de estos, comprueba si hay tres o cuatro píxeles idénticos. En función de estas condiciones, el algoritmo decide si utilizar uno de A, B, C o D, o una interpolación entre solo estos cuatro, para cada píxel de salida. El escalador arbitrario 2xSaI puede ampliar cualquier imagen a cualquier resolución y utiliza filtrado bilineal para interpolar los píxeles.

Dado que Kreed publicó [ 10 ] el código fuente bajo la Licencia Pública General de GNU , este está disponible gratuitamente para cualquiera que desee utilizarlo en un proyecto publicado bajo dicha licencia. Los desarrolladores que deseen usarlo en un proyecto que no esté bajo la GPL deberán reescribir el algoritmo sin utilizar el código existente de Kreed.

Está disponible en DOSBox mediante scaler=2xsaiuna opción.

familia hq n x

Los algoritmos hq2x, hq3x y hq4x de Maxim Stepin se utilizan para factores de escala de 2:1, 3:1 y 4:1, respectivamente. Cada uno funciona comparando el valor de color de cada píxel con el de sus ocho vecinos inmediatos, marcando a los vecinos como cercanos o lejanos, y utilizando una tabla de búsqueda pregenerada para encontrar la proporción adecuada de los valores de los píxeles de entrada para cada uno de los 4, 9 o 16 píxeles de salida correspondientes. La familia hq3x suaviza perfectamente cualquier línea diagonal cuya pendiente sea ±0,5, ±1 o ±2 y que no tenga suavizado de bordes en la entrada; una con cualquier otra pendiente alternará entre dos pendientes en la salida. También suaviza curvas muy cerradas. A diferencia de 2xSaI, aplica suavizado de bordes a la salida. [ 11 ] [ 8 ]

hq n x fue creado inicialmente para el emulador de Super NES ZSNES . El autor de bsnes ha publicado una implementación de hq2x que optimiza el uso del espacio y la pone a disposición del público. [ 12 ] Existe una versión para shaders , con una calidad comparable a las primeras versiones de xBR. [ 13 ] Antes de esta versión, un shader llamado "scalehq" se confundía a menudo con hqx. [ 14 ]

Familia xBR

Hay 6 filtros en esta familia: xBR , xBRZ , xBR-Hybrid , Super xBR , xBR+3D y Super xBR+3D .

xBR ("escalar por reglas"), creado por Hyllian, funciona de manera muy similar a HQx (basado en el reconocimiento de patrones) y generaría el mismo resultado que HQx cuando se le da el patrón anterior. [ 15 ] Sin embargo, va más allá que HQx al usar un conjunto de reglas de interpolación de 2 etapas , que manejan mejor patrones más complejos como líneas y curvas suavizadas . Las texturas de fondo escaladas mantienen las características nítidas de la imagen original, en lugar de volverse borrosas como tiende a hacer HQx (a menudo ScaleHQ en la práctica). Las versiones más recientes de xBR son de múltiples pasadas y pueden preservar mejor los pequeños detalles. También hay una versión de xBR combinada con el sombreador Reverse-AA llamada xBR-Hybrid. [ 16 ] xBR+3D es una versión con una máscara 3D que solo filtra elementos 2D.

xBRZ de Zenju es una versión modificada de xBR. Está implementado desde cero como un filtro basado en CPU en C++ . [ 17 ] Utiliza la misma idea básica que el reconocimiento de patrones e interpolación de xBR pero con un conjunto de reglas diferente diseñado para preservar detalles finos de la imagen tan pequeños como unos pocos píxeles. Esto lo hace útil para escalar los detalles en rostros, y en particular en los ojos. xBRZ está optimizado para CPU multinúcleo y arquitecturas de 64 bits y muestra un rendimiento entre un 40 y un 60 % mejor que HQx incluso cuando se ejecuta en un solo núcleo de CPU. Admite escalado de imágenes con un canal alfa y escalado por factores enteros de 2× a 6×.

Super xBR [ 18 ] [ 19 ] es un algoritmo desarrollado por Hyllian en 2015. Utiliza algunas combinaciones de filtros lineales conocidos junto con reglas de detección de bordes xBR de forma no lineal. Funciona en dos pasadas y solo puede escalar una imagen por dos (o múltiplos de dos volviéndola a aplicar) y también tiene un filtro anti-ringing. Super xBR+3D es una versión con una máscara 3D que solo filtra elementos 2D. También hay una versión de Super xBR reescrita en C/C++. [ 20 ] [ 8 ]

RotSprite

Izquierda: Imagen original de pixel art. Centro: Imagen rotada mediante el algoritmo de rotación del vecino más cercano. Derecha: Imagen rotada mediante el algoritmo RotSprite.

RotSprite es un algoritmo de escalado y rotación para sprites desarrollado por Xenowhirl. Produce muchos menos artefactos que los algoritmos de rotación de vecinos más cercanos y, al igual que EPX, no introduce nuevos colores en la imagen (a diferencia de la mayoría de los sistemas de interpolación). [ 21 ]

El algoritmo primero escala la imagen a 8 veces su tamaño original con un algoritmo Scale2× modificado que trata los píxeles similares (en lugar de idénticos) como coincidencias. Luego (opcionalmente) calcula qué desplazamiento de rotación usar, dando preferencia a los puntos muestreados que no son píxeles de borde. A continuación, se crea la imagen rotada con un algoritmo de escalado y rotación del vecino más cercano que reduce simultáneamente la imagen grande a su tamaño original y la rota. Finalmente, los detalles de un solo píxel que se pasaron por alto se restauran (opcionalmente) si el píxel correspondiente en la imagen de origen es diferente y el píxel de destino tiene tres vecinos idénticos. [ 22 ]

Sprite de descomposición rápida

Fast RotSprite es un algoritmo de rotación rápida para pixel art desarrollado por Oleg Mekekechko para la aplicación Pixel Studio. Se basa en RotSprite, pero ofrece un mejor rendimiento con una ligera pérdida de calidad. Puede procesar imágenes de mayor tamaño en tiempo real. En lugar de un aumento de 8×, Fast RotSprite utiliza un único aumento de 3×. A continuación, simplemente rota todos los píxeles con coordenadas redondeadas. Finalmente, realiza una reducción de 3× sin introducir nuevos colores. Dado que todas las operaciones en cada paso son independientes, pueden ejecutarse en paralelo para aumentar considerablemente el rendimiento.

Kopf–Lischinski

El algoritmo de Kopf-Lischinski es una forma novedosa de extraer gráficos vectoriales independientes de la resolución a partir de pixel art, descrito en el artículo de 2011 "Depixelizing Pixel Art". [ 23 ] Existe una implementación en Python. [ 24 ]

El algoritmo se ha adaptado a las GPU y se ha optimizado para la renderización en tiempo real. El código fuente de esta variante está disponible. [ 25 ]

Interpolación dirigida por bordes (EDI)

La interpolación dirigida por bordes (EDI) describe técnicas de escalado que utilizan muestreo estadístico para garantizar la calidad de una imagen a medida que se escala. [ 26 ] [ 27 ] Hubo varios métodos anteriores que implicaban la detección de bordes para generar pesos de mezcla para la interpolación lineal o clasificar píxeles según sus condiciones vecinas y utilizar diferentes esquemas de interpolación isotrópica basados ​​en la clasificación. Cada enfoque de interpolación se reduce a promedios ponderados de píxeles vecinos. El objetivo es encontrar los pesos óptimos. La interpolación bilineal establece todos los pesos como iguales. Los métodos de interpolación de orden superior, como la interpolación bicúbica o sinc, consideran un número mayor de vecinos que solo los adyacentes.

NEDI

NEDI (New Edge-Directed Interpolation) calcula las covarianzas locales en la imagen original y las utiliza para adaptar la interpolación a alta resolución. Es el filtro prototipo de esta familia. [ 28 ]

EDIUpsizer

EDIUpsizer [ 29 ] es un filtro de remuestreo que redimensiona una imagen por un factor de dos tanto horizontal como verticalmente usando NEDI (nueva interpolación dirigida por bordes). [ 28 ] EDIUpsizer también usa algunas modificaciones a NEDI básico para evitar muchos de los artefactos que NEDI crea en áreas detalladas. Estas incluyen prueba de número de condición y tamaño de ventana adaptativo, [ 30 ] así como restricciones de límite. Todas las modificaciones y restricciones a NEDI son opcionales (se pueden activar y desactivar) y son configurables por el usuario. Este filtro es bastante lento.

FastEDIUpsizer

FastEDIUpsizer es una versión simplificada de EDIUpsizer, optimizada para la velocidad. Utiliza una ventana constante de 8 × 8 píxeles, solo realiza NEDI en el plano de luminancia y solo emplea interpolación bicúbica o bilineal como método de interpolación de reserva.

eedi3

Otro filtro de interpolación dirigido a los bordes. Funciona minimizando una función de coste que involucra a cada píxel de una línea de exploración. Es lento.

EEDI2

EEDI2 redimensiona una imagen al doble en la dirección vertical copiando la imagen existente a 2⋅y(n) e interpolando el campo faltante. Está diseñado para la interpolación dirigida por bordes para el desentrelazado (es decir, no está pensado para redimensionar una imagen normal, aunque también puede hacerlo). EEDI2 se puede usar con TDeint y TIVTC; consulte el enlace de discusión para obtener más información sobre cómo hacerlo. [ 31 ]

SuperRes

Los sombreadores SuperRes [ 32 ] utilizan un método de escalado diferente que puede usarse en combinación con NEDI (o cualquier otro algoritmo de escalado). El método es explicado en detalle por su creador, Shiandow, en una publicación del foro de Doom9 en 2014. [ 33 ] Este método suele ofrecer mejores resultados que usar solo NEDI, y rivaliza con los de NNEDI3. Ahora también están disponibles como script de renderizado MPDN.

NNEDI

NNEDI es una familia de desentrelazadores intra-campo que también se pueden usar para ampliar imágenes por potencias de dos. Cuando se usa como desentrelazador, toma un fotograma , descarta un campo y luego interpola los píxeles faltantes usando solo la información del campo restante. Hasta ahora existen tres generaciones principales de NNEDI.

NNEDI, la versión original, funciona con entrada YUY2 y YV12 . [ 34 ] NNEDI2 añadió soporte para RGB24 y una función especial nnedi2_rpow2para escalado. NNEDI3 extiende NNEDI2 con una red neuronal predictora . Tanto el tamaño de la red como el vecindario que examina pueden ajustarse para lograr un equilibrio entre velocidad y calidad: [ 35 ]

Esta es una opción de calidad versus velocidad; sin embargo, las diferencias suelen ser pequeñas entre el número de neuronas para un factor de redimensionamiento específico, aunque la diferencia de rendimiento entre el número de neuronas aumenta al cuadruplicar el tamaño de la imagen. Si solo planea duplicar la resolución, no verá grandes diferencias entre 16 y 256 neuronas. Todavía existe una diferencia perceptible entre las opciones más alta y más baja, pero no de órdenes de magnitud. [ 36 ]

Referencias

  1. ↑ "Pixel Scalers" . Archivado del original el 2 de marzo de 2016. Consultado el 19 de febrero de 2016 .
  2. ↑ "Hoja de datos Mullard SAA5050" (PDF) . Archivado del original (PDF) el 19 de junio de 2017. Consultado el 12 de noviembre de 2018 .
  3. ↑ "SAA5050 Smoothing código fuente del proyecto MAME" . GitHub . 6 de noviembre de 2022. Archivado del original el 13 de agosto de 2023. Recuperado el 12 de noviembre de 2018 .
  4. ↑ "Publicación en el foro que muestra la página de prueba de referencia de Teletexto en el chip SAA5050" . Archivado del original el 13/11/2018 . Consultado el 12/11/2018 .
  5. ↑ Thomas, Kas (1999). "Estrategias rápidas de Blit: Guía para programadores de Mac" . MacTech . Archivado del original el 24 de junio de 2012. Consultado el 1 de junio de 2009 .
  6. ↑ libretro. "common-shaders/scalenx en master · libretro/common-shaders · GitHub" . GitHub . Archivado del original el 22 de diciembre de 2020. Recuperado el 19 de febrero de 2016 .
  7. ↑ "ScaleNx - Eliminación de artefactos y mejora del algoritmo [ Archivo ] " . Archivado del original el 27 de mayo de 2016. Consultado el 27 de mayo de 2016 .
  8. 1 2 3 "PixelArt Scalers" . GitHub . 30 de septiembre de 2022. Archivado del original el 12 de octubre de 2022. Recuperado el 12 de octubre de 2022 .
  9. ↑ "Águila (idea)" . Everything2 . 18 de enero de 2007. Archivado del original el 9 de noviembre de 2012. Consultado el 9 de agosto de 2008 .
  10. ↑ "Página principal de Kreed: 2xSaI" . Archivado del original el 25 de febrero de 2021. Consultado el 25 de abril de 2020 .
  11. ↑ Stepin, Maxim. "Filtro de aumento hq3x" . Archivado del original el 3 de julio de 2007. Consultado el 3 de julio de 2007 .
  12. ↑ Byuu. Anuncio de lanzamiento Archivado el 30/09/2011 en Wayback Machine Consultado el 14/08/2011.
  13. ↑ libretro. "common-shaders/hqx en master · libretro/common-shaders · GitHub" . GitHub . Archivado del original el 6 de abril de 2019. Recuperado el 19 de febrero de 2016 .
  14. ↑ Hunter K. (20 de junio de 2014). "Pantalones sucios: Un blog de informática" . Archivado del original el 4 de marzo de 2016. Recuperado el 19 de febrero de 2016 .
  15. ↑ "Tutorial del algoritmo xBR" . 18 de septiembre de 2012. Archivado del original el 19 de agosto de 2018. Consultado el 19 de febrero de 2016 .
  16. ↑ libretro. "common-shaders/xbr en master · libretro/common-shaders · GitHub" . GitHub . Archivado del original el 15 de enero de 2017. Recuperado el 19 de febrero de 2016 .
  17. ↑ zenju. "xBRZ" . SourceForge . Archivado del original el 3 de febrero de 2016. Consultado el 19 de febrero de 2016 .
  18. ↑ "Super-xBR.pdf" . Google Docs . Archivado del original el 12 de marzo de 2016. Consultado el 19 de febrero de 2016 .
  19. ↑ libretro. "common-shaders/xbr/shaders/super-xbr en master · libretro/common-shaders · GitHub" . GitHub . Archivado del original el 8 de junio de 2016. Recuperado el 19 de febrero de 2016 .
  20. ↑ "Super-XBR adaptado a C/C++ (solo versión de sombreado rápido)" . 6 de marzo de 2016. Archivado del original el 30 de junio de 2016. Consultado el 3 de julio de 2016 .
  21. ↑ "RotSprite" . Sonic Retro . Archivado del original el 19 de febrero de 2016. Consultado el 19 de febrero de 2016 .
  22. ↑ "Utilidad de rotación de sprites" . Foro de mensajes retro de Sonic y Sega . Archivado del original el 3 de marzo de 2016. Consultado el 19 de febrero de 2016 .
  23. ↑ Johannes Kopf y Dani Lischinski (2011). "Despixelando el pixel art" . ACM Transactions on Graphics . 30 (4). SIGGRAPH : 99:1–99:8. doi : 10.1145/2010324.1964994 . Archivado del original el 13 de mayo de 2016. Recuperado el 22 de mayo de 2016 .
  24. ↑ Vemula, Anirudh; Yeddu, Vamsidhar (29 de abril de 2019). "Pixel-Art: Implementamos el famoso artículo "Depixelizing Pixel Art" de Kopf y Lischinski" . GitHub . Archivado del original el 11 de junio de 2018. Recuperado el 7 de mayo de 2019 .
  25. ↑ Kreuzer, Felix; Kopf, Johannes; Wimmer, Michael (2015). "Despixelización de pixel art en tiempo real" . Actas del 19.º Simposio sobre Gráficos y Juegos 3D Interactivos . ACM. pág. 130. doi : 10.1145/2699276.2721395 . ISBN  9781450333924. S2CID 7592555 . Archivado del original el 07-05-2019 . Recuperado el 07-05-2019 . 
  26. ↑ "Interpolación dirigida por bordes" . chiranjivi.tripod.com . Archivado del original el 25 de febrero de 2016. Consultado el 7 de mayo de 2019 .
  27. ↑ "Implementación de sombreado del algoritmo NEDI - Foro de Doom9" . forum.doom9.org . Archivado del original el 13 de mayo de 2022. Consultado el 7 de mayo de 2019 .
  28. 1 2 Li, Xin (26-11-2010). "Nueva interpolación dirigida por bordes" (PDF) . Archivado del original (PDF) el 26-11-2010 . Recuperado el 07-05-2019 .
  29. ↑ Filtros Avisynth de tritical
  30. ↑ "Copia archivada" (PDF) . www.cs.ucdavis.edu . Archivado del original (PDF) el 21 de diciembre de 2004. Consultado el 12 de enero de 2022 .{{cite web}}: CS1 mantenimiento: copia archivada como título ( enlace )
  31. ↑ "TDeint y TIVTC - Página 21 - Foro de Doom9" . Archivado del original el 2 de marzo de 2016. Consultado el 19 de febrero de 2016 .
  32. ↑ "nnedi3 vs NeuronDoubler - Foro de Doom9" . Archivado del original el 2 de marzo de 2016. Consultado el 19 de febrero de 2016 .
  33. ↑ "Implementación de sombreado del algoritmo NEDI - Página 6 - Foro de Doom9" . Archivado del original el 2 de marzo de 2016. Consultado el 19 de febrero de 2016 .
  34. ↑ "NNEDI - filtro de desentrelazado intra-campo - Foro de Doom9" . Archivado del original el 2 de marzo de 2016. Consultado el 19 de febrero de 2016 .
  35. ↑ "Nnedi3" . AviSynth . Archivado del original el 7 de mayo de 2019. Consultado el 7 de mayo de 2019 .
  36. ↑ tritical (30-04-2019), nnedi3 - Readme.txt , archivado del original el 17-04-2019 , recuperado el 07-05-2019

Véase también

  • pixelscalers : implementaciones en C++ de los algoritmos ScaleNx, hqNx y superXBR en una herramienta independiente.
  • ScaleNx en Python : implementación en Python 3 puro de módulos de Scale2x, Scale3x, Scale2xSFX y Scale3xSFX, optimizada para FIR. También disponible la aplicación principal de ScaleNx para el reescalado de imágenes PNG y PNM, tanto individuales como por lotes .