drewcassidy/quicktex
1
0
Fork 0
mirror of https://github.com/drewcassidy/quicktex.git synced 2024-09-13 06:37:34 +00:00
Code Issues Projects Releases Activity

Add texture tests and minor api tweaks

Browse Source
This commit is contained in:
Andrew Cassidy 2021-03-29 22:15:53 -07:00
parent 0965f3958d
commit 22bbdeb7b8
3 changed files with 126 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
quicktex/_bindings.cpp
View File

@ -96,7 +96,7 @@ PYBIND11_MODULE(_quicktex, m) {
texture.def_property_readonly("height", &Texture::Height);
texture.def_buffer([](Texture &t) { return py::buffer_info(t.Data(), t.Size()); });
texture.def("to_bytes", [](const Texture &t) { return py::bytes(reinterpret_cast<const char *>(t.Data()), t.Size()); });
texture.def("tobytes", [](const Texture &t) { return py::bytes(reinterpret_cast<const char *>(t.Data()), t.Size()); });
py::class_<RawTexture> raw_texture(m, "RawTexture", texture);
@ -104,7 +104,7 @@ PYBIND11_MODULE(_quicktex, m) {
raw_texture.def("get_pixel", &RawTexture::GetPixel);
raw_texture.def("set_pixel", &RawTexture::SetPixel);
raw_texture.def_static("from_bytes", &BufferToTexture<RawTexture>, "data"_a, "width"_a, "height"_a);
raw_texture.def_static("frombytes", &BufferToTexture<RawTexture>, "data"_a, "width"_a, "height"_a);
// InitS3TC(m);
}

138
tests/test_bc1.py
View File

@ -3,73 +3,73 @@ import nose
from parameterized import parameterized_class
from s3tc import BC1Block
from images import Blocks
import quicktex.s3tc.bc1 as bc1
import quicktex.s3tc.interpolator as interpolator
# import quicktex.s3tc.bc1 as bc1
# import quicktex.s3tc.interpolator as interpolator
#
# ColorMode = bc1.BC1Encoder.ColorMode
ColorMode = bc1.BC1Encoder.ColorMode
class TestBC1Encoder(unittest.TestCase):
"""Test BC1 Encoder"""
def setUp(self):
self.bc1_encoder = bc1.BC1Encoder(5)
def test_block_size(self):
"""Ensure encoded block size is 8 bytes."""
out = self.bc1_encoder.encode_image(Blocks.greyscale, 4, 4)
self.assertEqual(self.bc1_encoder.block_width, 4, 'incorrect reported block width')
self.assertEqual(self.bc1_encoder.block_height, 4, 'incorrect reported block height')
self.assertEqual(self.bc1_encoder.block_size, 8, 'incorrect reported block size')
self.assertEqual(len(out), 8, 'incorrect returned block size')
def get_class_name_blocks(cls, num, params_dict):
return "%s%s" % (cls.__name__, params_dict['color_mode'].name,)
@parameterized_class([
{"color_mode": ColorMode.FourColor},
{"color_mode": ColorMode.ThreeColor},
{"color_mode": ColorMode.ThreeColorBlack},
], class_name_func=get_class_name_blocks)
class TestBC1EncoderBlocks(unittest.TestCase):
"""Test BC1 encoder with a variety of inputs with 3 color blocks disabled."""
def setUp(self):
self.bc1_encoder = bc1.BC1Encoder(5, self.color_mode)
def test_block_4color(self):
"""Test encoder output with 4 color greyscale testblock."""
out = BC1Block.frombytes(self.bc1_encoder.encode_image(Blocks.greyscale, 4, 4))
selectors = [[0, 2, 3, 1]] * 4
self.assertFalse(out.is_3color(), "returned block color mode for greyscale test block")
self.assertEqual(selectors, out.selectors, "block has incorrect selectors for greyscale test block")
def test_block_3color(self):
"""Test encoder output with 3 color test block."""
out = BC1Block.frombytes(self.bc1_encoder.encode_image(Blocks.three_color, 4, 4))
selectors = [[1, 2, 2, 0]] * 4
if self.color_mode != ColorMode.FourColor: # we only care about the selectors if we are in 3 color mode
self.assertTrue(out.is_3color(), "returned 4-color block for 3 color test block")
self.assertEqual(selectors, out.selectors, "block has incorrect selectors for 3 color test block")
else:
self.assertFalse(out.is_3color(), "return 3-color block in 4-color mode")
def test_block_3color_black(self):
"""Test encoder output with 3 color test block with black pixels."""
out = BC1Block.frombytes(self.bc1_encoder.encode_image(Blocks.three_color_black, 4, 4))
selectors = [[3, 1, 2, 0]] * 4
if self.color_mode == ColorMode.ThreeColorBlack: # we only care about the selectors if we are in 3 color black mode
self.assertTrue(out.is_3color_black(), "returned 4-color block for 3 color test block with black")
self.assertEqual(selectors, out.selectors, "block has incorrect selectors for 3 color with black test block")
else:
self.assertFalse(out.is_3color_black(), "returned incorrect block color mode for 3 color with black test block")
if __name__ == '__main__':
nose.main()
#
# class TestBC1Encoder(unittest.TestCase):
# """Test BC1 Encoder"""
#
# def setUp(self):
# self.bc1_encoder = bc1.BC1Encoder(5)
#
# def test_block_size(self):
# """Ensure encoded block size is 8 bytes."""
# out = self.bc1_encoder.encode_image(Blocks.greyscale, 4, 4)
#
# self.assertEqual(self.bc1_encoder.block_width, 4, 'incorrect reported block width')
# self.assertEqual(self.bc1_encoder.block_height, 4, 'incorrect reported block height')
# self.assertEqual(self.bc1_encoder.block_size, 8, 'incorrect reported block size')
# self.assertEqual(len(out), 8, 'incorrect returned block size')
#
#
# def get_class_name_blocks(cls, num, params_dict):
# return "%s%s" % (cls.__name__, params_dict['color_mode'].name,)
#
#
# @parameterized_class([
# {"color_mode": ColorMode.FourColor},
# {"color_mode": ColorMode.ThreeColor},
# {"color_mode": ColorMode.ThreeColorBlack},
# ], class_name_func=get_class_name_blocks)
# class TestBC1EncoderBlocks(unittest.TestCase):
# """Test BC1 encoder with a variety of inputs with 3 color blocks disabled."""
#
# def setUp(self):
# self.bc1_encoder = bc1.BC1Encoder(5, self.color_mode)
#
# def test_block_4color(self):
# """Test encoder output with 4 color greyscale testblock."""
# out = BC1Block.frombytes(self.bc1_encoder.encode_image(Blocks.greyscale, 4, 4))
# selectors = [[0, 2, 3, 1]] * 4
#
# self.assertFalse(out.is_3color(), "returned block color mode for greyscale test block")
# self.assertEqual(selectors, out.selectors, "block has incorrect selectors for greyscale test block")
#
# def test_block_3color(self):
# """Test encoder output with 3 color test block."""
# out = BC1Block.frombytes(self.bc1_encoder.encode_image(Blocks.three_color, 4, 4))
# selectors = [[1, 2, 2, 0]] * 4
#
# if self.color_mode != ColorMode.FourColor: # we only care about the selectors if we are in 3 color mode
# self.assertTrue(out.is_3color(), "returned 4-color block for 3 color test block")
# self.assertEqual(selectors, out.selectors, "block has incorrect selectors for 3 color test block")
# else:
# self.assertFalse(out.is_3color(), "return 3-color block in 4-color mode")
#
# def test_block_3color_black(self):
# """Test encoder output with 3 color test block with black pixels."""
# out = BC1Block.frombytes(self.bc1_encoder.encode_image(Blocks.three_color_black, 4, 4))
# selectors = [[3, 1, 2, 0]] * 4
#
# if self.color_mode == ColorMode.ThreeColorBlack: # we only care about the selectors if we are in 3 color black mode
# self.assertTrue(out.is_3color_black(), "returned 4-color block for 3 color test block with black")
# self.assertEqual(selectors, out.selectors, "block has incorrect selectors for 3 color with black test block")
# else:
# self.assertFalse(out.is_3color_black(), "returned incorrect block color mode for 3 color with black test block")
#
#
# if __name__ == '__main__':
# nose.main()

55
tests/test_texture.py Normal file
View File

@ -0,0 +1,55 @@
import unittest
import nose
import quicktex
import images
import tempfile
from PIL import Image
class TestRawTexture(unittest.TestCase):
def setUp(self):
self.width = 1024
self.height = 1024
self.texture = quicktex.RawTexture(self.width, self.height)
self.boilerplate = Image.open(images.image_path + '/Boilerplate.png')
def test_size(self):
"""test byte size and image dimensions"""
self.assertEqual(self.texture.size, self.width * self.height * 4, "incorrect texture byte size")
self.assertEqual(self.texture.width, self.width, "incorrect texture width")
self.assertEqual(self.texture.height, self.height, "incorrect texture height")
self.assertEqual(self.texture.dimensions, (self.width, self.height), "incorrect texture dimension tuple")
def test_pixels(self):
"""Test get_ and set_pixel methods for RawTexture"""
color1 = (69, 13, 12, 0) # totally random color
color2 = (19, 142, 93, 44)
self.texture.set_pixel(0, 0, color1)
self.texture.set_pixel(self.width - 1, self.height - 1, color2)
data = self.texture.tobytes()
self.assertEqual(self.texture.get_pixel(0, 0), color1)
self.assertEqual(self.texture.get_pixel(self.width - 1, self.height - 1), color2)
self.assertEqual(tuple(data[0:4]), color1)
self.assertEqual(tuple(data[-4:]), color2)
def test_buffer(self):
"""Test the Buffer protocol implementation for RawTexture"""
with tempfile.TemporaryFile('r+b') as fp:
fp.write(self.boilerplate.tobytes('raw', 'RGBX'))
fp.seek(0)
bytes_read = fp.readinto(self.texture)
self.assertEqual(bytes_read, self.texture.size, 'buffer over/underrun')
self.assertEqual(self.boilerplate.tobytes('raw', 'RGBX'), self.texture.tobytes(), 'Incorrect bytes after writing to buffer')
self.assertEqual(bytes(self.texture), self.texture.tobytes(), "Incorrect bytes reading from buffer")
def test_factory(self):
"""Test the frombytes factory function"""
bytetex = quicktex.RawTexture.frombytes(self.boilerplate.tobytes('raw', 'RGBX'), *self.boilerplate.size)
self.assertEqual(self.boilerplate.tobytes('raw', 'RGBX'), bytetex.tobytes(), 'Incorrect bytes after writing to buffer')
if __name__ == '__main__':
nose.main()