292 lines
9.3 KiB
Lua
292 lines
9.3 KiB
Lua
package.path = package.path .. ";?.lua"
|
|
local luaunit = require("testing.luaunit")
|
|
local loveStub = require("testing.loveStub")
|
|
_G.love = loveStub
|
|
|
|
local FlexLove = require("FlexLove")
|
|
|
|
TestImageScalerBilinear = {}
|
|
|
|
function TestImageScalerBilinear:setUp()
|
|
-- Create a simple test image (2x2 with distinct colors)
|
|
self.testImage2x2 = love.image.newImageData(2, 2)
|
|
-- Top-left: red
|
|
self.testImage2x2:setPixel(0, 0, 1, 0, 0, 1)
|
|
-- Top-right: green
|
|
self.testImage2x2:setPixel(1, 0, 0, 1, 0, 1)
|
|
-- Bottom-left: blue
|
|
self.testImage2x2:setPixel(0, 1, 0, 0, 1, 1)
|
|
-- Bottom-right: white
|
|
self.testImage2x2:setPixel(1, 1, 1, 1, 1, 1)
|
|
end
|
|
|
|
function TestImageScalerBilinear:test2xScaling()
|
|
-- Scale 2x2 to 4x4 (2x factor)
|
|
local scaled = FlexLove.ImageScaler.scaleBilinear(self.testImage2x2, 0, 0, 2, 2, 4, 4)
|
|
|
|
luaunit.assertEquals(scaled:getWidth(), 4)
|
|
luaunit.assertEquals(scaled:getHeight(), 4)
|
|
|
|
-- Corner pixels should match original (no interpolation at exact positions)
|
|
local r, g, b, a = scaled:getPixel(0, 0)
|
|
luaunit.assertAlmostEquals(r, 1, 0.01) -- Red
|
|
luaunit.assertAlmostEquals(g, 0, 0.01)
|
|
luaunit.assertAlmostEquals(b, 0, 0.01)
|
|
|
|
-- Center pixel at (1,1) should be blend of all 4 corners
|
|
-- At (0.5, 0.5) in source space -> blend of all 4 colors
|
|
r, g, b, a = scaled:getPixel(1, 1)
|
|
-- Should be approximately (0.5, 0.5, 0.5) - average of red, green, blue, white
|
|
luaunit.assertTrue(r > 0.3 and r < 0.7, "Center pixel should be blended")
|
|
luaunit.assertTrue(g > 0.3 and g < 0.7, "Center pixel should be blended")
|
|
luaunit.assertTrue(b > 0.3 and b < 0.7, "Center pixel should be blended")
|
|
end
|
|
|
|
function TestImageScalerBilinear:testGradientSmoothing()
|
|
-- Create a simple gradient: black to white horizontally
|
|
local gradient = love.image.newImageData(2, 1)
|
|
gradient:setPixel(0, 0, 0, 0, 0, 1) -- Black
|
|
gradient:setPixel(1, 0, 1, 1, 1, 1) -- White
|
|
|
|
-- Scale to 4 pixels wide
|
|
local scaled = FlexLove.ImageScaler.scaleBilinear(gradient, 0, 0, 2, 1, 4, 1)
|
|
|
|
luaunit.assertEquals(scaled:getWidth(), 4)
|
|
luaunit.assertEquals(scaled:getHeight(), 1)
|
|
|
|
-- Check smooth gradient progression
|
|
local r0 = scaled:getPixel(0, 0)
|
|
local r1 = scaled:getPixel(1, 0)
|
|
local r2 = scaled:getPixel(2, 0)
|
|
local r3 = scaled:getPixel(3, 0)
|
|
|
|
-- Should be monotonically increasing (or equal at end due to clamping)
|
|
luaunit.assertTrue(r0 < r1, "Gradient should increase")
|
|
luaunit.assertTrue(r1 < r2, "Gradient should increase")
|
|
luaunit.assertTrue(r2 <= r3, "Gradient should increase or stay same")
|
|
|
|
-- First should be close to black, last close to white
|
|
luaunit.assertAlmostEquals(r0, 0, 0.15)
|
|
luaunit.assertAlmostEquals(r3, 1, 0.15)
|
|
end
|
|
|
|
function TestImageScalerBilinear:testSameSizeScaling()
|
|
-- Scale 2x2 to 2x2 (should be identical)
|
|
local scaled = FlexLove.ImageScaler.scaleBilinear(self.testImage2x2, 0, 0, 2, 2, 2, 2)
|
|
|
|
luaunit.assertEquals(scaled:getWidth(), 2)
|
|
luaunit.assertEquals(scaled:getHeight(), 2)
|
|
|
|
-- Verify all pixels match original
|
|
for y = 0, 1 do
|
|
for x = 0, 1 do
|
|
local r1, g1, b1, a1 = self.testImage2x2:getPixel(x, y)
|
|
local r2, g2, b2, a2 = scaled:getPixel(x, y)
|
|
luaunit.assertAlmostEquals(r1, r2, 0.01)
|
|
luaunit.assertAlmostEquals(g1, g2, 0.01)
|
|
luaunit.assertAlmostEquals(b1, b2, 0.01)
|
|
luaunit.assertAlmostEquals(a1, a2, 0.01)
|
|
end
|
|
end
|
|
end
|
|
|
|
function TestImageScalerBilinear:test1x1Scaling()
|
|
-- Create 1x1 image
|
|
local img1x1 = love.image.newImageData(1, 1)
|
|
img1x1:setPixel(0, 0, 0.5, 0.5, 0.5, 1)
|
|
|
|
-- Scale to 4x4
|
|
local scaled = FlexLove.ImageScaler.scaleBilinear(img1x1, 0, 0, 1, 1, 4, 4)
|
|
|
|
luaunit.assertEquals(scaled:getWidth(), 4)
|
|
luaunit.assertEquals(scaled:getHeight(), 4)
|
|
|
|
-- All pixels should be the same color (no neighbors to interpolate with)
|
|
for y = 0, 3 do
|
|
for x = 0, 3 do
|
|
local r, g, b = scaled:getPixel(x, y)
|
|
luaunit.assertAlmostEquals(r, 0.5, 0.01)
|
|
luaunit.assertAlmostEquals(g, 0.5, 0.01)
|
|
luaunit.assertAlmostEquals(b, 0.5, 0.01)
|
|
end
|
|
end
|
|
end
|
|
|
|
function TestImageScalerBilinear:testPureColorMaintenance()
|
|
-- Create pure white image
|
|
local whiteImg = love.image.newImageData(2, 2)
|
|
for y = 0, 1 do
|
|
for x = 0, 1 do
|
|
whiteImg:setPixel(x, y, 1, 1, 1, 1)
|
|
end
|
|
end
|
|
|
|
local scaled = FlexLove.ImageScaler.scaleBilinear(whiteImg, 0, 0, 2, 2, 4, 4)
|
|
|
|
-- All pixels should remain pure white
|
|
for y = 0, 3 do
|
|
for x = 0, 3 do
|
|
local r, g, b = scaled:getPixel(x, y)
|
|
luaunit.assertAlmostEquals(r, 1, 0.01)
|
|
luaunit.assertAlmostEquals(g, 1, 0.01)
|
|
luaunit.assertAlmostEquals(b, 1, 0.01)
|
|
end
|
|
end
|
|
|
|
-- Test pure black
|
|
local blackImg = love.image.newImageData(2, 2)
|
|
for y = 0, 1 do
|
|
for x = 0, 1 do
|
|
blackImg:setPixel(x, y, 0, 0, 0, 1)
|
|
end
|
|
end
|
|
|
|
scaled = FlexLove.ImageScaler.scaleBilinear(blackImg, 0, 0, 2, 2, 4, 4)
|
|
|
|
for y = 0, 3 do
|
|
for x = 0, 3 do
|
|
local r, g, b = scaled:getPixel(x, y)
|
|
luaunit.assertAlmostEquals(r, 0, 0.01)
|
|
luaunit.assertAlmostEquals(g, 0, 0.01)
|
|
luaunit.assertAlmostEquals(b, 0, 0.01)
|
|
end
|
|
end
|
|
end
|
|
|
|
function TestImageScalerBilinear:testAlphaInterpolation()
|
|
-- Create image with varying alpha
|
|
local img = love.image.newImageData(2, 2)
|
|
img:setPixel(0, 0, 1, 0, 0, 1.0) -- Opaque red
|
|
img:setPixel(1, 0, 1, 0, 0, 0.0) -- Transparent red
|
|
img:setPixel(0, 1, 1, 0, 0, 1.0) -- Opaque red
|
|
img:setPixel(1, 1, 1, 0, 0, 0.0) -- Transparent red
|
|
|
|
local scaled = FlexLove.ImageScaler.scaleBilinear(img, 0, 0, 2, 2, 4, 2)
|
|
|
|
-- Check that alpha is interpolated smoothly
|
|
local r, g, b, a0 = scaled:getPixel(0, 0)
|
|
luaunit.assertAlmostEquals(a0, 1.0, 0.01)
|
|
|
|
local r, g, b, a1 = scaled:getPixel(1, 0)
|
|
-- Should be between 1.0 and 0.0
|
|
luaunit.assertTrue(a1 > 0.3 and a1 < 0.7, "Alpha should be interpolated")
|
|
|
|
local r, g, b, a3 = scaled:getPixel(3, 0)
|
|
luaunit.assertAlmostEquals(a3, 0.0, 0.15)
|
|
end
|
|
|
|
function TestImageScalerBilinear:testSubregionScaling()
|
|
-- Create 4x4 image with different quadrants
|
|
local img4x4 = love.image.newImageData(4, 4)
|
|
|
|
-- Fill with pattern: top-left red, rest black
|
|
for y = 0, 3 do
|
|
for x = 0, 3 do
|
|
if x < 2 and y < 2 then
|
|
img4x4:setPixel(x, y, 1, 0, 0, 1) -- red
|
|
else
|
|
img4x4:setPixel(x, y, 0, 0, 0, 1) -- black
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Scale only the top-left 2x2 red quadrant to 4x4
|
|
local scaled = FlexLove.ImageScaler.scaleBilinear(img4x4, 0, 0, 2, 2, 4, 4)
|
|
|
|
luaunit.assertEquals(scaled:getWidth(), 4)
|
|
luaunit.assertEquals(scaled:getHeight(), 4)
|
|
|
|
-- All pixels should be red (from source quadrant)
|
|
for y = 0, 3 do
|
|
for x = 0, 3 do
|
|
local r, g, b = scaled:getPixel(x, y)
|
|
luaunit.assertAlmostEquals(r, 1, 0.01)
|
|
luaunit.assertAlmostEquals(g, 0, 0.01)
|
|
luaunit.assertAlmostEquals(b, 0, 0.01)
|
|
end
|
|
end
|
|
end
|
|
|
|
function TestImageScalerBilinear:testEdgePixelHandling()
|
|
-- Create 3x3 checkerboard
|
|
local checkerboard = love.image.newImageData(3, 3)
|
|
for y = 0, 2 do
|
|
for x = 0, 2 do
|
|
if (x + y) % 2 == 0 then
|
|
checkerboard:setPixel(x, y, 1, 1, 1, 1) -- white
|
|
else
|
|
checkerboard:setPixel(x, y, 0, 0, 0, 1) -- black
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Scale to 9x9
|
|
local scaled = FlexLove.ImageScaler.scaleBilinear(checkerboard, 0, 0, 3, 3, 9, 9)
|
|
|
|
luaunit.assertEquals(scaled:getWidth(), 9)
|
|
luaunit.assertEquals(scaled:getHeight(), 9)
|
|
|
|
-- Verify corners are correct (no out-of-bounds access)
|
|
local r, g, b = scaled:getPixel(0, 0)
|
|
luaunit.assertAlmostEquals(r, 1, 0.01) -- Top-left should be white
|
|
|
|
r, g, b = scaled:getPixel(8, 8)
|
|
luaunit.assertAlmostEquals(r, 1, 0.01) -- Bottom-right should be white
|
|
end
|
|
|
|
function TestImageScalerBilinear:testNonUniformScaling()
|
|
-- Scale 2x2 to 6x4 (3x horizontal, 2x vertical)
|
|
local scaled = FlexLove.ImageScaler.scaleBilinear(self.testImage2x2, 0, 0, 2, 2, 6, 4)
|
|
|
|
luaunit.assertEquals(scaled:getWidth(), 6)
|
|
luaunit.assertEquals(scaled:getHeight(), 4)
|
|
|
|
-- Top-left corner should be red
|
|
local r, g, b = scaled:getPixel(0, 0)
|
|
luaunit.assertAlmostEquals(r, 1, 0.01)
|
|
luaunit.assertAlmostEquals(g, 0, 0.01)
|
|
|
|
-- Should have smooth interpolation in between
|
|
r, g, b = scaled:getPixel(2, 1)
|
|
-- Middle area should have blended colors
|
|
luaunit.assertTrue(r > 0.1, "Should have some red component")
|
|
luaunit.assertTrue(g > 0.1, "Should have some green component")
|
|
luaunit.assertTrue(b > 0.1, "Should have some blue component")
|
|
end
|
|
|
|
function TestImageScalerBilinear:testComparison_SmootherThanNearest()
|
|
-- Create gradient
|
|
local gradient = love.image.newImageData(2, 1)
|
|
gradient:setPixel(0, 0, 0, 0, 0, 1)
|
|
gradient:setPixel(1, 0, 1, 1, 1, 1)
|
|
|
|
local bilinear = FlexLove.ImageScaler.scaleBilinear(gradient, 0, 0, 2, 1, 8, 1)
|
|
local nearest = FlexLove.ImageScaler.scaleNearest(gradient, 0, 0, 2, 1, 8, 1)
|
|
|
|
-- Count unique values (nearest should have fewer due to blocky nature)
|
|
local bilinearValues = {}
|
|
local nearestValues = {}
|
|
|
|
for x = 0, 7 do
|
|
local rb = bilinear:getPixel(x, 0)
|
|
local rn = nearest:getPixel(x, 0)
|
|
bilinearValues[string.format("%.2f", rb)] = true
|
|
nearestValues[string.format("%.2f", rn)] = true
|
|
end
|
|
|
|
local bilinearCount = 0
|
|
for _ in pairs(bilinearValues) do
|
|
bilinearCount = bilinearCount + 1
|
|
end
|
|
|
|
local nearestCount = 0
|
|
for _ in pairs(nearestValues) do
|
|
nearestCount = nearestCount + 1
|
|
end
|
|
|
|
-- Bilinear should have more unique values (smoother gradient)
|
|
luaunit.assertTrue(bilinearCount >= nearestCount, "Bilinear should produce smoother gradient with more unique values")
|
|
end
|
|
|
|
luaunit.LuaUnit.run()
|