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(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))
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