def test_interleave_different_sizes(self):
base = self.segment
r1 = base.rawdata[512:768] # 256 byte segment
s1 = DefaultSegment(r1, 512)
r2 = base.rawdata[1024:1536] # 512 byte segment
s2 = DefaultSegment(r2, 1024)
indexes1 = r1.get_indexes_from_base()
verify1 = np.arange(512, 768, dtype=np.uint32)
assert np.array_equal(indexes1, verify1)
indexes2 = r2.get_indexes_from_base()
verify2 = np.arange(1024, 1536, dtype=np.uint32)
assert np.array_equal(indexes2, verify2)
s = interleave_segments([s1, s2], 3)
# when interleave size isn't a multiple of the length, the final array
# will reduce the size of the input array to force it to be a multiple.
size = (min(len(s1), len(s2)) // 3) * 3
assert size == (256 // 3) * 3
assert len(s) == size * 2
a = np.empty(len(s), dtype=np.uint8)
a[0::6] = s1[0:size:3]
a[1::6] = s1[1:size:3]
a[2::6] = s1[2:size:3]
a[3::6] = s2[0:size:3]
a[4::6] = s2[1:size:3]
a[5::6] = s2[2:size:3]
assert np.array_equal(s[:], a)
class TestJsonPickle(object):
def setup(self):
data = np.arange(2048, dtype=np.uint8)
self.segment = DefaultSegment(SegmentData(data))
def test_simple(self):
print self.segment.byte_bounds_offset(), len(self.segment)
r2 = self.segment.rawdata[100:400]
s2 = DefaultSegment(r2)
print s2.byte_bounds_offset(), len(s2), s2.__getstate__()
r3 = s2.rawdata[100:200]
s3 = DefaultSegment(r3)
print s3.byte_bounds_offset(), len(s3), s3.__getstate__()
order = list(reversed(range(700, 800)))
r4 = self.segment.rawdata.get_indexed(order)
s4 = DefaultSegment(r4)
print s4.byte_bounds_offset(), len(s4), s4.__getstate__()
slist = [s2, s3, s4]
for s in slist:
print s
j = jsonpickle.dumps(slist)
print j
slist2 = jsonpickle.loads(j)
print slist2
for s in slist2:
s.reconstruct_raw(self.segment.rawdata)
print s
for orig, rebuilt in zip(slist, slist2):
print "orig", orig.data[:]
print "rebuilt", rebuilt.data[:]
assert np.array_equal(orig[:], rebuilt[:])
def rebuild(self):
v = self.virtual_linked_base
old_size = v.document_length
size = old_size + 1
old_segment = v.segment
segment = DefaultSegment(np.arange(size, dtype=np.uint8))
segment.style[0:old_size] = old_segment.style[0:old_size]
v.segment = segment
self.init_boundaries()
print(f"new size: {len(v.segment)}")
def test_simple(self):
print(self.segment.byte_bounds_offset(), len(self.segment))
r2 = self.segment.rawdata[100:400]
s2 = DefaultSegment(r2)
print(s2.byte_bounds_offset(), len(s2), s2.__getstate__())
r3 = s2.rawdata[100:200]
s3 = DefaultSegment(r3)
print(s3.byte_bounds_offset(), len(s3), s3.__getstate__())
order = list(reversed(list(range(700, 800))))
r4 = self.segment.rawdata.get_indexed(order)
s4 = DefaultSegment(r4)
print(s4.byte_bounds_offset(), len(s4), s4.__getstate__())
slist = [s2, s3, s4]
for s in slist:
print(s)
j = jsonpickle.dumps(slist)
print(j)
slist2 = jsonpickle.loads(j)
print(slist2)
for s in slist2:
s.reconstruct_raw(self.segment.rawdata)
print(s)
for orig, rebuilt in zip(slist, slist2):
print("orig", orig.data[:])
print("rebuilt", rebuilt.data[:])
assert np.array_equal(orig[:], rebuilt[:])
def test_interleave(self):
base = self.segment
r1 = base.rawdata[512:1024] # 512 byte segment
s1 = DefaultSegment(r1, 512)
r2 = base.rawdata[1024:1536] # 512 byte segment
s2 = DefaultSegment(r2, 1024)
indexes1 = r1.get_indexes_from_base()
verify1 = np.arange(512, 1024, dtype=np.uint32)
assert np.array_equal(indexes1, verify1)
indexes2 = r2.get_indexes_from_base()
verify2 = np.arange(1024, 1536, dtype=np.uint32)
assert np.array_equal(indexes2, verify2)
s = interleave_segments([s1, s2], 2)
a = np.empty(len(s1) + len(s2), dtype=np.uint8)
a[0::4] = s1[0::2]
a[1::4] = s1[1::2]
a[2::4] = s2[0::2]
a[3::4] = s2[1::2]
print list(s[:])
print list(a[:])
print s.rawdata.order
assert np.array_equal(s[:], a)
s = interleave_segments([s1, s2], 4)
a = np.empty(len(s1) + len(s2), dtype=np.uint8)
a[0::8] = s1[0::4]
a[1::8] = s1[1::4]
a[2::8] = s1[2::4]
a[3::8] = s1[3::4]
a[4::8] = s2[0::4]
a[5::8] = s2[1::4]
a[6::8] = s2[2::4]
a[7::8] = s2[3::4]
assert np.array_equal(s[:], a)
with pytest.raises(ValueError) as e:
s = interleave_segments([s1, s2], 3)
r1 = base.rawdata[512:1025] # 513 byte segment
s1 = DefaultSegment(r1, 512)
r2 = base.rawdata[1024:1537] # 513 byte segment
s2 = DefaultSegment(r2, 1024)
s = interleave_segments([s1, s2], 3)
a = np.empty(len(s1) + len(s2), dtype=np.uint8)
a[0::6] = s1[0::3]
a[1::6] = s1[1::3]
a[2::6] = s1[2::3]
a[3::6] = s2[0::3]
a[4::6] = s2[1::3]
a[5::6] = s2[2::3]
assert np.array_equal(s[:], a)
class TestJsonPickle:
def setup(self):
data = np.arange(2048, dtype=np.uint8)
self.segment = DefaultSegment(SegmentData(data))
def test_simple(self):
print(self.segment.byte_bounds_offset(), len(self.segment))
r2 = self.segment.rawdata[100:400]
s2 = DefaultSegment(r2)
print(s2.byte_bounds_offset(), len(s2), s2.__getstate__())
r3 = s2.rawdata[100:200]
s3 = DefaultSegment(r3)
print(s3.byte_bounds_offset(), len(s3), s3.__getstate__())
order = list(reversed(list(range(700, 800))))
r4 = self.segment.rawdata.get_indexed(order)
s4 = DefaultSegment(r4)
print(s4.byte_bounds_offset(), len(s4), s4.__getstate__())
slist = [s2, s3, s4]
for s in slist:
print(s)
j = jsonpickle.dumps(slist)
print(j)
slist2 = jsonpickle.loads(j)
print(slist2)
for s in slist2:
s.reconstruct_raw(self.segment.rawdata)
print(s)
for orig, rebuilt in zip(slist, slist2):
print("orig", orig.data[:])
print("rebuilt", rebuilt.data[:])
assert np.array_equal(orig[:], rebuilt[:])
def setup(self):
self.screen = np.zeros(40 * 90, dtype=np.uint8)
data = np.fromstring(
"\x04\x00\x00\x01\x01\x01\x01\x04\x00\x01\x01\x00\x01\x00\x04\x00\x02\x01\x01\x01\x01\xff\x04\x00\x00\x00\x00\x00\x00\x04\x00\x01\x00\x00\x00\x00\x04\x00\x02\x00\x00\x00\x00\xff\x02\x00\x00\x02\x02\x02\x06\x00\x02\x02\x02\x00\x01\x02\x02\x02\x06\x01\x02\x02\x08\x00\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02\x00\x03\x02\x02\x02\x06\x03\x02\x02\xff\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\xff\x04\x00\x00\x00\x03\x03\x00\x04\x00\x01\x03\x00\x00\x03\x04\x00\x02\x00\x03\x03\x00\xff\x04\x00\x00\x00\x00\x00\x00\x04\x00\x01\x00\x00\x00\x00\x04\x00\x02\x00\x00\x00\x00\xff\x01\x00\x00\x01\x01\x01\x01\x01\x01\x00\x02\x01\x01\x01\x03\x01\xff\x01\x00\x00\x02\x01\x00\x01\x02\x01\x01\x02\x02\x01\x01\x03\x02\xff\x02\x00\x00\x00\x00\x02\x00\x01\x00\x00\x02\x00\x02\x00\x00\x02\x00\x03\x00\x00\xff",
dtype=np.uint8)
r = SegmentData(data)
segments = [DefaultSegment(r, 0x4000)]
self.builder = JumpmanLevelBuilder(segments)
def rebuild(self):
v = self.virtual_linked_base
emu = v.emulator
self.current_num_rows = len(emu.cpu_history)
segment = DefaultSegment(emu.cpu_history.entries.view(np.uint8))
v.segment = segment
print("CPU HISTORY ENTRIES", self.current_num_rows)
self.init_boundaries()
def __init__(self, parent, task, bytes_per_row=16, command=None, **kwargs):
FontMapScroller.__init__(self, parent, task, bytes_per_row, command,
**kwargs)
self.char_order = DefaultSegment(
SegmentData(np.arange(256, dtype=np.uint8),
np.zeros(256, dtype=np.uint8)), 0)
self.start_addr = 0
self.selected_char = -1
def get_break(self, section_break):
data = np.empty(32, dtype=np.uint8)
data[0:section_break] = 0x8d
data[section_break:] = 0xfc
style = np.empty(32, dtype=np.uint8)
style[0:section_break] = 0
style[section_break:] = 1
raw = SegmentData(data, style)
segment = DefaultSegment(raw, 0)
return segment
def test_indexed_sub(self):
base = self.segment
assert not base.rawdata.is_indexed
raw = base.rawdata[512:1536] # 1024 byte segment
sub = DefaultSegment(raw, 512)
assert not sub.rawdata.is_indexed
for i in range(len(sub)):
ri = sub.get_raw_index(i)
assert ri == sub.origin + i
assert sub[i] == base[ri]
start, end = sub.byte_bounds_offset()
assert start == 512
assert end == 1536
with pytest.raises(IndexError) as e:
# attempt to get indexes to 1024 * 3... Index to big => fail!
s, indexes = get_indexed(sub, 1024, 3)
# try with elements up to 256 * 3
s, indexes = get_indexed(sub, 256, 3)
print(sub.data)
print(indexes)
print(s.data[:])
assert s.rawdata.is_indexed
for i in range(len(indexes)):
ri = s.get_raw_index(i)
print(ri, "base[ri]=%d" % base[ri], i, indexes[i],
"s[i]=%d" % s[i])
assert ri == sub.origin + indexes[i]
assert s[i] == base[ri]
start, end = s.byte_bounds_offset()
assert start == 0
assert end == len(base)
# get indexed into indexed, will result in every 9th byte
s2, indexes2 = get_indexed(s, 64, 3)
assert s2.rawdata.is_indexed
for i in range(len(indexes2)):
assert s2.get_raw_index(i) == sub.origin + indexes2[i] * 3
start, end = s.byte_bounds_offset()
assert start == 0
assert end == len(base)
def parse(self):
r = self.segment_data
self.segments.append(self.container_segment(r, 0, name=self.menu_name))
for start, count, offset, name in self.save_state_memory_blocks:
if count > 0:
print(
f"creating emulator segment {name} at {hex(start)}:{hex(start + count)}"
)
self.segments.append(
DefaultSegment(r[start:start + count], offset, name))
def test_indexed_sub(self):
base = self.segment
assert not base.rawdata.is_indexed
raw = base.rawdata[512:1536] # 1024 byte segment
sub = DefaultSegment(raw, 512)
assert not sub.rawdata.is_indexed
for i in range(len(sub)):
ri = sub.get_raw_index(i)
assert ri == sub.start_addr + i
assert sub[i] == base[ri]
start, end = sub.byte_bounds_offset()
assert start == 512
assert end == 1536
with pytest.raises(IndexError) as e:
# attempt to get indexes to 1024 * 3... Index to big => fail!
s, indexes = get_indexed(sub, 1024, 3)
# try with elements up to 256 * 3
s, indexes = get_indexed(sub, 256, 3)
print sub.data
print indexes
print s.data[:]
assert s.rawdata.is_indexed
for i in range(len(indexes)):
ri = s.get_raw_index(i)
print ri, "base[ri]=%d" % base[ri], i, indexes[i], "s[i]=%d" % s[i]
assert ri == sub.start_addr + indexes[i]
assert s[i] == base[ri]
start, end = s.byte_bounds_offset()
assert start == 0
assert end == len(base)
# get indexed into indexed, will result in every 9th byte
s2, indexes2 = get_indexed(s, 64, 3)
assert s2.rawdata.is_indexed
for i in range(len(indexes2)):
assert s2.get_raw_index(i) == sub.start_addr + indexes2[i] * 3
start, end = s.byte_bounds_offset()
assert start == 0
assert end == len(base)
def expand_container(self, size):
c = self.container_segment
if c.can_resize:
oldsize, newsize = c.resize(size)
for s in self.contained_segments:
s.replace_data(c)
self.raw_bytes = c.data
start, end = oldsize, newsize
r = c.rawdata[start:end]
s = DefaultSegment(r, 0)
return s
def test_s1(self):
s = self.segment
s.set_comment([[4,5]], "test1")
s.set_comment([[40,50]], "test2")
s.set_style_ranges([[2,100]], comment=True)
s.set_style_ranges([[200, 299]], data=True)
for i in range(1,4):
for j in range(1, 4):
# create some with overlapping regions, some without
r = [500*j, 500*j + 200*i + 200]
s.set_style_ranges([r], user=i)
s.set_user_data([r], i, i*10 + j)
r = [100, 200]
s.set_style_ranges([r], user=4)
s.set_user_data([r], 4, 99)
r = [3100, 3200]
s.set_style_ranges([r], user=4)
s.set_user_data([r], 4, 99)
out = dict()
s.serialize_extra_to_dict(out)
print "saved", out
data = np.ones([4000], dtype=np.uint8)
r = SegmentData(data)
s2 = DefaultSegment(r, 0)
s2.restore_extra_from_dict(out)
out2 = dict()
s2.serialize_extra_to_dict(out2)
print "loaded", out2
assert out == out2
def test_subset(self):
# check to see data a view of some rawdata will be the same when the
# rawdata is resized.
c = self.container
assert not c.rawdata.is_indexed
offset = 1000
s = DefaultSegment(c.rawdata[offset:offset + offset], 0)
assert not s.rawdata.is_indexed
# Check that the small view has the same data as its parent
for i in range(offset):
assert s[i] == c[i + offset]
# keep a copy of the old raw data of the subset
oldraw = s.rawdata.copy()
oldid = id(s.rawdata)
requested = 8192
oldsize, newsize = c.resize(requested)
assert newsize == requested
s.replace_data(
c) # s should point to the same offset in the resized data
assert id(s.rawdata) == oldid # segment rawdata object should be same
assert id(oldraw.order) == id(s.rawdata.order) # order the same
for i in range(offset): # check values compared to parent
assert s[i] == c[i + offset]
# check for changes in parent/view reflected so we see that it's
# pointing to the same array in memory
newbase = c.rawdata
newsub = s.rawdata
print(c.rawdata.data[offset:offset + offset])
print(s.rawdata.data[:])
s.rawdata.data[:] = 111
print(c.rawdata.data[offset:offset + offset])
print(s.rawdata.data[:])
for i in range(offset):
assert s[i] == c[i + offset]
def __init__(self, parent, id, title):
wx.Frame.__init__(self, parent, id, title, wx.DefaultPosition,
wx.DefaultSize)
data = np.arange(0x800, dtype=np.uint8)
data[0:0x50] = np.fromstring(
"01\x1b1\x1b1\x1b1\xa0I\xc6\x94\xaax\x0f\x00\x00B\x80E\x1b1\xe00:\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Ws\x8e\xab\x00\x00\x86\x86\x0fT\x86\x8a\xff\xca\x00d\x00\xd0\x07\x00,F,\x80(\x01\x10L\xfdO!\x00\x00L\x00\x00 K(`\xff\x00\x8e,",
dtype=np.uint8)
data[0x3ec:0x400] = np.fromstring("abdceabdceabcdeabcde",
dtype=np.uint8)
r = SegmentData(data)
segment = DefaultSegment(r, 0x2800)
editor = MockEditor(segment)
task = MockTask(editor)
self.info = InfoPanel(self, task, fields)
self.info.recalc_view()
class TestSegment:
def setup(self):
data = np.ones([4000], dtype=np.uint8)
r = SegmentData(data)
self.segment = DefaultSegment(r, 0)
def test_getstate(self):
state = self.segment.__getstate__()
for k, v in state.items():
print("k=%s v=%s type=%s" % (k, v, type(v)))
byte_type = type(str(u' ').encode('utf-8')) # py2 and py3
try:
u = unicode(" ")
except:
u = str(" ")
assert type(state['uuid']) == type(u)
def test_extra(self):
s = self.segment
s.set_comment([[4,5]], "test1")
s.set_comment([[40,50]], "test2")
s.set_style_ranges([[2,100]], comment=True)
s.set_style_ranges([[200, 299]], data=True)
for i in range(1,4):
for j in range(1, 4):
# create some with overlapping regions, some without
r = [500*j, 500*j + 200*i + 200]
s.set_style_ranges([r], user=i)
s.set_user_data([r], i, i*10 + j)
r = [100, 200]
s.set_style_ranges([r], user=4)
s.set_user_data([r], 4, 99)
r = [3100, 3200]
s.set_style_ranges([r], user=4)
s.set_user_data([r], 4, 99)
out = dict()
s.serialize_session(out)
print("saved", out)
data = np.ones([4000], dtype=np.uint8)
r = SegmentData(data)
s2 = DefaultSegment(r, 0)
s2.restore_session(out)
out2 = dict()
s2.serialize_session(out2)
print("loaded", out2)
assert out == out2
def test_bad(self):
data = np.fromstring("\x8dp0L\xaa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00pppM\x00p\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\x8d\x8d\x06\x16\x8e\r", dtype=np.uint8)
style = np.empty(len(data), dtype=np.uint8)
style[0:17] = 0
style[17:] = 2
raw = SegmentData(data, style)
s = DefaultSegment(raw, 0x3bef)
info = self.disasm.disassemble_segment(s)
inst = info.instructions
for i in range(info.num_instructions):
print(info[i].instruction)
text = self.disasm.get_disassembled_text()
print("\n".join(text))
text = self.disasm.get_atasm_lst_text()
print("\n".join(text))
def get_exe_segments(self):
data1 = np.arange(4096, dtype=np.uint8)
data1[1::2] = np.repeat(np.arange(16, dtype=np.uint8), 128)
data2 = np.arange(4096, dtype=np.uint8)
data2[0::4] = np.repeat(np.arange(8, dtype=np.uint8), 128)
raw = [
(data1, 0x4000),
(data2, 0x8000),
]
segments = []
for data, origin in raw:
rawdata = SegmentData(data)
s = DefaultSegment(rawdata, origin)
segments.append(s)
return segments
def test_segment(self):
bytes = np.asarray([0xff, 0xff, 0x00, 0x60, 0x01, 0x60, 1, 2],
dtype=np.uint8)
rawdata = SegmentData(bytes)
container = XexContainerSegment(rawdata, 0)
image = AtariDosFile(container.rawdata)
image.parse_segments()
print(image.segments)
assert len(image.segments) == 1
assert len(image.segments[0]) == 2
assert np.all(image.segments[0] == bytes[6:8])
container.resize(16)
for s in image.segments:
s.replace_data(container)
new_segment = DefaultSegment(rawdata[8:16])
new_segment[:] = 99
assert np.all(image.segments[0] == bytes[6:8])
print(new_segment[:])
assert np.all(new_segment[:] == 99)
def setup(self):
data = np.arange(32, dtype=np.uint8)
style = np.zeros(32, dtype=np.uint8)
raw = SegmentData(data, style)
segment = DefaultSegment(raw, 0)
self.editor = MockHexEditor(segment=segment)
def _segments_default(self):
r = SegmentData(self.raw_bytes,self.style)
return list([DefaultSegment(r, 0)])
def __init__(self, *args, **kwargs):
DefaultSegment.__init__(self, *args, **kwargs)
if np.alen(self.data) != 1024:
raise RuntimeError("ANTIC Fonts must be 1024 bytes; have %d bytes" % (np.alen(self.data)))
def setup(self):
data = np.ones([4000], dtype=np.uint8)
r = SegmentData(data)
self.segment = DefaultSegment(r, 0)
def setup(self):
data = np.arange(256, dtype=np.uint8)
style = np.zeros(256, dtype=np.uint8)
raw = SegmentData(data, style)
s = DefaultSegment(raw, 0)
s.set_style_ranges([
(10, 20),
], data=True)
s.set_style_ranges([
(30, 40),
], user=1)
s.set_comment([(0, 5)], "comment 0-5")
s.set_comment([(15, 16)], "comment 15-16")
s.set_comment([(18, 24)], "comment 18,24")
s.set_comment([(38, 42)], "comment 38,42")
s.set_comment([(51, 55)], "comment 51,55")
self.editor = MockHexEditor(segment=s)
def Getaway(doc):
if doc.bytes[8] == 0x82 and doc.bytes[9] == 0x39:
state = doc.bytes[12:16] == [0x67, 0x21, 0x70, 0x64]
if state.all():
log.debug("Found Omnivore-enabled public domain getaway.xex!!!")
version = doc.bytes[16]
num_words = doc.bytes[17]
words = doc.bytes[18:18 + num_words * 2].copy().view(dtype='<u2')
r = doc.segments[0].rawdata
if version in supported_pd_getaway:
log.debug("Found supported version %d" % version)
else:
latest = reduce(max, supported_pd_getaway)
log.debug("Unsupported version %d; trying latest %d" %
(version, latest))
version = latest
playfield = words[0]
playfield_font = words[1]
log.debug("playfield address: %04x, font address: %04x" %
(playfield, playfield_font))
log.debug(doc)
segments = doc.find_segments_in_range(playfield)
if not segments:
log.error("playfield not found at %04x in any segment" %
playfield)
return
_, s, _ = segments[0]
i = s.get_raw_index_from_address(playfield)
segment = DefaultSegment(r[i:i + 0x4000],
playfield,
name="Playfield map")
segment.map_width = 256
segments = doc.find_segments_in_range(playfield_font)
if not segments:
log.error("playfield font not found at %04x in any segment" %
playfield_font)
return
_, s, _ = segments[0]
i = s.get_raw_index_from_address(playfield_font)
font_segment = AnticFontSegment(r[i:i + 0x400],
playfield_font,
name="Playfield font")
return getaway_metadata(font_segment, segment)
state = doc.bytes[0:6] == [0xff, 0xff, 0x80, 0x2a, 0xff, 0x8a]
if state.all():
log.debug("Found getaway.xex!!!")
r = doc.segments[0].rawdata
font_segment = AnticFontSegment(r[0x086:0x486],
0x2b00,
name="Playfield font")
#doc.add_user_segment(font_segment)
segment = DefaultSegment(r[0x2086:0x6086],
0x4b00,
name="Playfield map")
segment.map_width = 256
#doc.add_user_segment(segment)
return getaway_metadata(font_segment, segment)
state = doc.bytes[0x10:0x19] == [
0x00, 0xc1, 0x80, 0x0f, 0xcc, 0x22, 0x18, 0x60, 0x0e
]
if state.all():
log.debug("Found getaway.atr!!!")
r = doc.segments[0].rawdata
font_segment = AnticFontSegment(r[0x090:0x490],
0x2b00,
name="Playfield font")
#doc.add_user_segment(font_segment)
segment = DefaultSegment(r[0x2090:0x6090],
0x4b00,
name="Playfield map")
segment.map_width = 256
#doc.add_user_segment(segment)
return getaway_metadata(font_segment, segment)
def setup(self):
data = np.arange(2048, dtype=np.uint8)
self.segment = DefaultSegment(SegmentData(data))
def setup(self):
data = np.arange(2048, dtype=np.uint8)
self.segment = DefaultSegment(SegmentData(data))
def setup(self):
data = np.arange(4096, dtype=np.uint8)
data[1::2] = np.repeat(np.arange(16, dtype=np.uint8), 128)
r = SegmentData(data)
self.segment = DefaultSegment(r, 0)
def setup(self):
self.segments = []
for i in range(8):
data = np.ones([1024], dtype=np.uint8) * i
r = SegmentData(data)
self.segments.append(DefaultSegment(r, i * 1024))
def setup(self):
data = np.ones([4000], dtype=np.uint8)
r = SegmentData(data)
self.segment = DefaultSegment(r, 0)
assert grid_color_indexes.shape == (grid_height, pixels_per_row)
rgb_image = pc.calc_rgb_from_color_indexes_python(
grid_color_indexes, grid_style, color_list, empty_rgb)
assert rgb_image.shape == (grid_height, pixels_per_row, 3)
fast_rgb_image = fast_pc.calc_rgb_from_color_indexes(
grid_color_indexes, grid_style, color_list, empty_rgb)
assert (np.array_equal(rgb_image, fast_rgb_image))
if __name__ == "__main__":
data = np.arange(64, dtype=np.uint8)
style = np.zeros(64, dtype=np.uint8)
raw = SegmentData(data, style)
segment = DefaultSegment(raw, 0)
print(data)
ppb = 8
pixels_per_row = 16
bytes_per_row = pixels_per_row // ppb
c = pc.Converter1bpp()
grid_color_indexes, grid_style = c.calc_color_index_grid(
data, style, bytes_per_row)
print(grid_color_indexes)
ppb = 4
pixels_per_row = 16
bytes_per_row = pixels_per_row // ppb
c = pc.Converter2bpp()
grid_color_indexes, grid_style = c.calc_color_index_grid(
def replace_linked_base(cls, linked_base):
# the new linked base decouples the cursor here from the other segments
segment = DefaultSegment(np.arange(400, dtype=np.uint8))
return VirtualTableLinkedBase(editor=linked_base.editor,
segment=segment)
def setup(self):
data = np.arange(256, dtype=np.uint8)
style = np.zeros(256, dtype=np.uint8)
raw = SegmentData(data, style)
s = DefaultSegment(raw, 0)
s.set_style_ranges([(10,20),], data=True)
s.set_style_ranges([(30,40),], user=1)
s.set_comment([(0,5)], "comment 0-5")
s.set_comment([(15,16)], "comment 15-16")
s.set_comment([(18,24)], "comment 18,24")
s.set_comment([(38,42)], "comment 38,42")
s.set_comment([(51,55)], "comment 51,55")
self.editor = MockHexEditor(segment=s)
def setup(self):
data = np.arange(16, dtype=np.uint8)
style = np.zeros(16, dtype=np.uint8)
self.editor = MockEditor(DefaultSegment(data, style, 0))
def get_indexed(segment, num, scale):
indexes = np.arange(num) * scale
raw = segment.rawdata.get_indexed(indexes)
s = DefaultSegment(raw, segment.start_addr + indexes[0])
return s, indexes
