Apple-2-SW/ii-vision
1
0
Fork 0
mirror of https://github.com/KrisKennaway/ii-vision.git synced 2024-10-01 01:56:46 +00:00
Code Issues Projects Releases Wiki Activity
5c550d8524
ii-vision/transcoder/screen_test.py

783 lines
26 KiB
Python
Raw Normal View History

Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
"""Tests for the screen module."""
import unittest
import numpy as np
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
from etaprogress.progress import ProgressBar
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
import colours
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
from palette import Palette, PALETTES
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
import screen
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
import sys
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
class TestDHGRBitmap(unittest.TestCase):
def setUp(self) -> None:
self.aux = screen.MemoryMap(screen_page=1)
self.main = screen.MemoryMap(screen_page=1)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
def test_edit_distances(self):
for p in PALETTES:
ed = screen._edit_distances("DHGR", p)
print(p)
bar = ProgressBar((2 ** 13 * (2 ** 13 - 1)) / 2, max_width=80)
cnt = 0
for i in range(2 ** 13):
# Assert that self-distances are zero
self.assertEqual(0, ed[0][(i << 13) + i])
self.assertEqual(0, ed[1][(i << 13) + i])
self.assertEqual(0, ed[2][(i << 13) + i])
self.assertEqual(0, ed[3][(i << 13) + i])
# Assert that matrix is triangular
for j in range(i):
cnt += 1
if cnt % 10000 == 0:
bar.numerator = cnt
print(bar, end='\r')
sys.stdout.flush()
self.assertEqual(
ed[0][(i << 13) + j],
ed[0][(j << 13) + i],
)
self.assertEqual(
ed[1][(i << 13) + j],
ed[1][(j << 13) + i],
)
self.assertEqual(
ed[2][(i << 13) + j],
ed[2][(j << 13) + i],
)
self.assertEqual(
ed[3][(i << 13) + j],
ed[3][(j << 13) + i],
)
def test_make_header(self):
self.assertEqual(
0b100,
screen.DHGRBitmap._make_header(
np.uint64(0b0001000011111010110000111110101000))
)
def test_make_footer(self):
self.assertEqual(
0b1010000000000000000000000000000000,
screen.DHGRBitmap._make_footer(
np.uint64(0b0001000011111010110000111110101000))
)
def test_pixel_packing_offset_0(self):
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
# PBBBAAAA
self.aux.page_offset[0, 0] = 0b11110101
# PDDCCCCB
self.main.page_offset[0, 0] = 0b01000011
# PFEEEEDD
self.aux.page_offset[0, 1] = 0b11110101
# PGGGGFFF
self.main.page_offset[0, 1] = 0b01000011
dhgr = screen.DHGRBitmap(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
main_memory=self.main, aux_memory=self.aux, palette=Palette.NTSC)
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b0001000011111010110000111110101000,
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
dhgr.packed[0, 0]
)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Check header on neighbouring byte
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b0000000000000000000000000000000100,
dhgr.packed[0, 1]
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# No other entries should be set, in particular no footer since we
# are at packed offset 0
self.assertEqual(2, np.count_nonzero(dhgr.packed))
def test_pixel_packing_offset_1(self):
# PBBBAAAA
self.aux.page_offset[0, 2] = 0b11110101
# PDDCCCCB
self.main.page_offset[0, 2] = 0b01000011
# PFEEEEDD
self.aux.page_offset[0, 3] = 0b11110101
# PGGGGFFF
self.main.page_offset[0, 3] = 0b01000011
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
dhgr = screen.DHGRBitmap(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
main_memory=self.main, aux_memory=self.aux, palette=Palette.NTSC)
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b0001000011111010110000111110101000,
dhgr.packed[0, 1]
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Check footer on neighbouring byte
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b1010000000000000000000000000000000,
dhgr.packed[0, 0]
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Check header on neighbouring byte
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b0000000000000000000000000000000100,
dhgr.packed[0, 2]
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# No other entries should be set
self.assertEqual(3, np.count_nonzero(dhgr.packed))
def test_pixel_packing_offset_127(self):
# PBBBAAAA
self.aux.page_offset[0, 254] = 0b11110101
# PDDCCCCB
self.main.page_offset[0, 254] = 0b01000011
# PFEEEEDD
self.aux.page_offset[0, 255] = 0b11110101
# PGGGGFFF
self.main.page_offset[0, 255] = 0b01000011
dhgr = screen.DHGRBitmap(
main_memory=self.main, aux_memory=self.aux, palette=Palette.NTSC)
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b0001000011111010110000111110101000,
dhgr.packed[0, 127]
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Check footer on neighbouring byte
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b1010000000000000000000000000000000,
dhgr.packed[0, 126]
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# No other entries should be set, in particular header should not
# propagate to next row
self.assertEqual(2, np.count_nonzero(dhgr.packed))
def test_byte_offset(self):
self.assertEqual(0, screen.DHGRBitmap.byte_offset(0, is_aux=True))
self.assertEqual(1, screen.DHGRBitmap.byte_offset(0, is_aux=False))
self.assertEqual(2, screen.DHGRBitmap.byte_offset(1, is_aux=True))
self.assertEqual(3, screen.DHGRBitmap.byte_offset(1, is_aux=False))
def test_byte_offsets(self):
self.assertEqual((0, 2), screen.DHGRBitmap._byte_offsets(is_aux=True))
self.assertEqual((1, 3), screen.DHGRBitmap._byte_offsets(is_aux=False))
def test_mask_and_shift_data(self):
int13_max = np.uint64(2 ** 13 - 1)
int34_max = np.uint64(2 ** 34 - 1)
dhgr = screen.DHGRBitmap(
main_memory=self.main, aux_memory=self.aux, palette=Palette.NTSC)
for o in range(3):
self.assertEqual(
int13_max,
dhgr.mask_and_shift_data(
screen.DHGRBitmap.BYTE_MASKS[o], o
)
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Now check complement, i.e. no bits taken from outside expected
# range
self.assertEqual(
0,
dhgr.mask_and_shift_data(
~screen.DHGRBitmap.BYTE_MASKS[o] & int34_max, o
)
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
def test_masked_update(self):
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b0000000000000000000000001111111000,
screen.DHGRBitmap.masked_update(
0, np.uint64(0), np.uint8(0xff))
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b0000000000000000011111110000000000,
screen.DHGRBitmap.masked_update(
1, np.uint64(0), np.uint8(0xff))
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b0000000000111111100000000000000000,
screen.DHGRBitmap.masked_update(
2, np.uint64(0), np.uint8(0xff))
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b0001111111000000000000000000000000,
screen.DHGRBitmap.masked_update(
3, np.uint64(0), np.uint8(0xff))
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
# Now test masking out existing values
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
int34_max = np.uint64(2 ** 34 - 1)
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b1111111111111111111111110000000111,
screen.DHGRBitmap.masked_update(0, int34_max, np.uint8(0x00))
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b1111111111111111100000001111111111,
screen.DHGRBitmap.masked_update(1, int34_max, np.uint8(0x00))
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b1111111111000000011111111111111111,
screen.DHGRBitmap.masked_update(2, int34_max, np.uint8(0x00))
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b1110000000111111111111111111111111,
screen.DHGRBitmap.masked_update(3, int34_max, np.uint8(0x00))
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
)
# Test that masked_update can broadcast to numpy arrays
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
ary = np.zeros((2, 2), dtype=np.uint64)
elt = np.uint64(0b1111111000)
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
self.assertTrue(np.array_equal(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
np.array([[elt, elt], [elt, elt]], dtype=np.uint64),
screen.DHGRBitmap.masked_update(0, ary, np.uint8(0xff))
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
))
def test_apply(self):
dhgr = screen.DHGRBitmap(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
main_memory=self.main, aux_memory=self.aux, palette=Palette.NTSC)
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
dhgr.apply(page=0, offset=0, is_aux=True, value=np.uint8(0xff))
self.assertEqual(0b1111111000, dhgr.packed[0, 0])
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
dhgr.apply(page=12, offset=36, is_aux=True, value=np.uint8(0xff))
# Neighbouring header
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0,
dhgr.packed[12, 19])
# Body
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b1111111000,
dhgr.packed[12, 18])
# Neighbouring footer
self.assertEqual(
0b1110000000000000000000000000000000,
dhgr.packed[12, 17])
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Now update the next aux offset in same uint64
dhgr.apply(page=12, offset=37, is_aux=True, value=np.uint8(0xff))
# Neighbouring header
self.assertEqual(
0,
dhgr.packed[12, 19])
# Body
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b0000000111111100000001111111000,
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
dhgr.packed[12, 18]
)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Neighbouring footer
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b1110000000000000000000000000000000,
dhgr.packed[12, 17])
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Update offset 3, should propagate to next header
dhgr.apply(page=12, offset=37, is_aux=False, value=np.uint8(0b1010101))
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b101,
dhgr.packed[12, 19])
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b1010101111111100000001111111000,
dhgr.packed[12, 18]
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
)
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b1110000000000000000000000000000000,
dhgr.packed[12, 17])
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
dhgr.apply(page=12, offset=36, is_aux=False, value=np.uint8(0b0001101))
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b101,
dhgr.packed[12, 19])
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b1010101111111100011011111111000,
dhgr.packed[12, 18]
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
)
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b1110000000000000000000000000000000,
dhgr.packed[12, 17])
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Change offset 0, should propagate to neighbouring footer
dhgr.apply(page=12, offset=36, is_aux=True, value=np.uint8(0b0001101))
# Neighbouring header
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b101,
dhgr.packed[12, 19])
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b1010101111111100011010001101000,
dhgr.packed[12, 18]
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Neighbouring footer
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0b1010000000000000000000000000000000,
dhgr.packed[12, 17])
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Now propagate new header from neighbour onto (12, 18)
dhgr.apply(page=12, offset=35, is_aux=False, value=np.uint8(0b1010101))
self.assertEqual(
0b1010101111111100011010001101101,
dhgr.packed[12, 18]
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Neighbouring footer
self.assertEqual(
0b1011010101000000000000000000000000,
dhgr.packed[12, 17])
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
def test_fix_array_neighbours(self):
dhgr = screen.DHGRBitmap(
main_memory=self.main, aux_memory=self.aux, palette=Palette.NTSC)
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
packed = dhgr.masked_update(0, dhgr.packed, np.uint8(0x7f))
dhgr._fix_array_neighbours(packed, 0)
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Should propagate to all footers
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0, np.count_nonzero(
packed[packed != 0b1110000000000000000000001111111000]
)
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Should not change headers/footers
packed = dhgr.masked_update(1, packed, np.uint8(0b1010101))
dhgr._fix_array_neighbours(packed, 1)
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0, np.count_nonzero(
packed[packed != 0b1110000000000000010101011111111000]
)
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# Should propagate to all headers
packed = dhgr.masked_update(3, packed, np.uint8(0b0110110))
dhgr._fix_array_neighbours(packed, 3)
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
self.assertEqual(
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
0, np.count_nonzero(
packed[packed != 0b1110110110000000010101011111111011]
)
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
)
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
def binary(a):
return np.vectorize("{:032b}".format)(a)
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
Separate the details of the bitmap packing from operations on the packed representation (diff, apply etc). This allows the (D)HGRBitmap classes to focus on the bitmap packing and share common logic. Numpy has unfortunate long-standing bugs to do with type coercion of np.uint64, which leads to spurious "incompatible type" warnings when e.g. operating on a np.uint64 and some other integer type. To work around this we cast explicitly to np.uint64 everywhere. Get tests working again - for now HGR tests in screen_test.py are disabled until I finish implementing new packing. HGRBitmap is still incomplete although closer.
2019-07-04 14:21:20 +00:00
# class TestHGRBitmap: # unittest.TestCase):
# def setUp(self) -> None:
# self.main = screen.MemoryMap(screen_page=1)
#
# def test_pixel_packing_p0_p0(self):
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b01000011
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b01000011
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# want = 0b1100000000111111000000001111
# got = hgr.packed[0, 0]
#
# self.assertEqual(
# want, got, "\n%s\n%s" % (binary(want), binary(got))
# )
#
# def test_pixel_packing_p0_p1(self):
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b01000011
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b11000011
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# want = 0b1000000001111111000000001111
# got = hgr.packed[0, 0]
#
# self.assertEqual(
# want, got, "\n%s\n%s" % (binary(want), binary(got))
# )
#
# def test_pixel_packing_p1_p0(self):
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b11000011
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b01000011
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# want = 0b1100000000111110000000011110
# got = hgr.packed[0, 0]
#
# self.assertEqual(
# want, got, "\n%s\n%s" % (binary(want), binary(got))
# )
#
# def test_pixel_packing_p1_p1(self):
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b11000011
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b11000011
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# want = 0b1000000001111110000000011110
# got = hgr.packed[0, 0]
#
# self.assertEqual(
# want, got, "\n%s\n%s" % (binary(want), binary(got))
# )
#
# def test_pixel_packing_p1_promote_p0(self):
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b00000000
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b01000000
#
# # PDCCBBAA
# self.main.page_offset[0, 2] = 0b10000000
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# want = 0b0000000000000000000000000001
# got = hgr.packed[0, 1]
#
# self.assertEqual(
# want, got, "\n%s\n%s" % (binary(want), binary(got))
# )
#
# def test_pixel_packing_p1_promote_p1(self):
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b00000000
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b11000000
#
# # PDCCBBAA
# self.main.page_offset[0, 2] = 0b10000000
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# want = 0b0000000000000000000000000001
# got = hgr.packed[0, 1]
#
# self.assertEqual(
# want, got, "\n%s\n%s" % (binary(want), binary(got))
# )
#
# def test_nominal_colours(self):
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b01010101
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b00101010
# # PDCCBBAA
# self.main.page_offset[0, 2] = 0b01010101
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# want = 0b000110011001100110011001100110011
# got = hgr.packed[0, 0]
#
# self.assertEqual(
# want, got, "\n%s\n%s" % (binary(want), binary(got))
# )
#
# self.assertEqual(
# (
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# colours.HGRColours.VIOLET,
# ),
# colours.int34_to_nominal_colour_pixels(hgr.packed[0, 0],
# colours.HGRColours)
# )
#
# # See Figure 8.15 from Sather, "Understanding the Apple IIe"
#
# def test_nominal_colours_sather1(self):
# # Extend violet into light blue
#
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b01000000
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b10000000
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# self.assertEqual(
# (
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.LIGHT_BLUE,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# ),
# colours.int28_to_nominal_colour_pixels(hgr.packed[0, 0],
# colours.HGRColours)
# )
#
# def test_nominal_colours_sather2(self):
# # Cut off blue with black to produce dark blue
#
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b11000000
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b00000000
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# self.assertEqual(
# (
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.DARK_BLUE,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# ),
# colours.int28_to_nominal_colour_pixels(hgr.packed[0, 0],
# colours.HGRColours)
# )
#
# def test_nominal_colours_sather3(self):
# # Cut off blue with green to produce aqua
#
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b11000000
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b00000001
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# self.assertEqual(
# (
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.AQUA,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# ),
# colours.int28_to_nominal_colour_pixels(hgr.packed[0, 0],
# colours.HGRColours)
# )
#
# def test_nominal_colours_sather4(self):
# # Cut off white with black to produce pink
#
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b11100000
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b00000000
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# want = 0b0000000000000011100000000000
# got = hgr.packed[0, 0]
#
# self.assertEqual(
# want, got, "\n%s\n%s" % (binary(want), binary(got))
# )
#
# # TODO: BROWN(0001)/VIOLET(1100) should reframe to PINK (1011)
# self.assertEqual(
# (
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BROWN,
# colours.HGRColours.VIOLET,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# ),
# colours.int28_to_nominal_colour_pixels(hgr.packed[0, 0],
# colours.HGRColours)
# )
#
# def test_nominal_colours_sather5(self):
# # Extend green into light brown
#
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b01000000
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b10000000
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# want = 0b0000000000000111000000000000
# got = hgr.packed[0, 0]
#
# self.assertEqual(
# want, got, "\n%s\n%s" % (binary(want), binary(got))
# )
#
# # TODO: LIGHT_BLUE should reframe to PINK (1011)
# self.assertEqual(
# (
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.LIGHT_BLUE,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# ),
# colours.int28_to_nominal_colour_pixels(hgr.packed[0, 0],
# colours.HGRColours)
# )
#
# def test_nominal_colours_sather6(self):
# # Cut off orange with black to produce dark brown
#
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b11000000
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b00000000
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# want = 0b00000000000000010000000000000
# got = hgr.packed[0, 0]
#
# self.assertEqual(
# want, got, "\n%s\n%s" % (binary(want), binary(got))
# )
#
# # TODO: DARK_BLUE should reframe to DARK_BROWN
# self.assertEqual(
# (
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.DARK_BLUE,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# ),
# colours.int28_to_nominal_colour_pixels(hgr.packed[0, 0],
# colours.HGRColours)
# )
#
# def test_nominal_colours_sather7(self):
# # Cut off orange with violet to produce pink
#
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b11000000
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b00000001
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# want = 0b00000000000001110000000000000
# got = hgr.packed[0, 0]
#
# self.assertEqual(
# want, got, "\n%s\n%s" % (binary(want), binary(got))
# )
#
# # TODO: AQUA should reframe to PINK
# self.assertEqual(
# (
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.AQUA,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# ),
# colours.int28_to_nominal_colour_pixels(hgr.packed[0, 0],
# colours.HGRColours)
# )
#
# def test_nominal_colours_sather8(self):
# # Cut off white with black to produce aqua
#
# # PDCCBBAA
# self.main.page_offset[0, 0] = 0b11100000
# # PGGFFEED
# self.main.page_offset[0, 1] = 0b00000000
#
# hgr = screen.HGRBitmap(
# main_memory=self.main)
#
# want = 0b00000000000000011100000000000
# got = hgr.packed[0, 0]
#
# self.assertEqual(
# want, got, "\n%s\n%s" % (binary(want), binary(got))
# )
#
# # TODO: BROWN/VIOLET should reframe to AQUA
# self.assertEqual(
# (
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BROWN,
# colours.HGRColours.VIOLET,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# colours.HGRColours.BLACK,
# ),
# colours.int28_to_nominal_colour_pixels(
# hgr.packed[0, 0], colours.HGRColours)
# )
Checkpoint WIP for easier comparison to dhgr branch: - naive version of NTSC artifacting, it uses a sliding 4-bit window to assign a nominal (D)HGR colour to each dot position. A more sophisticated/correct implementation would model the YIQ signal directly. - Switch DHGRBitmap implementation to use a 34-bit representation of the 4-byte tuple, comprised of a 3-bit header and footer, plus 4*7=28-bit body. The headers/footers account for the influence on neighbouring tuples from the 4-bit NTSC window. - With this model each screen byte influences 13 pixels, so we need to precompute 2^26 edit distances for all possible (source, target) 13-bit sequences. - Checkpointing not-yet-working HGR implementation. - Add new unit tests but not yet all passing due to refactoring
2019-07-02 21:40:50 +00:00
Remove unused code. Add a new DHGRBitmap class that efficiently represents the DHGR interleaving of the (aux, main) MemoryMap as a sequence of 28-bit integers. This allows for easily extracting the 8-bit and 12-bit subsequences representing the DHGR pixels that are influenced when storing a byte at offsets 0..3 within the interleaved (aux, main, aux, main) sequence. Since we have precomputed all of the pairwise differences between these 8- and 12-bit values, this allows us to efficiently compute the edit distances between pairs of screen bytes (and/or arrays)
2019-06-13 22:44:41 +00:00
if __name__ == '__main__':
unittest.main()
Reference in New Issue Copy Permalink