def sort_bricks_flex(bricks, model):
build_que = list(bricks)
# separate layers
layers = [0]
for i in range(0, len(bricks) - 1):
if bricks[i]['z'] != bricks[i + 1]['z']:
layers.append(i + 1)
layers.append(len(bricks))
# find non-disassemblable
sub_bricks = []
remaining_bricks = []
for i in range(0, len(layers) - 1):
temp_bricks, opt = dis.sort_bricks_dis(bricks[layers[i]:layers[i + 1]],
copy.deepcopy(model))
if opt == 'n':
sub_bricks.append(temp_bricks)
else:
sub_bricks.append([])
for j in range(layers[i], layers[i + 1]):
flag = 0
for k in range(0, len(temp_bricks)):
if fd.match_bricks(bricks[j], temp_bricks[k]) == 1:
flag = 1
if flag == 0:
remaining_bricks.append(bricks[j])
print "bricks", sub_bricks
# get replacement bricks for flexible assembly
updated_model = fd.update_model(remaining_bricks, copy.deepcopy(model))
changed_model = copy.deepcopy(model)
for i in range(0, len(sub_bricks)):
if len(sub_bricks[i]) != 0:
replaced, replacement = get_replaceable(sub_bricks[i],
updated_model)
for j in range(layers[i], layers[i + 1]):
if fd.match_bricks(bricks[j], replaced) == 1:
changed_model = fd.update_model(
[replaced], copy.deepcopy(changed_model))
changed_model = change_model(replacement,
copy.deepcopy(changed_model))
build_que[j] = replacement
return build_que, changed_model, 'y'
def main():
ipt = raw_input("Robot connected?(y/n)")
if ipt == "y":
c, ser_ee = initialize()
# loop
print c.recv(1024)
inp = raw_input("Continue?")
msg = ic.safe_ur_move(c, Pose=dict(wp.home_joints), CMD=2)
while True:
task = raw_input("task: ")
if task == "o":
ic.super_serial_send(ser_ee, "G", 51)
if task == "c":
ic.super_serial_send(ser_ee, "G", 49)
if task == "cal":
ipt = raw_input("Continue?")
lm.grid_pick(c, ser_ee, 0, 1, 0, 0)
lm.grid_place(c, ser_ee, 0, 1, 0, 0)
ipt = raw_input("Continue?")
lm.grid_pick(c, ser_ee, 30, 1, 0, 0)
lm.grid_place(c, ser_ee, 30, 1, 0, 0)
ipt = raw_input("Continue?")
lm.grid_pick(c, ser_ee, 30, 13, 0, 0)
lm.grid_place(c, ser_ee, 30, 13, 0, 0)
ipt = raw_input("Continue?")
lm.grid_pick(c, ser_ee, 0, 13, 0, 0)
lm.grid_place(c, ser_ee, 0, 13, 0, 0)
ipt = raw_input("Continue?")
msg = ic.safe_ur_move(c, Pose=dict(wp.home_joints), CMD=2)
if task == "stack":
msg = ic.safe_ur_move(c, Pose=dict(wp.home_joints), CMD=2)
time.sleep(3)
lm.stack_pick(c, ser_ee, 0, 1, 2, 0, stack=3)
lm.grid_place(c, ser_ee, 30, 1, 2, 0)
if task == "rot":
msg = ic.safe_ur_move(c, Pose=dict(wp.home_joints), CMD=2)
ic.socket_send(c, sCMD=300)
current_Pose = ic.get_ur_position(c, 1)
demand_Pose = {
"x": current_Pose[0],
"y": current_Pose[1],
"z": current_Pose[2],
"rx": current_Pose[3],
"ry": current_Pose[4],
"rz": current_Pose[5]
}
print "current_Pose: ", demand_Pose
demand_Pose = dict(lm.smooth_rotate(c, 0, R=20))
print "demand_Pose: ", demand_Pose
ipt = raw_input("continue?")
msg = ic.safe_ur_move(c, Pose=demand_Pose, CMD=8)
# if task == "lego":
# #time.sleep(5)
# ipt = raw_input("Open?(y/n)")
# if ipt == "y":
# ic.super_serial_send(ser_ee,"G",51)
# for i in range(0,3):
# for j in range(0,4):
# for k in range(0,2):
# lm.grid_pick(c,ser_ee,j*8+3,k*6+1,4,0)
# lm.grid_place(c,ser_ee,j*8+3,k*6+7,4,0)
# msg = ic.safe_ur_move(c,Pose=dict(wp.home_joints),CMD=2)
# for j in range(0,4):
# for k in range(0,2):
# lm.grid_pick(c,ser_ee,27-j*8,13-k*6,4,0)
# lm.grid_place(c,ser_ee,27-j*8,7-k*6,4,0)
# msg = ic.safe_ur_move(c,Pose=dict(wp.home_joints),CMD=2)
if task == "lego":
ic.socket_send(c, sCMD=300)
lm.grid_pick(c, ser_ee, 0, 1, 0, 0)
if task == "pt":
#time.sleep(5)
ipt = raw_input("Open?(y/n)")
if ipt == "y":
ic.super_serial_send(ser_ee, "G", 51)
for i in range(0, 4):
for j in range(0, 4):
for k in range(0, 2):
lm.grid_pick(c, ser_ee, ((j + k) * 8 + 3) % 32,
k * 6 + 1, 1, 0)
lm.grid_place(c, ser_ee, ((j + k + 1) * 8 + 3) % 32,
k * 6 + 7, 1, 0)
msg = ic.safe_ur_move(c, Pose=dict(wp.home_joints), CMD=2)
for j in range(0, 4):
lm.grid_pick(c, ser_ee, j * 8 + 3, 13, 1, 0)
lm.grid_place(c, ser_ee, ((j + 1) * 8 + 3) % 32, 1, 1, 0)
msg = ic.safe_ur_move(c, Pose=dict(wp.home_joints), CMD=2)
if task == "wp":
msg = ic.safe_ur_move(c, Pose=dict(wp.feed_stow_wp_joints), CMD=2)
if task == "pose":
current_Pose = ic.get_ur_position(c, 1)
print "current pose: ", current_Pose
if task == "joints":
current_Joints, current_Grip = ic.get_ur_position(c, 3)
print "current joints: ", current_Joints
if task == "dis":
model = fd.import_file("example.txt")
bricks = fd.decode_file(model)
que, opt = dis.sort_bricks_dis(bricks, model)
print opt
print "x\ty\tp\tr\tex\tey"
for i in range(0, len(que)):
print que[i]['x'], '\t', que[i]['y'], '\t', que[i][
'p'], '\t', que[i]['r'], '\t', que[i]['ye'], '\t', que[i][
'xe']
lm.clean_disassemble(c, ser_ee, que)
if task == "disre":
ipt = raw_input("Open?(y/n)")
if ipt == "y":
ic.super_serial_send(ser_ee, "G", 51)
model = fd.import_file("examplere.txt")
bricks = fd.decode_file(model)
que, opt = dis.sort_bricks_dis(bricks, model)
print opt
print "x\ty\tp\tr\tex\tey"
for i in range(0, len(que)):
print que[i]['x'], '\t', que[i]['y'], '\t', que[i][
'p'], '\t', que[i]['r'], '\t', que[i]['ye'], '\t', que[i][
'xe']
ipt = raw_input("continue?")
#lm.assemble(c,ser_ee,bricks)
#ipt = raw_input("continue?")
lm.clean_disassemble(c, ser_ee, que)
if task == "ass":
model = fd.import_file("example.txt")
bricks = fd.decode_file(model)
que, opt = ass.sort_bricks_ass(bricks, model)
print opt
print "x\ty\tp\tr\tex\tey"
for i in range(0, len(que)):
print que[i]['x'], '\t', que[i]['y'], '\t', que[i][
'p'], '\t', que[i]['r'], '\t', que[i]['ye'], '\t', que[i][
'xe']
ipt = raw_input('Continue?')
if ipt == 'y':
lm.clean_assemble(c, ser_ee, que)
if task == "assre":
ipt = raw_input("Open?(y/n)")
if ipt == "y":
ic.super_serial_send(ser_ee, "G", 51)
model = fd.import_file("examplere.txt")
bricks = fd.decode_file(model)
que, opt = ass.sort_bricks_ass(bricks, model)
print opt
for i in range(0, len(que)):
if que[i]['r'] == 0 or que[i]['r'] == 180:
print que[i]['x'], ', ', que[i]['y'] + que[i][
'p'], ', ', que[i]['z']
else:
print que[i]['x'] + que[i]['p'], ', ', que[i][
'y'], ', ', que[i]['z']
ipt = raw_input("continue?")
#lm.assemble(c,ser_ee,bricks)
#ipt = raw_input("continue?")
lm.assemble(c, ser_ee, que)
if task == "i":
model = fd.import_file("example.txt")
#print get_size(model)
if task == "stow":
h = int(raw_input("H: "))
s = int(raw_input("stack: "))
msg = ic.safe_ur_move(c, Pose=dict(wp.home_joints), CMD=2)
if s == 2:
lm.feed_place2(c, ser_ee, sH=h)
lm.feed_place(c, ser_ee, H=h)
msg = ic.safe_ur_move(c, Pose=dict(wp.home_joints), CMD=2)
if task == "pick":
msg = ic.safe_ur_move(c, Pose=dict(wp.home_joints), CMD=2)
h = int(raw_input("H: "))
x = int(raw_input("x: "))
s = int(raw_input("stack: "))
lm.feed_pick(c, ser_ee, X=x, H=h, stack=s)
msg = ic.safe_ur_move(c, Pose=dict(wp.home_joints), CMD=2)
if task == "ls":
model = fd.import_file("example.txt")
bricks = fd.decode_file(model)
#tic = time.time()
que, opt, p = ass.sort_bricks_ass(bricks, copy.deepcopy(model))
#print "sort time = ", time.time()-tic
#print "Sort output: ", opt
#print "total cost = ",ass.list_cost(que,copy.deepcopy(model))
#print ""
#for i in range(0,len(que)):
# if que[i]['r'] == 0 or que[i]['r'] == 180:
# print que[i]['x'],', ',que[i]['y'],', ',que[i]['p'],', ',que[i]['r'],', ',que[i]['z'],', ',que[i]['ye'],', ',que[i]['xe']
# else:
# print que[i]['x'],', ',que[i]['y'],', ',que[i]['p'],', ',que[i]['r'],', ',que[i]['z'],', ',que[i]['xe'],', ',que[i]['ye']
#for i in range(0,len(que)):
# if que[i]['r'] == 0 or que[i]['r'] == 180:
# print que[i]['x'],', ',que[i]['y']+que[i]['p'],', ',que[i]['z'],', ',que[i]['ye'],', ',que[i]['xe']
# else:
# print que[i]['x']+que[i]['p'],', ',que[i]['y'],', ',que[i]['z'],', ',que[i]['xe'],', ',que[i]['ye']
#ipt = raw_input("continue?")
#tic = time.time()
#delay = lm.assemble(c,ser_ee,que)
#tock = time.time()
print "----------- assembly prob ----------"
print " ", p * 100, '%'
print "----------- assembly time ----------"
print " ", 14.8 * len(que)
#ipt = raw_input("continue?")
#model = fd.import_file("example.txt")
#bricks = fd.decode_file(model)
#tic = time.time()
que, opt = dis.sort_bricks_dis(bricks, copy.deepcopy(model))
#print "dis time = ", time.time()-tic
print "Sort output: ", opt
#print "total cost = ",ass.list_cost(que,copy.deepcopy(model))
#for i in range(0,len(que)):
# if que[i]['r'] == 0 or que[i]['r'] == 180:
# print que[i]['x'],', ',que[i]['y'],', ',que[i]['p'],', ',que[i]['r'],', ',que[i]['z'],', ',que[i]['ye'],', ',que[i]['xe']
# else:
# print que[i]['x'],', ',que[i]['y'],', ',que[i]['p'],', ',que[i]['r'],', ',que[i]['z'],', ',que[i]['xe'],', ',que[i]['ye']
#tic1 = time.time()
#lm.disassemble(c,ser_ee,que)
#toc1 = time.time()
if opt == 'y':
print "--------- disassembly prob --------"
print " ", (0.999**len(que)) * 100, '%'
if opt == 'n':
print "--------- disassembly prob ---------"
print " ", 0, '%'
print "--------- disassembly time --------"
print " ", 20.8 * len(que)
print ""
print ""
print ""
print ""
if task == "lsflex":
model = fd.import_file("example.txt")
bricks = fd.decode_file(model)
flex, updated_model, opt = flx.sort_bricks_flex(bricks, model)
que, opt, p = ass.sort_bricks_ass(flex,
copy.deepcopy(updated_model))
print "----------- assembly prob ----------"
print " ", p * 100, '%'
print "----------- assembly time ----------"
print " ", 14.8 * len(que)
que, opt = dis.sort_bricks_dis(flex, copy.deepcopy(updated_model))
if opt == 'y':
print "--------- disassembly prob --------"
print " ", (0.999**len(que)) * 100, '%'
if opt == 'n':
print "--------- disassembly prob ---------"
print " ", 0, '%'
print "--------- disassembly time --------"
print " ", 20.8 * len(que)
print ""
print ""
print ""
print ""
if task == "re":
model1 = fd.import_file("example.txt")
bricks1 = fd.decode_file(model1)
model2 = fd.import_file("examplere.txt")
bricks2 = fd.decode_file(model2)
dis_list, ass_list = rea.reassemble(bricks1, bricks2, model1,
model2)
#print "dis_list :",dis_list
#print "as_list :",ass_list
#ipt = raw_input("continue?")
que, opt = dis.sort_bricks_dis(dis_list, copy.deepcopy(model1))
print "disassembly sort output: ", opt
print "-------------- remove --------------"
print "x", ",", " y", ",", " p", ",", " r", ",", " z"
for i in range(0, len(que)):
if que[i]['r'] == 0 or que[i]['r'] == 180:
print que[i]['x'], ', ', que[i]['y'], ', ', que[i][
'p'], ', ', que[i]['r'], ', ', que[i]['z']
else:
print que[i]['x'], ', ', que[i]['y'], ', ', que[i][
'p'], ', ', que[i]['r'], ', ', que[i]['z']
ipt = raw_input("continue?")
lm.disassemble(c, ser_ee, que)
print ""
print ""
que, opt = ass.sort_bricks_ass(ass_list, copy.deepcopy(model2))
print "assembly sort output: ", opt
print "-------------- build --------------"
print "x", ",", " y", ",", " p", ",", " r", ",", " z", ",", " ex", ",", " ey"
for i in range(0, len(que)):
if que[i]['r'] == 0 or que[i]['r'] == 180:
print que[i]['x'], ', ', que[i]['y'], ', ', que[i][
'p'], ', ', que[i]['r'], ', ', que[i][
'z'], ', ', -que[i]['ye'], ', ', que[i]['xe']
else:
print que[i]['x'], ', ', que[i]['y'], ', ', que[i][
'p'], ', ', que[i]['r'], ', ', que[i]['z'], ', ', que[
i]['xe'], ', ', que[i]['ye']
ipt = raw_input("continue?")
lm.assemble(c, ser_ee, que)
if task == 'flex':
ipt = int(raw_input("model1?"))
if ipt == 1:
model = fd.import_file("model1.txt")
elif ipt == 2:
model = fd.import_file("model2.txt")
elif ipt == 3:
model = fd.import_file("model3.txt")
elif ipt == 4:
model = fd.import_file("model4.txt")
elif ipt == 5:
model = fd.import_file("model5.txt")
elif ipt == 6:
model = fd.import_file("model6.txt")
bricks = fd.decode_file(model)
que, updated_model, opt = flx.sort_bricks_flex(bricks, model)
print "flex sort output: ", opt
print "-------------- build --------------"
print "x", ",", " y", ",", " p", ",", " r", ",", " z", ",", "ex", ",", "ey", ",", " b"
for i in range(0, len(que)):
if que[i]['r'] == 0 or que[i]['r'] == 180:
print que[i]['x'], ', ', que[i]['y'], ', ', que[i][
'p'], ', ', que[i]['r'], ', ', que[i]['z'], ', ', -que[
i]['ye'], ', ', que[i]['xe'], ', ', que[i]['b']
else:
print que[i]['x'], ', ', que[i]['y'], ', ', que[i][
'p'], ', ', que[i]['r'], ', ', que[i]['z'], ', ', que[
i]['xe'], ', ', que[i]['ye'], ', ', que[i]['b']
ipt = raw_input("continue?")
que, opt = ass.sort_bricks_ass(que, copy.deepcopy(updated_model))
print "assembly sort output: ", opt
print "-------------- build --------------"
print "x", ",", " y", ",", " p", ",", " r", ",", " z", ",", "ex", ",", "ey", ",", " b"
for i in range(0, len(que)):
if que[i]['r'] == 0 or que[i]['r'] == 180:
print que[i]['x'], ', ', que[i]['y'], ', ', que[i][
'p'], ', ', que[i]['r'], ', ', que[i]['z'], ', ', -que[
i]['ye'], ', ', que[i]['xe'], ', ', que[i]['b']
else:
print que[i]['x'], ', ', que[i]['y'], ', ', que[i][
'p'], ', ', que[i]['r'], ', ', que[i]['z'], ', ', que[
i]['xe'], ', ', que[i]['ye'], ', ', que[i]['b']
print ass.list_cost(que, updated_model)
ipt = raw_input("continue?")
tic = time.time()
delay = lm.assemble(c, ser_ee, que)
tock = time.time()
print "----------- assembly time ----------"
print " ", tock - tic - delay
print "------------- resources ------------"
print " ", len(que)
#que,opt = dis.sort_bricks_dis(que,copy.deepcopy(updated_model))
#print "disassembly sort output: ",opt
#print "-------------- build --------------"
#print "x",","," y",","," p",","," r",","," z",",","ex",",","ey",","," b"
#for i in range(0,len(que)):
# if que[i]['r'] == 0 or que[i]['r'] == 180:
# print que[i]['x'],', ',que[i]['y'],', ',que[i]['p'],', ',que[i]['r'],', ',que[i]['z'],', ',-que[i]['ye'],', ',que[i]['xe'],', ',que[i]['b']
# else:
# print que[i]['x'],', ',que[i]['y'],', ',que[i]['p'],', ',que[i]['r'],', ',que[i]['z'],', ',que[i]['xe'],', ',que[i]['ye'],', ',que[i]['b']
#ipt = raw_input("continue?")
#lm.disassemble(c,ser_ee,que)
if task == "reflex":
ipt = int(raw_input("model1?"))
if ipt == 1:
model1 = fd.import_file("model1.txt")
model2 = fd.import_file("model2.txt")
elif ipt == 2:
model1 = fd.import_file("model2.txt")
model2 = fd.import_file("model3.txt")
elif ipt == 3:
model1 = fd.import_file("model3.txt")
model2 = fd.import_file("model4.txt")
elif ipt == 4:
model1 = fd.import_file("model4.txt")
model2 = fd.import_file("model5.txt")
elif ipt == 5:
model1 = fd.import_file("model5.txt")
model2 = fd.import_file("model6.txt")
bricks1 = fd.decode_file(model1)
#print "1 length: ", len(bricks1)
bricks2 = fd.decode_file(model2)
#print "2 length: ", len(bricks2)
flex1, updated_model1, opt1 = flx.sort_bricks_flex(bricks1, model1)
flex2, updated_model2, opt2 = flx.sort_bricks_flex(bricks2, model2)
dis_list, ass_list = rea.reassemble(flex1, flex2, updated_model1,
updated_model2)
print "dis_list :", dis_list
print "as_list :", ass_list
ipt = raw_input("continue?")
que, opt = dis.sort_bricks_dis(dis_list,
copy.deepcopy(updated_model1))
print "disassembly sort output: ", opt
print "-------------- remove --------------"
print "x", ",", " y", ",", " p", ",", " r", ",", " z"
for i in range(0, len(que)):
if que[i]['r'] == 0 or que[i]['r'] == 180:
print que[i]['x'], ', ', que[i]['y'], ', ', que[i][
'p'], ', ', que[i]['r'], ', ', que[i]['z']
else:
print que[i]['x'], ', ', que[i]['y'], ', ', que[i][
'p'], ', ', que[i]['r'], ', ', que[i]['z']
ipt = raw_input("continue?")
tic1 = time.time()
lm.disassemble(c, ser_ee, que)
toc1 = time.time()
bricks_saved = len(que)
#print "dis length: ", bricks_saved
#print ""
#print ""
que, opt = ass.sort_bricks_ass(ass_list,
copy.deepcopy(updated_model2))
#print "ass length: ", len(que)
#print "P(success): ",p
#print ""
print "assembly sort output: ", opt
print "-------------- build --------------"
print "x", ",", " y", ",", " p", ",", " r", ",", " z", ",", " ex", ",", " ey"
for i in range(0, len(que)):
if que[i]['r'] == 0 or que[i]['r'] == 180:
print que[i]['x'], ', ', que[i]['y'], ', ', que[i][
'p'], ', ', que[i]['r'], ', ', que[i][
'z'], ', ', -que[i]['ye'], ', ', que[i]['xe']
else:
print que[i]['x'], ', ', que[i]['y'], ', ', que[i][
'p'], ', ', que[i]['r'], ', ', que[i]['z'], ', ', que[
i]['xe'], ', ', que[i]['ye']
ipt = raw_input("continue?")
tic2 = time.time()
delay = lm.assemble(c, ser_ee, que)
toc2 = time.time()
print "---------- reassembly time ---------"
print " ", toc2 - tic2 - delay + toc1 - tic1
print "------------- resources ------------"
print " ", len(que) - bricks_saved
if task == 'time':
tic = time.time()
ipt = raw_input("Refill hopper and press enter to continue")
toc = time.time()
print toc - tic
if task == 'gol':
nbricks = int(raw_input("Number of starting bricks: "))
iter = int(raw_input("Number of iterations: "))
gol.game_of_life(c, ser_ee, nbricks, iter)
def find_bricks(remove, brick, updated_model):
remove_bricks = [brick]
if remove_bricks[0]['b'] == 0:
# -------------- 0 -------------- #
if remove & 1 == 1:
if brick['r'] == 0:
remove_brick = find_brick(brick['x'] + 2, brick['y'],
brick['z'], updated_model)
else:
remove_brick = find_brick(brick['x'], brick['y'] - 1,
brick['z'], updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
# -------------- 1 -------------- #
if remove & 2 == 2:
if brick['r'] == 0:
remove_brick = find_brick(brick['x'] + 2, brick['y'] + 1,
brick['z'], updated_model)
else:
remove_brick = find_brick(brick['x'] + 1, brick['y'] - 1,
brick['z'], updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
# -------------- 2 -------------- #
if remove & 4 == 4:
if brick['r'] == 0:
remove_brick = find_brick(brick['x'] + 2, brick['y'] + 2,
brick['z'], updated_model)
else:
remove_brick = find_brick(brick['x'] + 2, brick['y'] - 1,
brick['z'], updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
# -------------- 3 -------------- #
if remove & 8 == 8:
if brick['r'] == 0:
remove_brick = find_brick(brick['x'] + 2, brick['y'] + 3,
brick['z'], updated_model)
else:
remove_brick = find_brick(brick['x'] + 3, brick['y'] - 1,
brick['z'], updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
# -------------- 6 -------------- #
if remove & 64 == 64:
if brick['r'] == 0:
remove_brick = find_brick(brick['x'] - 1, brick['y'] + 3,
brick['z'], updated_model)
else:
remove_brick = find_brick(brick['x'] + 3, brick['y'] + 2,
brick['z'], updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
# -------------- 7 -------------- #
if remove & 128 == 128:
if brick['r'] == 0:
remove_brick = find_brick(brick['x'] - 1, brick['y'] + 2,
brick['z'], updated_model)
else:
remove_brick = find_brick(brick['x'] + 2, brick['y'] + 2,
brick['z'], updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
# -------------- 8 -------------- #
if remove & 256 == 256:
if brick['r'] == 0:
remove_brick = find_brick(brick['x'] - 1, brick['y'] + 1,
brick['z'], updated_model)
else:
remove_brick = find_brick(brick['x'] + 1, brick['y'] + 2,
brick['z'], updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
# -------------- 9 -------------- #
if remove & 512 == 512:
if brick['r'] == 0:
remove_brick = find_brick(brick['x'] - 1, brick['y'],
brick['z'], updated_model)
else:
remove_brick = find_brick(brick['x'], brick['y'] + 2,
brick['z'], updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
elif remove_bricks[0]['b'] == 1:
# -------------- 0 -------------- #
if remove & 1 == 1:
remove_brick = find_brick(brick['x'], brick['y'] + 1, brick['z'],
updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
# -------------- 1 -------------- #
if remove & 2 == 2:
remove_brick = find_brick(brick['x'] + 1, brick['y'] + 1,
brick['z'], updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
# -------------- 2 -------------- #
if remove & 4 == 4:
remove_brick = find_brick(brick['x'] + 2, brick['y'], brick['z'],
updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
# -------------- 3 -------------- #
if remove & 8 == 8:
remove_brick = find_brick(brick['x'] + 2, brick['y'] + 1,
brick['z'], updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
# -------------- 4 -------------- #
if remove & 16 == 16:
remove_brick = find_brick(brick['x'] + 1, brick['y'] + 2,
brick['z'], updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
# -------------- 5 -------------- #
if remove & 32 == 32:
remove_brick = find_brick(brick['x'], brick['y'] + 2, brick['z'],
updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
# -------------- 6 -------------- #
if remove & 64 == 64:
remove_brick = find_brick(brick['x'] - 1, brick['y'] + 1,
brick['z'], updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
# -------------- 7 -------------- #
if remove & 128 == 128:
remove_brick = find_brick(brick['x'] - 1, brick['y'], brick['z'],
updated_model)
if remove_brick != None:
remove_bricks.append(remove_brick)
opt = 'n'
while opt == 'n':
remove_bricks = copy.deepcopy(remove_duplicates(remove_bricks))
new_list, opt = dis.sort_bricks_dis(remove_bricks, updated_model)
if opt == 'n':
for i in range(0, len(new_list)):
r_bricks = list(find_bricks(remove, brick, updated_model))
for j in range(0, len(r_bricks)):
remove_bricks.append(r_bricks[j])
return remove_bricks
def game_of_life(c,ser_ee,nbricks=10,iter=100):
bricks,model = initialise_grid(nbricks)
assembly = []
disassembly = []
print "------------ initial state ------------"
print "x",","," y"
for i in range(0,len(bricks)):
print bricks[i]['x'],', ',bricks[i]['y']
que,opt = ass.sort_bricks_ass(copy.deepcopy(bricks),copy.deepcopy(model))
print "\nAssembly sort output: ",opt
print "-------------- queue --------------"
#print "x",","," y",","," p",","," r",","," ex",","," ey"
print "x\ty\tp\tr\tex\tey"
for i in range(0,len(que)):
print que[i]['x'],'\t',que[i]['y'],'\t',que[i]['p'],'\t',que[i]['r'],'\t',que[i]['ye'],'\t',que[i]['xe']
assembly.append(que)
#lm.clean_assemble(c,ser_ee,que,t=False)
for i in range(0,iter):
#time.sleep(20)
new_bricks,new_model = update_grid(bricks,copy.deepcopy(model))
dis_list, ass_list = rea.reassemble(bricks,new_bricks,copy.deepcopy(model),copy.deepcopy(new_model))
print "-------------- new state --------------"
for i in range(0,len(new_bricks)):
print new_bricks[i]['x'],', ',new_bricks[i]['y']
#raw_input("Continue?")
que,opt = dis.sort_bricks_dis(dis_list,copy.deepcopy(model))
print "\nDisassembly sort output: ",opt
print "-------------- queue --------------"
#print "x",","," y",","," p",","," r",","," ex",","," ey"
print "x\ty\tp\tr\tex\tey"
for i in range(0,len(que)):
print que[i]['x'],'\t',que[i]['y'],'\t',que[i]['p'],'\t',que[i]['r'],'\t',que[i]['ye'],'\t',que[i]['xe']
disassembly.append(que)
#lm.clean_disassemble(c,ser_ee,que,t=False)
que,opt = ass.sort_bricks_ass(ass_list,copy.deepcopy(new_model))
print "\nAssembly sort output: ",opt
print "-------------- queue --------------"
#print "x",","," y",","," p",","," r",","," ex",","," ey"
print "x\ty\tp\tr\tex\tey"
for i in range(0,len(que)):
print que[i]['x'],'\t',que[i]['y'],'\t',que[i]['p'],'\t',que[i]['r'],'\t',que[i]['ye'],'\t',que[i]['xe']
assembly.append(que)
#lm.clean_assemble(c,ser_ee,que,t=False)
if len(ass_list) == 0 and len(dis_list) == 0:
#print 'No bricks remaining'
break
bricks = copy.deepcopy(new_bricks)
model = copy.deepcopy(new_model)
ipt = raw_input('Continue?(y/n)')
if ipt == 'y':
lm.clean_assemble(c,ser_ee,assembly[0],t=False)
for i in range(0,iter):
time.sleep(20)
lm.clean_disassemble(c,ser_ee,disassembly[i],t=False)
lm.clean_assemble(c,ser_ee,assembly[i+1],t=False)
return