def __init__(self, over, under):
Top.__init__(self, find_bounding_box(over + under))
from block import Block
self.over = Block(over)
self.under = Block(under)
def __init__(self, adjStats = string.ascii_letters + ' ', noisy = False):
# Load it...
if noisy: print 'Reading in ply2 corpus file...'
data = read(os.path.join(os.path.dirname(__file__),'corpus.ply2'))
# Convert contents into a list of blocks...
self.blocks = []
t_arr = data['element']['document']['text']
a_arr = data['element']['document']['attribution']
if noisy:
print 'Creating blocks...'
for i in xrange(t_arr.shape[0]):
b = Block(t_arr[i], a_arr[i])
self.blocks.append(b)
# Construct all statistics - this gets complicated for reasons of efficiency...
if noisy:
print 'Collecting statistics...'
self.counts = numpy.zeros(256, dtype=numpy.int32)
self.adj = numpy.zeros((len(adjStats),len(adjStats)), dtype=numpy.int32)
self.adj_index = adjStats
for b in self.blocks:
b.stats(self.counts, self.adj, self.adj_index)
def _block_real_name(self):
if type(self._block) is str:
return Block.to_real_name(Block.from_full_name(self._block)[1])
elif self._block is None:
return None
else:
return self._block.real_name()
class Game: def __init__( self, scr, loop ): self.scr = scr from block import Block self.block = Block( scr ) from message import Messages self.msg = Messages( self.scr ) self.loop = loop self.FPS = 60 self.block( self, self.loop ) def update( self ): lasttime = time.time( ) self.block.update( ) self.FPS = 1.0 / ( time.time( ) - lasttime ) def draw( self ): scr = self.scr scr.fill( ( 35, 35, 35 ) ) self.block.draw( ) self.msg.message( round( self.FPS, 1 ), ( 10, 10 ) )
def make_updated_block_for_site(transformation_matrix,
operators_to_add_to_block):
"""Make a new block for a list of operators.
Takes a dictionary of operator names and matrices and makes a new
block inserting in the `operators` block dictionary the result of
transforming the matrices in the original dictionary accoring to the
transformation matrix.
You use this function everytime you want to create a new block by
transforming the current operators to a truncated basis.
Parameters
----------
transformation_matrix : a numpy array of ndim = 2.
The transformation matrix coming from a (truncated) unitary
transformation.
operators_to_add_to_block : a dict of strings and numpy arrays of ndim = 2.
The list of operators to transform.
Returns
-------
result : a Block.
A block with the new transformed operators.
"""
cols_of_transformation_matrix = transformation_matrix.shape[1]
result = Block(cols_of_transformation_matrix)
for key in operators_to_add_to_block.keys():
result.add_operator(key)
result.operators[key] = transform_matrix(operators_to_add_to_block[key],
transformation_matrix)
return result
def __init__(self, size):
"""Initialize board:
argument: size
"""
self.size = size
self.side = BLACK
self.goban = {} #actual board
self.init_hash()
#Create and initialize board as empty size*size
for pos in self.iterate_goban():
#can't use set_goban method here, because goban doesn't yet really exists
self.goban[pos] = EMPTY
self.current_hash = self.current_hash ^ self.board_hash_values[EMPTY, pos]
self.blocks = {} #blocks dictionary
#Create and initialize one whole board empty block
new_block = Block(EMPTY)
for pos in self.iterate_goban():
new_block.add_stone(pos)
self.block_dict = {}
self.add_block(new_block)
self.chains = {}
self.stone_count = {}
for color in EMPTY+BLACK+WHITE:
self.stone_count[color] = 0
self.ko_flag = PASS_MOVE
BoardAnalysis.__init__(self)
def compute_blocks(self):
"""
Compute the set of blocks that C infer
return: Topologically sorted blocks T_c
"""
timer_start('Compute blocks')
T_c = list()
T_unions = set()
# iterate the combination sizes in reverse
a = range(len(self.C)+1)[::-1]
for i in a:
choose = i
for comb in combinations(self.C, choose):
union = itemsets.union_of_itemsets(comb)
if not union in T_unions:
T_unions.add(union)
T = Block()
T.union_of_itemsets = union
T.singletons = itemsets.singletons_of_itemsets(comb)
T.itemsets = set(comb)
T_c.append(T)
timer_stop('Compute blocks')
return T_c
def parse(blockchain): print 'print Parsing Block Chain' counter = 0 while True: print counter block = Block(blockchain) block.toString() counter+=1
def __init__(self, image_path, position, center, collider=None):
Block.__init__(self, image_path, position, collider)
self.center = center
self.this_center = pygame.math.Vector2(self.position.x
+ self.animation.current_frame().get_width() / 2,
self.position.y
+ self.animation.current_frame().get_height() / 2)
self.distance = self.this_center - self.center
self.type = Entity.TYPE_OBJECT_DYNAMIC
def parse(file_name):
'''function that takes a file name, and returns a list of blocks,
instances of class Block.'''
from block import Block
# open file, specified on command line
block_file = open(file_name, 'r')
# compile the regular expressions to be used for performance reasons
comment_pattern = re.compile(r'\s*#.*')
block_start_pattern = re.compile(r'\s*begin\s+(\w+)')
block_end_pattern = re.compile(r'\s*end\s+(\w+)')
# current_block holds an instance of Block for the block that is being
# parsed, its # value is None when outside a block, note that it doubles
# as state variable
current_block = None
# list to hold the blocks
blocks = []
for line in block_file:
# remove leading/triailing spaces, and comments (i.e., everything
# following a '#'
line = comment_pattern.sub('', line.strip())
# ignore blank lines
if len(line) == 0:
continue
# check for begin block
match = block_start_pattern.match(line)
if match is not None:
# if current_block is not None, we are already in a block,
# raise error
if current_block is not None:
raise ParseError(
'block {0} is not close when opening {1}'.format(
current_block.get_name(), match.group(1)))
# now in a block, so change state
current_block = Block(match.group(1))
continue
# check for end block
match = block_end_pattern.match(line)
if match is not None:
# if the end block name is not the current block, raise error
if match.group(1) != current_block.get_name():
raise ParseError(
'block {0} is closed with {1}'.format(
match.group(1), current_block.get_name()))
# now out of a block, add current block to the list, and change state
blocks.append(current_block)
current_block = None
continue
# if not in a block, ignore the line
if current_block is None:
continue
else:
# store block data
current_block.add_data(line)
# close the file
block_file.close()
return blocks
def split_marked_group(self, block, mark):
"""move all stones with given mark to new block
Return splitted group.
"""
new_block = Block(block.color)
for stone, value in block.stones.items():
if value==mark:
block.remove_stone(stone)
new_block.add_stone(stone)
return new_block
def new_next_block():
global next_block
global next_block_pos
new_type = random.choice(block_types)
next_block = Block(new_type[0], new_type[1], [0, 0], board_width, board_height)
width, height = next_block.get_size()
width *= block_size
height *= block_size
x = next_block_surface[0] + next_block_surface[2] / 2 - width / 2
y = next_block_surface[1] + next_block_surface[3] / 2 - height / 2
next_block_pos = [x, y]
def __init_blocks(self):
self.blocks = list()
row_mid = len(self.piece[0])/2
row_offset = self.__first_non_empty_row()
for row in range(0, len(self.piece)):
for col in range(0, len(self.piece[row])):
block_symbol = self.piece[row][col]
if block_symbol != '.':
block = Block(block_symbol)
block.move_to((col - row_mid, row - row_offset))
self.blocks.append(block)
def spawn_block(self):
"""
Creates a new block with random starting position/random orientation.
"""
block = Block()
#block.position = (random.randint(0,GRID_WIDTH-1),block.position[1]) #uncomment here and comment below for randomly positioned blocks
block.position = (GRID_WIDTH/2,block.position[1]) #spawn in middle of field
for i in range(random.randint(0,3)): #random orientation
block.rotate(True)
self.block_count += 1
return block
def __merge(self,ns_list):
block_li = [] # 文本块列表
block = Block() # 文本块
for i in range(len(ns_list)):
if ns_list[i]['offset'] >= 1:#thr:
# 大于或等于阈值,保存上一个块，划给新块
if not block.is_empty():
block_li.append( block )
block = Block() # 新增文本块
if ns_list[i]['node'] and ns_list[i]['node'].string.strip():
block.append( ns_list[i]['node'] )
return block_li
def polarArray(geom,numberOfCopies,totalAngle=2*pi,center=Point(0,0)):
'''
array geometric entity in a polar pattern
'''
b = Block()
theta_step = totalAngle / numberOfCopies
theta = 0.0
for i in range(numberOfCopies):
g = rotateAboutPoint(geom,center,theta)
b.append(g)
theta += theta_step
return b
def test_add_blocks(self):
self.test_init_field()
for i, b_data in enumerate(self.raw_data):
b = Block(b_data["type"], b_data["conns"], b_data["name"], b_data["groups"])
b.rotate(b_data["rot"])
b.mirror(set_to=b_data["mir"])
self.field.add_block(b, b_data["pos"])
self.assertEqual(len(self.field), len(self.raw_data))
def rectArray(geom,xNum,xStep,yNum=1,yStep=None):
'''
array geometric entity in a rectangular pattern
'''
b = Block()
y = 0.0
for j in range(yNum):
x = 0.0
for i in range(xNum):
t = AffineMatrix().translation(Vector(x,y,0.0))
b.append(t * geom)
x += xStep
y += yStep
return b
def parse(blockchain):
print 'Parsing Block Chain'
'''
block = Block(blockchain)
return block
'''
counter = 0
while True:
print counter
block = Block(blockchain)
block.toString()
print "\n"*10
counter+=1
def _block_name(self):
if type(self._block) is str:
return Block.from_full_name(self._block)[1]
elif self._block is None:
return None
else:
return self._block.name
def _dataset_name(self):
if type(self._block) is str:
return Block.from_full_name(self._block)[0]
elif self._block is None:
return None
else:
return self._block.dataset.name
def __init__(self):
#self.TICKS_PER_SEC = TICKS_PER_SEC
# A Batch is a collection of vertex lists for batched rendering.
self.batch = pyglet.graphics.Batch()
# A TextureGroup manages an OpenGL texture.
self.group = Textures._texture_group
# Block useful methods
self.block = Block()
# A mapping from position to the texture of the block at that position.
# This defines all the blocks that are currently in the world.
self.world = dict()
# Same mapping as `world` but only contains blocks that are shown.
self.shown = dict()
# Mapping from position to a pyglet `VertextList` for all shown blocks.
self._shown = dict()
# Mapping from sector to a list of positions inside that sector.
self.sectors = dict()
# Simple function queue implementation. The queue is populated with
# _show_block() and _hide_block() calls
self.queue = deque()
self._initialize()
def init(self):
self.Repeat = 0
super(ColorDiffGame, self).init()
self.block = Block(color = ColorDiffGame.GREEN,level=self.level,score = self.score)
self.startgame = False
self.block.constant()
self.render_score()
def parse(blockchain): print 'print Parsing Block Chain' continueParsing = True counter = 0 blockchain.seek(0, 2) fSize = blockchain.tell() - 80 #Minus last Block header size for partial file blockchain.seek(0, 0) while continueParsing: block = Block(blockchain) continueParsing = block.continueParsing if continueParsing: block.toString() counter+=1 print '' print 'Reached End of Field' print 'Parsed %s blocks', counter
def parse(blockchain, block_counter_start=0, datfilenum=0, debug=False): if debug: print 'print Parsing Block Chain' continueParsing = True counter = block_counter_start blockchain.seek(0, 2) fSize = blockchain.tell() - 80 #Minus last Block header size for partial file blockchain.seek(0, 0) while continueParsing: block = Block(blockchain, counter, datfilenum, debug) continueParsing = block.continueParsing if continueParsing: if debug: block.toString() block.toCSV() counter+=1 if debug: print '' if debug: print 'Reached End of Field' if debug: print 'Parsed %s blocks', counter
def next_block(self):
"""Get the next block for fitting. Returns None when the end
of the data is reached.
"""
if self.debug:
print("\nSearching for next block...")
print(" Starting index:", self.idx)
# Call the C function that will do the actual search.
return_inds = np.zeros(2, dtype=np.int64)
b = blockident_median_c.next_block(
max(self.idx - self.filt_len, 0),
self.filt_len,
self.pad_post,
self.max_len,
self.th,
self.r,
return_inds)
i0, i1 = return_inds
# Are we at the end of the data?
if i0 == self.r.size:
return None
# Construct new block.
block = Block(self.r, self.p,
max(i0 - self.pad_pre, 0),
min(i1 + self.pad_post, self.r.size - 1),
b)
block.exclude_pre = self.exclude_pre
block.exclude_post = self.exclude_post
# Update current index, always making some progress.
# This helps us avoid a problem that occurs when we reach the
# end of the data.
self.set_position(max(self.idx + 1, block.i1 - self.exclude_post))
if self.debug:
print(" Found block :", block.i0)
print(" Length :", block.i1 - block.i0)
return block
def newBlock(self):
#新方塊
self.block = Block(0, self.col_size//2)
for row, col in self.block.tellAllPos():
if self.board[row][col] > 0:
self.mergeBlock()
self.draw()
print("遊戲結束")
sys.exit()
def CalculateBlocks(video_image):
start = time.time()
orig_image = video_image
# orig_image = cv2.imread("block_test.jpg")
# orig_image = cv2.imread("Picture 11.jpg") # Picture 6-11
# cv2.imshow("Original", orig_image)
image = cv2.resize(orig_image, (0,0), fx=0.25, fy=0.25) # half x and y axes
height, width, channels = image.shape
# BGR
# for y in range(0, width):
# for x in range(0, height):
# red = image.item(x,y,2)
# green = image.item(x,y,1)
# blue = image.item(x,y,0)
# if red > 1.3 * green and red > 1.3 * blue:
# image.itemset((x,y,2),0)
# image.itemset((x,y,1),0)
# image.itemset((x,y,0),0)
blocks = []
for x in xrange(10,width-10,10):
for y in xrange(10,height-10,10):
block = Block(x,y);
# print("x,y:", x,",",y)
FloodFill(x,y,image,block)
# print("numPixels: ", block.getNumPixelsInBlock())
if block.getNumPixelsInBlock() > 500:
block.meanX = block.accumulatedX / block.getNumPixelsInBlock()
blocks.append(block)
# x, y = block.getBlockBottomPixel()
# print(x,y)
# print (block.meanX == x)
# image.itemset((y, x, 0),0)
# image.itemset((y, x, 1),255)
# image.itemset((y, x, 2),0)
# print("Blocks: ", len(blocks))
end = time.time()
# print("Time: ", (end - start))
return blocks
def parse(blockchain, blkNo): print 'Parsing Block Chain block head, transaction etc.' continueParsing = True counter = 0 blockchain.seek(0, 2) fSize = blockchain.tell() - 80 #Minus last Block header size for partial file blockchain.seek(0, 0) while continueParsing: block = Block(blockchain) continueParsing = block.continueParsing if continueParsing: block.toString() counter+=1 print "#"*20+"Block counter No. %s"%counter +"#"*20 if counter >= blkNo and blkNo != 0xFF: continueParsing = False print '' print 'Reached End of Field' print "Parsed %d blocks" % counter
def get_block_list(world):
blocks = {}
for obj in world.objects.values():
if obj.type.name != "BLOCK":
continue
block = None
if world.atom_true(worldsim.Atom(world.predicates["table"], [obj])):
block = Block(Block.TABLE, obj.name)
elif world.atom_true(worldsim.Atom(world.predicates["triangle"], [obj])):
block = Block(Block.TRIANGLE, obj.name)
elif world.atom_true(worldsim.Atom(world.predicates["block"], [obj])):
block = Block(Block.SQUARE, obj.name)
if not block:
continue
block.clear = False
block.on = None
block.onfire = False
if block.type == block.TABLE:
table = block
blocks[obj.name] = block
for atom in world.atoms:
if atom.predicate == world.predicates["on"]:
blocks[atom.args[0].name].on = blocks[atom.args[1].name]
elif atom.predicate == world.predicates["on-table"]:
blocks[atom.args[0].name].on = table
elif atom.predicate == world.predicates["clear"]:
blocks[atom.args[0].name].clear = True
elif atom.predicate == world.predicates["onfire"]:
blocks[atom.args[0].name].onfire = True
return sorted(blocks.values(), key = lambda x: x.id)
def __init__(self):
self.chain = [Block.genesis()]
self.blockindex = 1
self.reward = 10
def run_model(x, start_bottom_y,start_top_y, step, multipliers, x_interval, save_name):
""" Main Program """
stop = start_top_y
count = 1
while stop > 0:
stop -= step
print_data = True
save_folder_path = save_name + str(count)
test_levels = build_blueprint_range(x=x, start_bottom_y=start_bottom_y, start_top_y=start_top_y, width=100,
stop=stop, multipliers=multipliers, y_interval=1, x_interval=x_interval)
#level1
levels = Block.generate(SCREEN_WIDTH, SCREEN_HEIGHT, 100, True, test_levels)
screen, clock, current_level, current_level_no = init(SCREEN_WIDTH, SCREEN_HEIGHT, levels)
done = False
while not done:
# --- Event Processing ---
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
# --- Drawing ---
screen.fill(WHITE)
for block in current_level:
block.draw(screen)
capture(surface=screen, mode='capture', remove_blank_frames=True,
level_number=current_level_no,
save_folder_path=save_folder_path, preview=False)
if current_level_no < len(levels) - 1:
current_level_no += 1
current_level = levels[current_level_no]
else:
done = True
pygame.display.flip()
clock.tick(60)
if print_data:
print('Simulation Terminated')
pygame.quit()
count += 1
from blockchain import BlockChain
from block import Block
from hashlib import sha256
from json import dumps
genesis_prev_hash = sha256((b'\x00' * 32))
genesis_data = 'Hello there!'.encode('utf-8')
data1 = '1!'.encode('utf-8')
data2 = '2!'.encode('utf-8')
data3 = '3!'.encode('utf-8')
data4 = '4!'.encode('utf-8')
genesis_block = Block(genesis_data, genesis_prev_hash.digest())
block1 = Block(data1, genesis_block.hash())
block2 = Block(data2, block1.hash())
block3 = Block(data3, block2.hash())
block4 = Block(data4, block1.hash())
blockchain = BlockChain(genesis_block)
one = blockchain.append(block1)
two = blockchain.append(block2)
three = blockchain.append(block3)
four = blockchain.append(block4)
test_dict = {
"data": "MyE=",
"previous":
"3b9448477c4dc133872b1029ab8d3e5ca151ad872cf5de636c2e8595dbf67855"
}
def build_block(self, transactions, tree):
prevhash = len(self.blocks) > 0 and self.blocks[-1].roothash or ''
return Block(transactions, tree.root, tree.tree, prevhash)
def make_move(self, board: Block) -> int:
"""Choose a move to make on the given board, and apply it, mutating
the Board as appropriate.
Return 0 upon successful completion of a move, and 1 upon a QUIT event.
"""
scores = {}
iterations = {0: 5, 1: 10, 2: 25, 3: 50, 4: 100, 5: 150}
moves = iterations[self.diff]
# Get all the available blocks
list_ = board.get_all_blocks()
# Try all the moves, record, and undo them.
for _ in range(moves):
block = random.randint(0, len(list_) - 1)
curr = list_[block]
move_index = random.randint(1, 4)
if move_index == 1:
curr.rotate(1)
dict_helper(scores, self.goal.score(board), curr, 1)
curr.rotate(3)
elif move_index == 2:
curr.rotate(3)
dict_helper(scores, self.goal.score(board), curr, 2)
curr.rotate(1)
elif move_index == 3:
curr.swap(0)
dict_helper(scores, self.goal.score(board), curr, 3)
curr.swap(0)
elif move_index == 4:
curr.swap(1)
dict_helper(scores, self.goal.score(board), curr, 4)
curr.swap(1)
# Find the move with the highest score and execute that move.
# find the max score
score = max(scores, key=int)
self._selected_block = scores[score][0][0]
move = scores[score][0][1]
self._selected_block.highlighted = True
# draw the board, call time delay
self.renderer.draw(board, self.id)
pygame.time.wait(TIME_DELAY)
# do the move
if move == 1:
self._selected_block.rotate(1)
elif move == 2:
self._selected_block.rotate(3)
elif move == 3:
self._selected_block.swap(0)
elif move == 4:
self._selected_block.swap(1)
self._selected_block.highlighted = False
self.renderer.draw(board, self.id)
return 0
def process_event(self, board: Block,
event: pygame.event.Event) -> Optional[int]:
"""Process the given pygame <event>.
Identify the selected block and mark it as highlighted. Then identify
what it is that <event> indicates needs to happen to <board>
and do it.
Return
- None if <event> was not a board-changing move (that is, if was
a change in cursor position, or a change in _level made via
the arrow keys),
- 1 if <event> was a successful move, and
- 0 if <event> was an unsuccessful move (for example in the case of
trying to smash in an invalid location or when the player is not
allowed further smashes).
"""
# Get the new "selected" block from the position of the cursor
block = board.get_selected_block(pygame.mouse.get_pos(), self._level)
# Remove the highlighting from the old "_selected_block"
# before highlighting the new one
if self._selected_block is not None:
self._selected_block.highlighted = False
self._selected_block = block
self._selected_block.highlighted = True
# Since get_selected_block may have not returned the block at
# the requested level (due to the level being too low in the tree),
# set the _level attribute to reflect the level of the block which
# was actually returned.
self._level = block.level
if event.type == pygame.MOUSEBUTTONDOWN:
block.rotate(event.button)
return 1
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
if block.parent is not None:
self._level -= 1
return None
elif event.key == pygame.K_DOWN:
if len(block.children) != 0:
self._level += 1
return None
elif event.key == pygame.K_h:
block.swap(0)
return 1
elif event.key == pygame.K_v:
block.swap(1)
return 1
elif event.key == pygame.K_s:
if self.num_smashes >= self.MAX_SMASHES:
print('Can\'t smash again!')
return 0
if block.smash():
self.num_smashes += 1
return 1
else:
print('Tried to smash at an invalid depth!')
return 0
def genesis_block(self):
return Block('Genesis')
def test_rotate() -> None:
block = Block((0, 0), 16, (1, 128, 181), 0, 2)
b1 = Block((8, 0), 8, (1, 128, 181), 1, 2)
b2 = Block((0, 0), 8, (199, 44, 58), 1, 2)
b3 = Block((0, 8), 8, (1, 128, 181), 1, 2)
b4 = Block((8, 8), 8, (255, 211, 92), 1, 2)
block.children = [b1, b2, b3, b4]
b31 = Block((4, 8), 4, (1, 128, 181), 2, 2)
b32 = Block((0, 8), 4, (199, 44, 58), 2, 2)
b33 = Block((0, 12), 4, (255, 211, 92), 2, 2)
b34 = Block((4, 12), 4, (199, 44, 58), 2, 2)
b3.children = [b31, b32, b33, b34]
assert b31.rotate(1) is False
assert b4.rotate(3) is False
assert b3.rotate(1)
assert b32.position == (4, 8)
assert block.rotate(3)
assert b32.position == (8, 8)
def test_paint() -> None:
block = Block((0, 0), 16, (1, 128, 181), 0, 2)
b1 = Block((8, 0), 8, (1, 128, 181), 1, 2)
b2 = Block((0, 0), 8, (199, 44, 58), 1, 2)
b3 = Block((0, 8), 8, (1, 128, 181), 1, 2)
b4 = Block((8, 8), 8, (255, 211, 92), 1, 2)
block.children = [b1, b2, b3, b4]
b31 = Block((4, 8), 4, (1, 128, 181), 2, 2)
b32 = Block((0, 8), 4, (199, 44, 58), 2, 2)
b33 = Block((0, 12), 4, (255, 211, 92), 2, 2)
b34 = Block((4, 12), 4, (199, 44, 58), 2, 2)
b3.children = [b31, b32, b33, b34]
color = (255, 211, 92)
assert block.paint(color) is False
assert b2.paint(color) is False
assert b33.paint(color) is False
assert b31.paint(color) is True
assert b31.colour == color
def text_line_segmentation_NN(image,
scale,
use_binary=True,
debug_image=None,
offset=(0, 0),
debug_mode=False):
h, w = image.shape[:2]
if debug_image is None:
debug_image = image
if len(debug_image.shape) < 3:
debug_image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
if len(image.shape) > 2:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
if use_binary:
image = (thresh_sauvola(image, k=0.2) * 255).astype('uint8')
labels, _ = label(image == 0)
objects = find_objects(labels)
height_map = [
sl.height(o) for o in objects if sl.height(o) > 6
and sl.height(o) < 100 and sl.aspect_normalized(o) < 8
]
avg_h = max(np.nan_to_num(np.mean(height_map)), scale * 0.6)
# remove underline (optional)
image = remove_underline(image, avg_h)
block = Block(image, avg_h)
words = block.getWordBoundingBoxes()
words = filter_and_merge_overlap_boxes(words,
max(avg_h, scale * 0.8) * 0.3,
(h, w))
words = filter_and_merge_overlap_boxes(words,
max(avg_h, scale * 1.0) * 0.3,
(h, w),
use_merge_same_line_only=True,
same_line_multiplier=5)
offset_x, offset_y = offset
# filter line by size
lines = [
(l, m) for l, m in words if l[3] - l[1] > avg_h * 0.5 and l[3] -
l[1] < min(avg_h, scale * 1.5) * 3.5 and l[2] - l[0] > avg_h *
0.25 and 1.0 * (l[2] - l[0]) /
(l[3] - l[1]) > 0.2 and max(l[3] - l[1], l[2] - l[0]) > avg_h * 0.8
]
masks = [m for _, m in lines]
lines = [sl.pad_box(l, 0, (h, w)) for l, _ in lines]
lines = [[
l[0] + offset_x, l[1] + offset_y, l[2] + offset_x, l[3] + offset_y
] for l in lines]
if debug_mode:
debug_image = block.paint(None)
else:
pre_image = debug_image.copy()
for i, m in enumerate(masks):
x0, y0 = lines[i][0], lines[i][1]
x1, y1 = lines[i][2], lines[i][3]
mh, mw = m.shape
cv2.rectangle(pre_image, (x0, y0), (x1, y1), (0, 0, 255), 1)
cv2.rectangle(debug_image, (x0, y0), (x1, y1), (0, 0, 255), 1)
region = debug_image[y0:y0 + mh, x0:x0 + mw]
region[m[:region.shape[0], :region.shape[1]] > 0] = [0, 0, 255]
alpha = 0.75
debug_image = cv2.addWeighted(pre_image, alpha, debug_image, 1 - alpha,
0)
return lines, debug_image
def test_block_to_squares() -> None:
block1 = Block((0, 0), 16, None, 0, 2)
c1 = Block((8, 0), 8, (1, 128, 181), 1, 2)
c2 = Block((0, 0), 8, (199, 44, 58), 1, 2)
c3 = Block((0, 8), 8, None, 1, 2)
c4 = Block((8, 8), 8, None, 1, 2)
block1.children = [c1, c2, c3, c4]
b31 = Block((4, 8), 4, (1, 128, 181), 2, 2)
b32 = Block((0, 8), 4, (199, 44, 58), 2, 2)
b33 = Block((0, 12), 4, (255, 211, 92), 2, 2)
b34 = Block((4, 12), 4, (199, 44, 58), 2, 2)
c3.children = [b31, b32, b33, b34]
b41 = Block((12, 8), 4, (255, 211, 92), 2, 2)
b42 = Block((8, 8), 4, (199, 44, 58), 2, 2)
b43 = Block((8, 12), 4, (255, 211, 92), 2, 2)
b44 = Block((12, 12), 4, (199, 44, 58), 2, 2)
c4.children = [b41, b42, b43, b44]
lst = _block_to_squares(block1)
assert ((1, 128, 181), (4, 8), 4) in lst
def insert_block(self, data):
new_block = Block(self.len + 1, data, self.previous_hash, self.hash,
self.difficulty)
self.len += 1
self.blockchain.append(new_block.get_block())
return True
def add_block(last_block, data):
this_index = last_block.index + 1
this_timestamp = date.datetime.now()
this_data = data
this_hash = last_block.hash
return Block(this_index, this_timestamp, this_data, this_hash)
from block import Block
import datetime
num_blocks_to_add = 10
block_chain = [Block.create_genesis_block()]
print("The genesis block has been created.")
print("Hash: %s" % block_chain[0].hash)
for i in range(1, num_blocks_to_add + 1):
block_chain.append(
Block(block_chain[i - 1].hash, "Block number %d" % i,
datetime.datetime.now()))
print("Block #%d created." % i)
print("Hash: %s" % block_chain[-1].hash)
import time
from transaction import Transaction
from block import Block
from key import BitcoinAccount
wallet = BitcoinAccount()
difficulty = 4
first_block = Block(0, "")
tx = Transaction("mohamed", "justine", 50, time.time())
first_block.add_transaction(tx)
first_block.mine(difficulty)
print("First block is: ")
print(first_block)
last_hash = first_block.hashval
second_block = Block(1, last_hash)
second_block.mine(difficulty)
print("Second block is: ")
print(second_block)
def test_combine() -> None:
block = Block((0, 0), 16, (1, 128, 181), 0, 2)
b1 = Block((8, 0), 8, (1, 128, 181), 1, 2)
b2 = Block((0, 0), 8, (199, 44, 58), 1, 2)
b3 = Block((0, 8), 8, (1, 128, 181), 1, 2)
b4 = Block((8, 8), 8, (255, 211, 92), 1, 2)
block.children = [b1, b2, b3, b4]
b31 = Block((4, 8), 4, (1, 128, 181), 2, 2)
b32 = Block((0, 8), 4, (199, 44, 58), 2, 2)
b33 = Block((0, 12), 4, (255, 211, 92), 2, 2)
b34 = Block((4, 12), 4, (199, 44, 58), 2, 2)
b3.children = [b31, b32, b33, b34]
b41 = Block((12, 8), 4, (255, 211, 92), 2, 2)
b42 = Block((8, 8), 4, (199, 44, 58), 2, 2)
b43 = Block((8, 12), 4, (255, 211, 92), 2, 2)
b44 = Block((12, 12), 4, (199, 44, 58), 2, 2)
b4.children = [b41, b42, b43, b44]
assert b34.combine() is False
assert block.combine() is False
assert b3.combine()
assert b4.combine() is False
assert block.combine
assert block.combine() is False
def make_move(self, board: Block):
"""Produce random moves (moves_to_check) times and make those moves
on the <board> to calculate their score and then undo them. Then store
the identities that lead us to the maximum score among other moves that
we have produced. And do that move to gain the biggest possible score
among the other moves that we have generated.
Each random move will be produced by calling the _move method on the
random block that will be generated by producing random location and
random level( <= board.max_depth ) on the given <board>.
Return 0 upon successful completion of a move. And since random player
can't Quit therefore it won't return 1 in any case.
"""
max_score = 0
# minimum score is 0.
best_move = 0
# it will save the number( that later in _move function determine the
# action) of the best move ( to generate on the block )
best_block: Block
# the identity that will help us to store the block on the board which
# will lead us through our goal
for _ in range(self.moves_to_check):
x = random.randint(0, BOARD_WIDTH)
y = random.randint(0, BOARD_WIDTH)
# producing random location (x, y)
# which is inside the area of the board
random_level = random.randint(0, board.max_depth)
# producing random level ( <= board.max_depth )
block = board.get_selected_block((x, y), random_level)
# choose a block on the board base on the identities that we
# randomly generated
decider = random.randint(0, 3)
# it is the number between 0 and 3 which base on it's value, our
# _move function will do the action on the block. it doesn't contain
# 4 because base on the implementiation of the function random_move
# 4 will do the smash however Smartplayer can't smash any block
random_move(decider, block)
# to the generated action on the generated block
if max_score < self.goal.score(board):
# check if the score that has been generated from the move that
# that we made is greater than the existing max_score, then
# save the identities of the move.
best_move = decider
best_block = block
max_score = self.goal.score(board)
undo_move(block, decider)
# undo the move that we have (done and calculated its score)
block = best_block
# chooose the stored block as the best_block to lead us to the highest
# possible score among the other moves that we haved check
block.highlighted = True
# select the block
self.renderer.draw(board, self.id)
# to draw the frame around the selected block with HIGHLIGHT_COLOUR
pygame.time.wait(TIME_DELAY)
# to introduce a delay so that the user can see what is happening.
random_move(best_move, block)
# move the selected block with the best action to gain more score
block.highlighted = False
# unselect the block
self.renderer.draw(board, self.id)
# to draw the change that happens because of our random_move
return 0
def test_create_copy() -> None:
block = Block((0, 0), 16, None, 0, 5)
b1 = Block((8, 0), 8, (1, 128, 181), 1, 5)
b2 = Block((0, 0), 8, (199, 44, 58), 1, 5)
b3 = Block((0, 8), 8, None, 1, 5)
b4 = Block((8, 8), 8, (255, 211, 92), 1, 5)
block.children = [b1, b2, b3, b4]
b31 = Block((4, 8), 4, (1, 128, 181), 2, 5)
b32 = Block((0, 8), 4, (199, 44, 58), 2, 5)
b33 = Block((0, 12), 4, (255, 211, 92), 2, 5)
b34 = Block((4, 12), 4, (199, 44, 58), 2, 5)
b3.children = [b31, b32, b33, b34]
b = block.create_copy()
assert id(b) != id(block)
assert b.position == block.position
assert b.size == block.size
assert b.max_depth == block.max_depth
assert b.level == block.level
assert b.colour == block.colour
assert b.children == block.children
assert id(b.children[1]) != id(b2)
assert b.children[1].position == b2.position
assert b.children[1].size == b2.size
assert b.children[1].max_depth == b2.max_depth
assert b.children[1].level == b2.level
assert b.children[1].colour == b2.colour
assert id(b.children[2].children[0]) != id(b31)
assert b.children[2].children[0].position == b31.position
assert b.children[2].children[0].size == b31.size
assert b.children[2].children[0].max_depth == b31.max_depth
assert b.children[2].children[0].level == b31.level
assert b.children[2].children[0].colour == b31.colour
def generate(self):
for i in range(self.height):
#if i > 10:
for j in range(self.width):
self.world.append(Block(self.get_id(i), j, i))
def test_flatten() -> None:
blocky = Block((0, 0), 16, (1, 128, 181), 0, 0)
assert _flatten(blocky) == [[(1, 128, 181)]]
block = Block((0, 0), 16, None, 0, 1)
b1 = Block((8, 0), 8, (1, 128, 181), 1, 1)
b2 = Block((0, 0), 8, (199, 44, 58), 1, 1)
b3 = Block((0, 8), 8, (1, 128, 181), 1, 1)
b4 = Block((8, 8), 8, (255, 211, 92), 1, 1)
block.children = [b1, b2, b3, b4]
assert _flatten(block) == [[(199, 44, 58), (1, 128, 181)],
[(1, 128, 181), (255, 211, 92)]]
block1 = Block((0, 0), 16, None, 0, 2)
c1 = Block((8, 0), 8, (1, 128, 181), 1, 2)
c2 = Block((0, 0), 8, (199, 44, 58), 1, 2)
c3 = Block((0, 8), 8, None, 1, 2)
c4 = Block((8, 8), 8, None, 1, 2)
block1.children = [c1, c2, c3, c4]
b31 = Block((4, 8), 4, (1, 128, 181), 2, 2)
b32 = Block((0, 8), 4, (199, 44, 58), 2, 2)
b33 = Block((0, 12), 4, (255, 211, 92), 2, 2)
b34 = Block((4, 12), 4, (199, 44, 58), 2, 2)
c3.children = [b31, b32, b33, b34]
b41 = Block((12, 8), 4, (255, 211, 92), 2, 2)
b42 = Block((8, 8), 4, (199, 44, 58), 2, 2)
b43 = Block((8, 12), 4, (255, 211, 92), 2, 2)
b44 = Block((12, 12), 4, (199, 44, 58), 2, 2)
c4.children = [b41, b42, b43, b44]
block2 = Block((0, 0), 16, None, 0, 2)
c1 = Block((8, 0), 8, (1, 128, 181), 1, 2)
c2 = Block((0, 0), 8, (199, 44, 58), 1, 2)
c3 = Block((0, 8), 8, (255, 211, 92), 1, 2)
c4 = Block((8, 8), 8, (1, 128, 181), 1, 2)
block2.children = [c1, c2, c3, c4]
assert len(_flatten(block1)) == len(_flatten(block2))
assert _flatten(block1) == [[(199, 44, 58), (199, 44, 58), (199, 44, 58),
(255, 211, 92)],
[(199, 44, 58), (199, 44, 58), (1, 128, 181),
(199, 44, 58)],
[(1, 128, 181), (1, 128, 181), (199, 44, 58),
(255, 211, 92)],
[(1, 128, 181), (1, 128, 181), (255, 211, 92),
(199, 44, 58)]]
assert _flatten(block2) == [[(199, 44, 58), (199, 44, 58), (255, 211, 92),
(255, 211, 92)],
[(199, 44, 58), (199, 44, 58), (255, 211, 92),
(255, 211, 92)],
[(1, 128, 181), (1, 128, 181), (1, 128, 181),
(1, 128, 181)],
[(1, 128, 181), (1, 128, 181), (1, 128, 181),
(1, 128, 181)]]
from block import Block
'''
{
"blockchain": [
{
"authorizations": {},
"hash_root": "",
"nonce": 52811,
"now_hash": "0000208efadb6caff4e351c6fd1bf059677bb3f64fb63e0e1aec9a7ffffca265",
"prev_hash": 0,
"timestamp": 1516156465.836211
}
],
"difficulty": "0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
"height": 1
}
'''
genesis_block = Block(
0, [], "5feceb66ffc86f38d952786c6d696c79c2dbc239dd4e91b46729d73a27fb57e9",
1516156465.836211,
"00002758d1b4dd20111165f398e0cdf649af643176d5f77c5ab9cd1b39141ef9", 126745)
#print(genesis_block.to_json())
def test_score_blob_goal() -> None:
block1 = Block((0, 0), 16, None, 0, 2)
c1 = Block((8, 0), 8, (1, 128, 181), 1, 2)
c2 = Block((0, 0), 8, (199, 44, 58), 1, 2)
c3 = Block((0, 8), 8, None, 1, 2)
c4 = Block((8, 8), 8, None, 1, 2)
block1.children = [c1, c2, c3, c4]
b31 = Block((4, 8), 4, (1, 128, 181), 2, 2)
b32 = Block((0, 8), 4, (199, 44, 58), 2, 2)
b33 = Block((0, 12), 4, (255, 211, 92), 2, 2)
b34 = Block((4, 12), 4, (199, 44, 58), 2, 2)
c3.children = [b31, b32, b33, b34]
b41 = Block((12, 8), 4, (255, 211, 92), 2, 2)
b42 = Block((8, 8), 4, (199, 44, 58), 2, 2)
b43 = Block((8, 12), 4, (255, 211, 92), 2, 2)
b44 = Block((12, 12), 4, (199, 44, 58), 2, 2)
c4.children = [b41, b42, b43, b44]
block2 = Block((0, 0), 16, None, 0, 2)
c1 = Block((8, 0), 8, (1, 128, 181), 1, 2)
c2 = Block((0, 0), 8, (199, 44, 58), 1, 2)
c3 = Block((0, 8), 8, (255, 211, 92), 1, 2)
c4 = Block((8, 8), 8, (1, 128, 181), 1, 2)
block2.children = [c1, c2, c3, c4]
block3 = Block((0, 0), 16, None, 0, 2)
c1 = Block((8, 0), 8, (1, 128, 181), 1, 2)
c2 = Block((0, 0), 8, (199, 44, 58), 1, 2)
c3 = Block((0, 8), 8, None, 1, 2)
c4 = Block((8, 8), 8, (199, 44, 58), 1, 2)
block3.children = [c1, c2, c3, c4]
b31 = Block((4, 8), 4, (1, 128, 181), 2, 2)
b32 = Block((0, 8), 4, (199, 44, 58), 2, 2)
b33 = Block((0, 12), 4, (255, 211, 92), 2, 2)
b34 = Block((4, 12), 4, (0, 0, 0), 2, 2)
c3.children = [b31, b32, b33, b34]
b41 = Block((12, 8), 4, (255, 211, 92), 2, 2)
b42 = Block((8, 8), 4, (199, 44, 58), 2, 2)
b43 = Block((8, 12), 4, (0, 0, 0), 2, 2)
b44 = Block((12, 12), 4, (199, 44, 58), 2, 2)
c4.children = [b41, b42, b43, b44]
goal1 = BlobGoal((199, 44, 58))
goal2 = BlobGoal((255, 211, 92))
goal3 = BlobGoal((0, 0, 0))
block4 = Block((0, 0), 16, None, 0, 2)
c1 = Block((8, 0), 8, (1, 128, 181), 1, 2)
c2 = Block((0, 0), 8, (199, 44, 58), 1, 2)
c3 = Block((0, 8), 8, None, 1, 2)
c4 = Block((8, 8), 8, None, 1, 2)
block4.children = [c1, c2, c3, c4]
b31 = Block((4, 8), 4, (1, 128, 181), 2, 2)
b32 = Block((0, 8), 4, (199, 44, 58), 2, 2)
b33 = Block((0, 12), 4, (199, 44, 58), 2, 2)
b34 = Block((4, 12), 4, (199, 44, 58), 2, 2)
c3.children = [b31, b32, b33, b34]
b41 = Block((12, 8), 4, (255, 211, 92), 2, 2)
b42 = Block((8, 8), 4, (199, 44, 58), 2, 2)
b43 = Block((8, 12), 4, (199, 44, 58), 2, 2)
b44 = Block((12, 12), 4, (199, 44, 58), 2, 2)
c4.children = [b41, b42, b43, b44]
assert goal1.score(block1) == 5
assert goal1.score(block4) == 10
assert goal2.score(block1) == 1
assert goal2.score(block2) == 4
assert goal3.score(block3) == 2
assert goal3.score(block1) == 0
def build_element(self, elements_list, element_name):
new_hero = Block(element_name, self.get_random_position())
while not (self.validate_position(elements_list, new_hero)):
new_hero = Block(element_name, self.get_random_position())
return new_hero
def test_get_block() -> None:
block = Block((0, 0), 16, None, 0, 5)
b1 = Block((8, 0), 8, (1, 128, 181), 1, 5)
b2 = Block((0, 0), 8, (199, 44, 58), 1, 5)
b3 = Block((0, 8), 8, None, 1, 5)
b4 = Block((8, 8), 8, (255, 211, 92), 1, 5)
block.children = [b1, b2, b3, b4]
b31 = Block((4, 8), 4, (1, 128, 181), 2, 5)
b32 = Block((0, 8), 4, (199, 44, 58), 2, 5)
b33 = Block((0, 12), 4, (255, 211, 92), 2, 5)
b34 = Block((4, 12), 4, (199, 44, 58), 2, 5)
b3.children = [b31, b32, b33, b34]
x = _get_block(block, (3, 7), 2)
y = _get_block(block, (7, 10), 2)
a = _get_block(block, (8, 8), 1)
b = _get_block(block, (16, 8), 1)
z = _get_block(block, (15, 13), 5)
assert b is None
assert a.position == (8, 8)
assert y.position == (4, 8)
assert x.position == (0, 0)
assert z.position == (8, 8)
class ColorDiffGame(gamelib.SimpleGame):
BLACK = pygame.Color('black')
WHITE = pygame.Color('white')
GREEN = pygame.Color('green')
def __init__(self):
super(ColorDiffGame, self).__init__('ColorDiff', ColorDiffGame.WHITE)
self.level = 2
self.score = 0
self.start_time = 60
self.frame_count = 0
self.frame_rate = 60
self.total_seconds = 60
def init(self):
self.Repeat = 0
super(ColorDiffGame, self).init()
self.block = Block(color=ColorDiffGame.GREEN,
level=self.level,
score=self.score)
self.startgame = False
self.block.constant()
self.render_score()
def update(self):
self.render_time()
if pygame.mouse.get_pressed() == (1, 0, 0): # detect left click
self.Repeat += 1
if self.Repeat == 1:
self.mouse_position = [self.posX, self.posY]
self.block.is_clicked(self.mouse_position, self.level)
else:
self.Repeat = 0
if self.block.is_pass() == True:
self.score += 1
print(self.score)
if (self.score > 25): self.level = 10
elif (self.score > 22): self.level = 9
elif (self.score > 18): self.level = 8
elif (self.score > 14): self.level = 7
elif (self.score > 10): self.level = 6
elif (self.score > 7): self.level = 5
elif (self.score > 4): self.level = 4
elif (self.score > 1): self.level = 3
self.init()
self.frame_count += 1
self.total_seconds = self.start_time - (self.frame_count //
self.frame_rate)
if self.total_seconds < 0:
self.done = True
self.total_seconds = 0
def render_score(self):
self.score_image = self.font.render("Score = %d" % self.score, 0,
ColorDiffGame.GREEN)
def render_time(self):
self.time_image = self.font.render(
"Time left: {0} ".format(self.total_seconds), 0,
ColorDiffGame.GREEN)
def render(self, surface):
self.block.render(surface, self.level, self.score)
surface.blit(self.score_image, (100, 640))
surface.blit(self.time_image, (250, 640))
def add_block(self, data):
self.chain.append(Block(data))
# intersect function used for collision determination
def intersect(rect1, rect2):
if (rect1.x <
rect2.x + rect2.width) and (rect1.x + rect1.width > rect2.x) and (
rect1.y < rect2.y + rect2.height) and (rect1.height + rect1.y >
rect2.y):
return True
return False
# Instantiate all objects and append into object lists drawables and blocks
drawables = []
blocks = []
newBall = Ball(10, 350, (255, 0, 0))
newBlock1 = Block(300, 320, (0, 0, 255))
newBlock2 = Block(300, 330, (0, 0, 255))
newBlock3 = Block(300, 340, (0, 0, 255))
newBlock4 = Block(310, 320, (0, 0, 255))
newBlock5 = Block(310, 330, (0, 0, 255))
newBlock6 = Block(310, 340, (0, 0, 255))
newBlock7 = Block(320, 320, (0, 0, 255))
newBlock8 = Block(320, 330, (0, 0, 255))
newBlock9 = Block(320, 340, (0, 0, 255))
newText = Text('Score: 0', 0, 0, (0, 0, 0))
resetText = Text('Press r to reset ball', 250, 0, (0, 0, 0))
quitText = Text('Press q to quit game', 250, 10, (0, 0, 0))
drawables.append(newBall)
drawables.append(newBlock1)
drawables.append(newBlock2)
def generate_move(self, board: Block) -> \
Optional[Tuple[str, Optional[int], Block]]:
"""Return a valid move by assessing multiple valid moves and choosing
the move that results in the highest score for this player's goal (i.e.,
disregarding penalties).
A valid move is a move other than PASS that can be successfully
performed on the <board>. If no move can be found that is better than
the current score, this player will pass.
This function does not mutate <board>.
"""
if not self._proceed:
return None
self._proceed = False
curr_score = self.goal.score(board)
moves = [ROTATE_CLOCKWISE, ROTATE_COUNTER_CLOCKWISE, SWAP_HORIZONTAL,
SWAP_VERTICAL, SMASH, COMBINE, PAINT]
results = []
# random position
while len(results) < self._difficulty:
depth = random.randint(0, board.max_depth)
random_location = (random.randint(0, board.size-1),
random.randint(0, board.size-1))
# make moves on copies
copy = board.create_copy() # to get score
random_block = _get_block(copy, random_location, depth) # move
block_copy = random_block.create_copy() # try move
# random move
random_move = random.choice(moves)
successful = False
if random_move[0] == 'rotate' and block_copy.rotate(1):
if random_move[1] == 1:
random_block.rotate(1)
if random_move[1] == 3:
random_block.rotate(3)
successful = True
elif random_move[0] == 'swap' and block_copy.swap(1):
if random_move[1] == 1:
random_block.swap(1)
if random_move[1] == 0:
random_block.swap(0)
successful = True
elif random_move[0] == 'paint':
if block_copy.paint(self.goal.colour):
random_block.paint(self.goal.colour)
successful = True
elif random_move[0] == 'smash':
if block_copy.smash():
random_block.smash()
successful = True
elif random_move[0] == 'combine':
if block_copy.combine():
random_block.combine()
successful = True
if successful:
score = self.goal.score(copy)
results.append((score, _create_move(random_move, _get_block(
board, random_location, depth))))
scores = {}
for result in results:
if result[0] in scores:
scores[result[0]].append(result[1])
else:
scores[result[0]] = [result[1]]
if max(list(scores.keys())) <= curr_score:
return _create_move(PASS, board)
else:
return random.choice(scores[max(list(scores.keys()))])
def __init__(self, index, timestamp, data, prev_hash):
self.__block_chain = list()
self.__block_chain.append(Block(index, timestamp, data, timestamp))
def cache_constructor(self):
block0 = Block()
block0.set_number(0)
block0.set_state("I")
block0.set_memory_address(0)
block0.set_data(0)
block0.set_tag(0)
block1 = Block()
block1.set_number(1)
block1.set_state("I")
block1.set_memory_address(0)
block1.set_data(0)
block1.set_tag(0)
block2 = Block()
block2.set_number(2)
block2.set_state("I")
block2.set_memory_address(0)
block2.set_data(0)
block2.set_tag(0)
block3 = Block()
block3.set_number(3)
block3.set_state("I")
block3.set_memory_address(0)
block3.set_data(0)
block3.set_tag(0)
set0 = [block0, block1]
set1 = [block2, block3]
self.set_sets([set0, set1])
self.set_blocks([block0, block1, block2, block3])
