mmiiqquueell escribió:maxpower91 escribió:sanamarcar escribió:Pero las cpu actuales no pueden hacer integer scaling ... no se pero en emuladores siempre se pudo. Yo es que flipo se venda esto como una novedad xD. Y mediante cuda deberia poderse... En fin xD
No pueden porque, según Nvidia, el escalado de Turing está implementado a nivel de hardware, y todos sabemos que se necesita la potencia de cómputo de un superordenador, IA y uranio-235 para calcular que debemos multiplicar un pixel por cuatro (2x), nueve (3x) o dieciséis (4x) pixeles si queremos un escalado 1:1 o
pixel perfect. De risa.
Y digo yo... ¿no seria más fácil desactivar cualquier filtrado de escalado y que se muestren los sprites tal cual el original? es que no entiendo esta gilipollada del escalado. Estoy "intentando" hacer el Sonic en JavaScript (el de la master system que es ultra básico en funciones) y el navegador hace ese filtrado pero con solo decirle por CSS que no haga el filtrado ademas de ahorrar uso de RAM y CPU puedo escalar tanto como quiera la imagen y se ve pixel perfecto. ¿No seria eso más fácil y simple? No estoy al loro así que normal que lo comente.
Claro, es que el Integer Scaling no es un filtrado, sino un escalado. Simplemente multiplica/clona un pixel en cuatro, por ejemplo, y los coloca en pantalla formando un cuadrado, de manera que, aunque sean cuatro pixeles, parezcan uno muy grande. Así amplias las imágenes sin deformarlas de ninguna manera. Aquí te dejo una imagen que, además de explicarlo, supongo que ilustra bastante lo que estás haciendo tú cuando utilizas el escalado de CSS:
El filtrado solo tiene sentido cuando no puedes hacer escalados de forma exacta. Por ejemplo, tenemos un monitor de 8x4 pixeles de resolución y una imagen de 4x2 pixeles de color rojo. Si mostramos la imagen a tamaño real, centrada en pantalla, la veremos perfecta, con un marco negro de 1 pixel por arriba y abajo y de 2 pixeles en cada lateral, pero respetando su proporción rectangular 2:1. Si amplias la imagen al doble de su tamaño (8x2) verás que el ejemplo de la imagen anterior se cumple a la perfección, ya que clonamos cada pixel en vertical y horizontal, y cuando lo mostramos a tamaño real sigue respetando la proporción 2:1 y el color rojo, sólo que ahora ya no tenemos bordes negros porque el nuevo tamaño de la imagen se corresponde con la resolución del monitor. Sin embargo, si aumentamos la imagen a 5x3 pixeles y luego la mostramos a tamaño real, centrada, tenemos un problema, ya que para ampliar a ese tamaño tenemos que multiplicar cada pixel por uno y medio. El software lo hará, porque aquí hablamos de matemática pura, el problema es que el software no ha tenido en cuenta que nuestro monitor de 8x4 no puede iluminar un pixel sólo a la mitad de su superficie (no puede mostrarse rojo y negro a la vez), de modo que da igual si lo dejamos en rojo o en negro, la proporción 2:1 de la imagen se va a deformar cuando la mostremos centrada en pantalla, porque tendrá que "añadir" o "quitar" pixeles de la imagen (lo pongo entre comillas porque ni quita, ni pone, pero es lo que ves cuando miras al monitor). Ahí es donde entran los filtrados por interpolación para decidir qué hacer en estos casos, lo cual variará en función del tipo de filtrado que utilicemos. Los filtrados parten de la base de que la imagen está deformada, pero quizá podamos "disimularlo un poco". ¿Cómo?, pues llevando la decisión de si dejar el pixel en rojo o negro un paso más allá: lo que hacen estos filtrados es coger una muestra del color (por eso se llaman filtrados) de los pixeles contiguos a aquel que queremos iluminar (en este caso rojo y negro) y decide utilizar un color que ni es negro, ni es rojo, es un color intermedio (por eso hablamos de interpolación). Esto puede sonar ridículo cuando hablamos de estas resoluciones, pero cuando tenemos millones de pixeles de muy pequeño tamaño y muchos más colores pues bueno, si que ayuda a disimular, pero muchas veces nos dará la sensación de que la imagen ampliada se ve borrosa.
El problema de los videojuegos clásicos o algunos "pixel art" modernos es que nuestros monitores tendrán millones de pixeles, pero el juego no, por lo tanto respetar que cada pixel original siga siendo cuadrado después de un escalado es más difícil de lo que parece (no siempre es posible que cada pixel original esté formado por cuatro o nueve cuando escalamos, hablamos de muchos pixeles y a veces nos faltarán o sobrarán, dependiendo de la resolución del monitor, y al final volvemos a los odiados decimales con los que estos no pueden trabajar). El caso es que no todos los filtrados trabajan igual y a veces se pueden hacer cosas como esta:
Esto es lo que me refería antes cuando hablaba de técnicas
nearest neighbor que no son escalados completos (Integer Scaling) pero cuyo resultado no es borroso como el de otros filtrados. El mayor problema del Integer Scaling es que solo puedes multiplicar por números enteros, lo que casi siempre se traduce en bordes negros por la diferencia de proporción (o ratio) si quieres
pixel perfect. Esto que se ve en la imagen es un filtro que trabaja de manera similar a otros, sólo que aquí no metemos colores que no había en la imagen original, sino que el color "nuevo" siempre será igual al de uno de los pixeles adyacentes. El problema es que, como vemos, el pixel no es cuadrado, pero si no queremos bordes negros o en según qué casos puede dar resultados bastante decentes (entre más se parezca la proporción original del juego a la del monitor, aunque no sea exacta, mejor).
pirtugan escribió:@maxpower91, es un problema de arquitectura. Las GPU son paralelas, pero para aprovechar el paralelismo, los datos han de estar correctamente ordenados. Y muchas veces la ordenación de los datos es más costosa que lo que ahorras en el paralelismo.
Una aclaración, los pixeles escalados no se los inventa/calcula en el escalado entero como hace por ejemplo en una interpolación lineal, simplemente se clonan, ejemplo obvio:
Escalado x1 = 1234
Escalado x2 = 11223344
Escalado x4 = 1111222233334444
Luego si conoces a la perfección la arquitectura y modificas algún parámetro ligeramente, puedes hacer esta cosa en paralelo que en términos de CPU serían "un porrón" (término muy técnico) de accesos a memoria y por tanto perdida de tiempo.
PD.- Conozco a un profe que si me pilla comparando una interpolación lineal con un escalado, me suspendería su asignatura de tratamiento digital de señal por mezclar peras con manzanas.
Gracias por la aclaración. Es que a nivel de hardware reconozco que no tengo ni idea (todo lo que sé de escalados es por ser fotógrafo aficionado, no por informática), pero bueno, sigo pensando que un escalado entero siempre será más sencillo que un filtrado, pues no hay que interpolar, y los filtrados es algo que vemos en multitud de ocasiones (sobretodo en emuladores). De hecho la ampliación de Windows para accesibilidad, si mal no recuerdo, era o es un escalado perfecto, por ejemplo. Entiendo que no sea sencillo de implementar por hardware para arquitecturas anteriores a Turing, pero al menos podían buscar la manera de hacerlo por software, como se ha hecho hasta ahora, aunque sea a costa de penalizar rendimiento y que la implementación por hardware se la guarden como exclusiva para Turing (algo similar a lo que han hecho con el ray-tracing).
Sí, se qué en un escalado con número enteros no se inventan pixeles, pero me refería a que quizá Nvidia estaba hablando de otra técnica similar a la que muestro al compañero. Sé que no tendría sentido, porque si hablamos de Integer Scaling no habría que interpolar, pero bueno, es que no me explico por qué Nvidia ha vendido esto a bombo y platillo cuando es algo bastante sencillo, al menos en su funcionamiento. Pero bueno, por lo que he visto hablamos de Integer Scaling puro y duro.
![[+risas]](/images/smilies/nuevos/risa_ani3.gif "más risas")
![[fumando]](/images/smilies/nuevos/fumando.gif "fumando")
. 
![[borracho]](/images/smilies/nuevos/borracho_ani1.gif "borracho")
