Siempre es buena cosa hurgar por los ejemplos de código, allí siempre se encuentra uno "joyitas" inesperadas, y como mínimo puede entender mejor "cómo se supone que se hacen las cosas". Aunque esta implementación en concreto tiene algún defectillo importante, que ya comentaré...

Empezando por el principio, la función se basa en el buen uso del método blit, que puede emplearse con cualquier par de imágenes (es decir, puedes "blitear" cualquier imagen sobre cualquier otra, sin que se necesite que una de ambas sea screen; de hecho, screen es una "imagen especial", una Image con algún método añadido). Utiliza los parámetros "poco conocidos" del método blit, a saber: no es necesario blitear las imágenes enteras; puedes blitear sólo un área rectangular (o cuadrada) de un ancho y alto determinado, que empiece en unas coordenadas dadas de la imagen origen.

Aparte, algo que hace muy bien es que en realidad no modifica (escala) la imagen, sino que te devuelve una imagen nueva, que es la "vieja" cambiada de tamaño. Esto va bien porque, si lo que quieres es modificar una imagen y no crear una nueva, tienes el recurso de hacer miImagen=scaleImage(nuevoAncho, nuevoAlto, miImagen), y ya modificas la imagen, sin crear una nueva (en principio... si no fuera por uno de los "fallitos" que digo).

function scaleImage(newX, newY, theImage): Aquí se definen los tres parámetros o argumentos que necesitará la función para trabajar: el nuevo ancho, el nuevo alto, y la imagen que escalaremos.

resizedImage = Image.createEmpty(newX, newY): Se crea la nueva imagen que se devolverá... y primer fallito. El problema, aquí, es que la variable resizedImage ("imagenEscalada" o "cambiada de tamaño") es de ámbito global, porque lo que no se declara como local, en Lua es global. Que sea de ámbito global significa, entre otras cosas, que esta imagen nueva seguirá usando espacio aun cuando en realidad no la utilicemos, porque la variable global resizedImage sigue apuntando a esta imagen; y si en Lua hay un puntero que apunta a un valor (y una variable es exactamente eso), el valor se mantiene y sigue ocupando espacio, aun cuando se limpie la memoria con collectgarbage() o su variante System.memclean(): para Lua, esa imagen que "no utilizamos", sí que se utiliza (y se seguirá utilizando hasta que se vuelva a llamar a la función, y resizedImage cambie de valor). Para decirle a Lua que no utilizamos un valor (imagen, cadena, número, etc.), tenemos que eliminar todos sus punteros; las variables locales se eliminan automáticamente al terminar la función (pero el valor que es la imagen redimensionada se mantendrá, porque la habremos pasado a otra variable o lugar, así que habrá otro puntero. Sí, ya sé que suena un poco "raro" esto de que "una imagen es un valor" :)... las máquinas son así).

Sigamos: for x = 1, newX do for y = 1, newY do : Los junto aquí porque "van juntos". Estos dos bucles que empiezan sirven para recorrer, píxel a píxel, la nueva imagen; después (en la siguiente línea) se mirará qué es lo que tiene que ir en ese píxel, y se pondrá (con blit, que es más rápido que hacerlo con el método Image:pixel). Y aquí hay dos fallitos más: uno, que sigue sin declarar como locales las variables x e y (y ojo, que son nombres que pueden usarse mucho... si usabas x o y antes de llamar a la función, ¡te cambiará su valor!). El otro es más sutil, pero causaría un descuadre en el escalado: resulta que las coordenadas del primer píxel no son (1, 1), sino (0,0), así que habría que empezar por 0, no 1; y el último píxel de una imagen de, pongamos, 128x128 no es el 128, 128, ¡sino el 127, 127!. Así que para funcionar perfectamente, tendría que ser algo tipo for x=0, newX-1 for y=0, newY-1...

resizedImage:blit(x,y , theImage, ...: Empieza aquí la función de blit, que nos servirá para poner en las coordenadas x, y de resizedImage, la nueva imagen, "lo que corresponda" de la imagen origen. Los siguientes parámetros de blit buscan a qué coordenadas de theImage, la imagen origen a escalar, corresponden las coordenadas nuevas de la nueva imagen, y seleccionan de la imagen origen un cuadrado de 1x1 píxeles (recordemos que estamos pintando la nueva imagen píxel a píxel).

...math.floor(x*(theImage:width()/newX)), math.floor(y*(theImage:height()/newY)),1,1): Vale, aquí la parte difícil, supongo, es lo de "math.floor" y las divisiones, queda un tanto oscuro por qué se hacen. Empecemos por (theImage:width()/newX) y (theImage:height()/newY). Esto, lo que hace, es encontrar la proporción relativa entre ambas imágenes, y sirve para (empezar a) encontrar a qué punto de la imagen origen corresponde cada punto (par de coordenadas) de la imagen destino. Es otro de los fallitos: la proporción entre ambas imágenes no cambia, así que bastaría con calcularla una sola vez. Pero aquí la recalcula con cada bucle... lo que significa que, por ejemplo, para una imagen de 128x128, ¡hace 16.383 multiplicaciones innecesarias! Esto ralentiza soberanamente la función. El math.floor redondea hacia abajo: se redondea porque los píxeles son enteros, no hay un píxel en las coordenadas (0.5, 0.5): ese corresponde al (0,0).

Esta parte de las proporciones es sin duda la más abstrusa y difícil. Para intentar aclarar dudas, recurro a una técnica usada por dibujantes para escalar imágenes, y que también encontrabas en los libros y revistas de pasatiempos de hace 20 o 30 años, cuando yo era un chaval (snif...): la técnica de la cuadrícula. Coges la imagen origen, y le plantas encima una cuadrícula. Luego dibujas una cuadrícula mayor, con el mismo número de casillas, y rehaces el dibujo proporcionalmente, viendo dónde caen las líneas. Si no te ha quedado aún lo bastante claro, prueba esto de la cuadrícula con lápiz y papel, y seguro que algo más te aclara.

El resto de la función es bastante directo: con  end end return resizedImage end se marca el fin de ambos bucles, se devuelve la imagen final y se cierra la función.

Entonces, recapitulando, para mejorarla, tendríamos que:

• Pasar a locales las variables globales.
• Calcular las proporciones una sola vez, y emplearlas en el bucle

Una vez hecho, nos quedaría algo más o menos así:

function EscalaImagen(nuevoAncho, nuevoAlto, imagenOrigen) 
local xActual, yActual, pixelXFin, pixelYFin, propAncho, propAlto=0, 0, nuevoAncho-1, nuevoAlto-1, imagenOrigen:width()/nuevoAncho, imagenOrigen:height()/nuevoAlto;
local imagenFinal=Image.createEmpty(nuevoAncho, nuevoAlto); 
for xActual = 0, pixelXFin do for yActual=0, pixelYFin do 
imagenFinal:blit(xActual, yActual, imagenOrigen, math.floor(xActual*propAncho), math.floor(yActual*propAlto), 1, 1);
end; end; 
return imagenFinal; end

Así nos queda todo de lo más rápido posible con este método, y bien "embolsado" para que cuando pase el basurero lo recoja, y no les ocupe espacio innecesario; además no modifica ninguna variable externa a la función. Pueden Vds. (todos) usar esta función según los términos de la licencia Creative Commons by-nc-sa (la que rige en Scenebeta, vaya; tienen enlace al fin de la página). Ahora bien, como a alguien se le olvide el reconocimiento de la licencia (que puede ser "donde a Vds. les quepa" :), tampoco pido una letra Impact de 72 puntos...), me voy a enfadar, y ya saben que cuando me enfado soy peor que una ducha de ácido clorhídrico. (Y si alguien está pensando que no me enteraré si "compila" el código fuente, que sepa que sí me voy a enterar igualmente, que sé hacer un dump de mis funciones... y entonces aún me enfadaré más, porque habrán infringido doblemente la licencia: no les estoy dando la función precompilada, sino en código fuente, para que puedan modificarla a su conveniencia... avisados están).

Y para usarlo (pongamos, poner algo a 128x128):miImagenReescalada=EscalaImagen(128, 128, miImagenOriginal);

Si se prefiere emplear porcentajes... bueno, podemos añadir otra función que los recalcule:

function EscalaPorCiento(porcentajeAncho, porcentajeAlto, imagenOrigen)
local anchoOriginal, altoOriginal=imagenOrigen:width(), imagenOrigen:height();
return EscalaImagen(math.floor(anchoOriginal*porcentajeAncho*.01), math.floor(altoOriginal*porcentajeAlto*.01), imagenOrigen);
end

(Aquí no es necesario, en realidad, pasar el ancho y alto original a variables, se puede hacer directamente, pero lo he puesto para un pelín más de claridad)

Pero, para terminar... a ver, el reescalado (y basta, o sea, sin más) de una imagen es una cutrada. Sobre todo, si las proporciones finales no son enteras (o sea, amplías una imagen al 150%, por ejemplo). Un píxel al 200% es un cuadrado de 2x2, y basta. Por eso, para que queden bien -o medianamente bien- lo suyo es aplicarles algún tipo de filtro después de escalarlas (que esto no lo hace esta función, pero tampoco el PGE, que yo sepa): algún difuminado, interpolado, dithering, desenfoque, lo que sea, pero algo que suavice esos pedazo de bloques de Lego que te quedan cuando amplías, o esos bordes tan marcados y raros que aparecen cuando reduces. Una función de este tipo es ya más compleja (hay muchas maneras distintas, y todas tienen su qué...).

gracias .. entonces se podria hacer juegos con el no?