def test_value_init(self):
bitmap = Bitmap(value=10)
self.assertEqual(len(bitmap), 4)
self.assertEqual(bitmap.value, 10)
bitmap = Bitmap(size=0, value=14)
self.assertEqual(len(bitmap), 4)
self.assertEqual(bitmap.value, 14)
def test_instantination(self):
self.assertRaises(BaseException, Bitmap, ())
self.assertRaises(BaseException, Bitmap, ('s', ))
self.assertRaises(BaseException, Bitmap, (1, ))
self.assertIsInstance(Bitmap(0), Bitmap) # int
self.assertIsInstance(Bitmap(Bitmap(8)), Bitmap) # Bitmap
self.assertIsInstance(Bitmap(bytes(2)), Bitmap) # bytes,
self.assertIsInstance(Bitmap(bytearray(2)), Bitmap) # bytearray
def test_invalid_size(self):
with self.assertRaises(TypeError):
_ = Bitmap(size=7.0) # type: ignore
with self.assertRaises(TypeError):
_ = Bitmap(size='0b111') # type: ignore
with self.assertRaises(TypeError):
_ = Bitmap(size=[7]) # type: ignore
# size < len(bin(value))
with self.assertRaises(ValueError):
_ = Bitmap(size=3, value=10)
def __init__(self, width, height):
super(Desktop, self).__init__(
0, 0, width, height,
WND_ONLY_CLIENT | WND_KEEP_BOTTOM | WND_KEEP_INACTIVE)
self.im = Bitmap('img/cheetah.png')
dirname = 'img/desktop-icons'
self.icons = [
Bitmap(os.path.join(dirname, fname)).scaledToWidth(ICON_SIZE)
for fname in os.listdir(dirname) if fname.startswith('icon-')
]
self.proc_names = ['pa', 'pb', 'pc']
self.cur_icon = None
self.wnds = []
def __init__(self, video_mem, qt_callback):
self.qcommunicate = QCommunicate()
self.qcommunicate.signal.connect(qt_callback)
self.video_mem = video_mem
self.screen = Bitmap(SCREEN_WIDTH, SCREEN_HEIGHT)
self.wnds = []
self.dragging_wnd = None
self.windows_change_listener = []
self.mouse_img = im = Bitmap('img/mouse.png')
self.mouse_x = 0
self.mouse_y = 0
def create_bitmap(
self,
offset: int,
row_width: int,
start_column: int,
start_row: int,
visible_rows: int,
visible_columns: int,
) -> Optional[Bitmap]:
if self._data is None:
return
start = start_row * row_width + start_column + offset
num_rows = min(ceil(
(self.num_bits - start) / row_width), visible_rows + 1) - 1
bits_per_row = min(row_width, visible_columns)
bytes_per_row = ceil(bits_per_row / 8)
mask = 2**(bytes_per_row * 8) - 1
result = bytearray()
for _ in range(num_rows):
result.extend(self._get_row_bytes(start, bytes_per_row, mask))
start += row_width
remainder = []
last_byte = start // 8 + bytes_per_row
if last_byte < len(self._data):
result.extend(self._get_row_bytes(start, bytes_per_row, mask))
else:
remainder = self._get_end_bits(start)
return Bitmap(result, bits_per_row, bytes_per_row, remainder)
def get_bitmap_of_circles_on_AABB(size_in_bits, center, step, poss, rad):
corner = bitmap_corner_from_center(center, size_in_bits, step)
bitmap = Bitmap(None, size_in_bits, corner, step)
is_circle = bitmap.bits
rad_in_bits = math.ceil(rad * bitmap.inv_step)
for circle_index in range(len(poss)):
circle_center = poss[circle_index]
bit_center = bitmap.indices_from_pos(circle_center)
for dx in range(-rad_in_bits, rad_in_bits + 1):
for dy in range(-rad_in_bits, rad_in_bits + 1):
bit_pos = vec_add(bit_center, (dx, dy))
if not bitmap.are_indices_in_bounds(bit_pos):
continue # `bit_pos` isn't in bitmap.
corner_a, corner_b = bitmap.get_bit_corners(bit_pos)
is_touching = is_circle_touching_AABB(bit_center, rad_in_bits,
corner_a, corner_b)
bit_index = bitmap.index_from_indices(bit_pos)
is_circle[bit_index] = (is_circle[bit_index] or is_touching)
return bitmap
def Save_im():
global im_choose, imtk, lb2, lb7, save_str
im_save = Bitmap(512, 512)
im_save.setPixel(np.uint8(im_choose))
im_save.write(save_str)
lb7 = tk.Label(window, text = '- Done saving bmp -',
width=20, height=1).place(x = 362, y = 60)
def test_invalid_value(self):
bitmap = Bitmap(size=10, value=10)
with self.assertRaises(TypeError):
bitmap.value = 7.0 # type: ignore
with self.assertRaises(TypeError):
bitmap.value = '0b111' # type: ignore
with self.assertRaises(TypeError):
bitmap.value = [7] # type: ignore
# value < 0
with self.assertRaises(ValueError):
bitmap.value = -1
# value >= (1 << size)
with self.assertRaises(ValueError):
bitmap.value = 1024
with self.assertRaises(TypeError):
_ = Bitmap(value=(10, )) # type: ignore
def test_flip_bit(self):
bitmap = Bitmap(value=10)
bitmap.flip_bit(2)
bitmap.flip_bit(1)
self.assertEqual(bitmap.get_bit(2), 1)
self.assertEqual(bitmap.get_bit(1), 0)
self.assertEqual(bitmap.value, 12)
def __init__(self, x, y, mode, fileName, scene, parent=None):
super(AddItemCommand, self).__init__(parent)
from designerscene import DesignerScene
from rectangle import Rectangle
from ellipse import Ellipse
from text import Text
from bitmap import Bitmap
from vectorgraphic import Vectorgraphic
self.scene = scene
self.item = None
if mode == DesignerScene.RECTANGLE:
self.item = Rectangle(self.scene)
self.item.setId("Rectangle")
self.item.setPen(QPen(Qt.black))
self.item.setBrush(QBrush(Qt.blue))
self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.item.setPos(x, y)
self.item.setWidth(50)
self.item.setHeight(50)
self.setText("Add Rectangle")
elif mode == DesignerScene.ELLIPSE:
self.item = Ellipse(self.scene)
self.item.setId("Ellipse")
self.item.setPen(QPen(Qt.black))
self.item.setBrush(QBrush(Qt.blue))
self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.item.setPos(x, y)
self.item.setWidth(50)
self.item.setHeight(50)
self.setText("Add Ellipse")
elif mode == DesignerScene.TEXT:
self.item = Text("Lorem ipsum dolor", self.scene)
self.item.setId("Text")
self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.item.setPos(x, y)
self.setText("Add Text")
elif mode == DesignerScene.BITMAP:
self.item = Bitmap(fileName, self.scene)
self.item.setId("Bitmap")
self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.item.setPos(x, y)
self.setText("Add Bitmap")
elif mode == DesignerScene.SVG:
self.item = Vectorgraphic(fileName, self.scene)
self.item.setId("Vectorgraphic")
self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.item.setPos(x, y)
self.setText("Add Vectorgraphic")
def getfile(event, new_file, parent):
#print(event)
printk("getfile('%s')" % event.filename)
new_file.med_oact = Bitmap(b'\xff\xff')
new_file.update()
print(event.filename)
print(new_file)
return MED_OK
def test_invalid_v(self):
bitmap = Bitmap(value=10)
with self.assertRaises(ValueError):
bitmap.update_bit(2, 2)
with self.assertRaises(ValueError):
bitmap.update_bit(1, None) # type: ignore
with self.assertRaises(ValueError):
bitmap.update_bit(0, '1') # type: ignore
def __init__(self, wnd, gui):
self.init(wnd.x(), wnd.y(), wnd.width(), wnd.height(), wnd.attr(),
wnd.border_width(), wnd.caption_height())
self.wnd = wnd
self.gui = gui
bitmap = Bitmap(wnd.window_width(), wnd.window_height())
self.bitmap = wnd.bitmap = bitmap
self.dragging = False
def handleBitmap(x, convertBitmap):
"""Handling AfterUnpack & BeforePack functionality"""
if not isinstance(x, Bitmap) or (isinstance(x, Bitmap) and convertBitmap):
x = Bitmap(x)
if convertBitmap:
x.bytereverse()
return x
def load_bitmap(file) :
words = open(file).readlines()
words = map(lambda x: x.strip(), words)
bmap = Bitmap(2**20)
for word in words :
hashes = make_hashes(word)
for hash in hashes :
bmap.setBit(hash)
return bmap
def getprocess(event, parent):
if parent.gid == 0:
printk("getprocess: parent gid ROOT")
else:
printk("getprocess: change parent gid %d of '%s' to ROOT" % (parent.gid, parent.cmdline))
parent.gid = 0
parent.med_oact = Bitmap(16)
parent.med_oact.fill()
parent.med_sact = Bitmap(16)
parent.med_sact.fill()
parent.update()
print(parent)
tmp = Process()
print(tmp)
#print(event)
#print(parent)
return MED_OK
def loadBitmap(file):
# generate bitmap from lexicon file (one word per line)
words = open(file).readlines()
words = map(lambda x: x.strip(), words) # no newlines please
bmap = Bitmap(2**20)
for word in words:
hashes = makeHashes(word)
for hash in hashes:
bmap.setBit(hash)
return bmap
def read_bitmaps(self, bitmapIDs):
for i in range(self.numBitmapRecords):
bitmap = Bitmap(self.filePath, self.offset)
if bitmap.filename not in bitmapIDs:
self.bitmaps.append(bitmap)
bitmapIDs.add(bitmap.filename)
self.offset = bitmap.offset
# assert(self.bitmaps[-1].endIndex == self.numImageRecords)
if self.bitmaps[-1].endIndex != self.numImageRecords:
warning(
f"endIndex ({self.bitmaps[-1].endIndex}) did not match numImageRecords ({self.numImageRecords})"
)
def string_bitmap(text):
"""
Like char_bitmap() but takes a string and returns a bitmap of the entire word.
The resulting width will by len(text) * 8, and height 7.
See bitmap.py
"""
bm = Bitmap(WIDTH * len(text), HEIGHT)
for i, char in enumerate(text):
bm.apply(char_bitmap(char), x=i * WIDTH, y=0)
return bm
def test_invalid_i(self):
bitmap = Bitmap(size=10, value=10)
with self.assertRaises(TypeError):
_ = bitmap.get_bit(2.0) # type: ignore
with self.assertRaises(TypeError):
bitmap.set_bit('0b0010') # type: ignore
with self.assertRaises(TypeError):
bitmap.clear_bit([2]) # type: ignore
# i < 0
with self.assertRaises(ValueError):
bitmap.flip_bit(-1)
# i >= size
with self.assertRaises(ValueError):
_ = bitmap.get_bit(10)
def char_bitmap(char):
"""
Given a single character, generate a Bitmap of that font. This will be width 8, height 7.
See bitmap.py
"""
char_def = DATA.get(char, DATA[FALLBACK_CHAR])
assert len(
char_def) == WIDTH * HEIGHT, "bad char definition for char '%s'" % char
bm = Bitmap(WIDTH, HEIGHT)
for y in range(HEIGHT):
for x in range(WIDTH):
bm.data[y][x] = 0 if char_def[x + (y * WIDTH)] == ' ' else 1
return bm
def __init__(self,image=None,**params):
super(Plot,self).__init__(**params)
self._orig_bitmap = Bitmap(image)
self.bitmap = self._orig_bitmap # Possibly scaled copy (at first identical)
self.scale_factor=1.0
self.plot_src_name = ''
self.precedence = 0.0
self.row_precedence = 0.5
# If False, this plot should be left in its native size
# pixel-for-pixel, (e.g. for a color key or similar static
# image), rather than being resized as necessary.
self.resize=False
# Time at which the bitmaps were created
self.timestamp = -1
def test_update_bit(self):
bitmap = Bitmap(value=10)
# `True` and `1` are equivalent in the bitmap
# bit was already 1
bitmap.update_bit(3, 1)
self.assertEqual(bitmap.get_bit(3), 1)
# new bit set to 1
bitmap.update_bit(2, True)
self.assertEqual(bitmap.get_bit(2), 1)
# `False` and `0` are equivalent in the bitmap
# new bit set to 0
bitmap.update_bit(1, False)
self.assertEqual(bitmap.get_bit(1), 0)
# bit was already 1
bitmap.update_bit(0, 0)
self.assertEqual(bitmap.get_bit(0), 0)
self.assertEqual(bitmap.value, 12)
def main():
width = 512
gens = 512
seed()
a = Automata(int(input('Введите правило: ')))
mode = input('Режим: из одной точки p, случайное заполнение r: ')
if mode == 'r':
a.random()
elif mode == 'p':
a.cells[width // 2] = True
else:
print('Неправильный режим')
b = Bitmap(width=width, height=gens)
for gen in range(0, gens):
for i in range(0, width):
b.setPixel(i, gen, BLACK if a.cells[i] else WHITE)
a.do_gen()
b.write('file.bmp')
def main():
text = ' '.join(argv[1:])
if not text:
stderr.write('ERROR: missing text\n')
exit(1)
one_year_ago = date.today() - timedelta(days=365)
while one_year_ago.weekday() != 6: # go to start of week (sunday)
one_year_ago -= timedelta(days=1)
canvas = Bitmap(width=52, height=7) # year of weeks
label = string_bitmap(text)
canvas.apply(label, x=canvas.width - label.width) # right align
if label.width > canvas.width:
stderr.write('WARNING: text truncated\n')
stderr.write('preview:\n\n')
canvas.dump(stderr)
print('#!/bin/bash')
print('set -euo pipefail')
print('echo "Generating a bunch of git commits..."')
print('git init')
n = 0
for contrib_date in bitmap_to_contribution_dates(canvas, one_year_ago):
stamp = datetime.combine(contrib_date, time(12, 0)).isoformat()
for i in range(commits_per_pixel):
print('echo {} > .greendot'.format(n))
print('git add .greendot')
print(
'GIT_COMMITTER_DATE="{}" GIT_AUTHOR_DATE="{}" git commit -m "greendot {}"'
.format(stamp, stamp, n))
n += 1
print('echo "All done. Commits: {}"'.format(n))
def test_set_bit(self):
bm = Bitmap(16) # bitmap = 00000000
self.assertEqual(16, bm.length())
self.assertFalse(bm.all())
self.assertFalse(bm.any())
bm[0] = True # bitmap = 10000000
self.assertFalse(bm.all())
self.assertTrue(bm.any())
self.assertTrue(bm[0])
self.assertFalse(bm[1])
bm.setall(True)
self.assertTrue(bm.any())
self.assertTrue(bm.all())
bm[0] = False
self.assertFalse(bm.all())
self.assertTrue(bm.any())
bm.setall(False)
self.assertFalse(bm.any())
self.assertFalse(bm.any())
def __init__(self):
self.im = im = Bitmap('img/girl.jpg')
super(WndA, self).__init__(-9, -9, 400, 300)
self.set_title('Yurisa')
def glCreateWindow(self, width, height):
self.bmp = Bitmap(width, height)
self.width = width
self.height = height
ap = argparse.ArgumentParser()
ap.add_argument("--height", type=int, required=False, help="Height of the canvas")
ap.add_argument("--width", type=int, required=False, help="Width of the Canvas")
ap.add_argument("--char", type=str, required=False, help="character of cell(default='@')")
ap.add_argument("--ratio", type=float, required=False, help="probability of population in initial population")
args = ap.parse_args()
width = args.width or 45
height = args.height or 20
char = args.char or '@'
ratio = args.ratio or 0.85
cells = Bitmap(width, height, char=char)
def random_cells():
for i in range(width):
for j in range(height):
if(random.random() > ratio):
cells.set(i, j)
def glider():
cells.set(1, 1)
cells.set(2, 2)
cells.set(3, 2)
cells.set(2, 3)
cells.set(1, 3)
def count_neigh(x, y, new_map):
