def sort_layer_dis(sub_bricks, model):
pickable = 0
groups = [0]
updated_model = copy.deepcopy(model)
build_que = copy.deepcopy(sub_bricks)
#print 'start: '
#for i in range(0,len(build_que)):
# print build_que[i]['x']+build_que[i]['px'],', ',build_que[i]['y']+build_que[i]['py']
while pickable == 0:
group, build_que[
groups[-1]:len(sub_bricks)], pickable = sort_pickable_dis(
build_que[groups[-1]:len(sub_bricks)], updated_model)
if group == 0:
return 'n', build_que[groups[-1]:len(sub_bricks)]
groups.append(groups[-1] + group)
updated_model = fd.update_model(build_que[groups[-2]:groups[-1]],
updated_model)
#print 'pickable: '
#for i in range(groups[-2],groups[-1]):
# print build_que[i]['x']+build_que[i]['px'],', ',build_que[i]['y']+build_que[i]['py']
#print 'not pickable: '
#for i in range(groups[-1],len(sub_bricks)):
# print build_que[i]['x']+build_que[i]['px'],', ',build_que[i]['y']+build_que[i]['py']
return groups, build_que
def sort_layer_ass(sub_bricks, model):
placeable = 0
groups = [len(sub_bricks)]
updated_model = copy.deepcopy(model)
build_que = copy.deepcopy(sub_bricks)
#print 'start: '
#for i in range(0,len(build_que)):
# print build_que[i]['x']+build_que[i]['px'],', ',build_que[i]['y']+build_que[i]['py']
while placeable == 0:
group, build_que[0:groups[0]], placeable = sort_placeable_ass(
build_que[0:groups[0]], updated_model)
if group == len(build_que[0:groups[0]]):
return 'n', build_que[0:groups[0]]
groups.insert(0, group)
updated_model = fd.update_model(build_que[groups[0]:groups[1]],
updated_model)
#print 'placeable: '
#for i in range(groups[0],groups[-1]):
# if build_que[i]['r'] == 0 or build_que[i]['r'] == 180:
# print build_que[i]['x'],', ',build_que[i]['y']+build_que[i]['p']
# else:
# print build_que[i]['x']+build_que[i]['p'],', ',build_que[i]['y']
#print 'not placeable: '
#for i in range(0,groups[0]):
# if build_que[i]['r'] == 0 or build_que[i]['r'] == 180:
# print build_que[i]['x'],', ',build_que[i]['y']+build_que[i]['p']
# else:
# print build_que[i]['x']+build_que[i]['p'],', ',build_que[i]['y']
#print '\n'
return groups, build_que
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 list_picking(bricks, model):
updated_model = list(model)
P = 1
k = len(bricks)
for i in range(0, k):
constraints = fd.brick_constraints(bricks[i], updated_model)
bricks[i] = dict(update_placing(bricks[i], constraints))
updated_model = fd.update_model(bricks[i:i + 1], updated_model)
return bricks
def list_placing(bricks, model):
updated_model = list(model)
P = 1
k = len(bricks)
for i in range(0, k):
constraints = fd.brick_constraints(bricks[k - 1 - i], updated_model)
bricks[k - 1 - i] = dict(update_placing(
bricks[k - 1 - i],
constraints)) #temp dict(update_placing) once deleted p
#P = P*p
updated_model = fd.update_model(bricks[k - 1 - i:k - i], updated_model)
return bricks #,P #temp delete p
def sort_layer_ass(sub_bricks, model):
placeable = 0
groups = [len(sub_bricks)]
updated_model = copy.deepcopy(model)
build_que = copy.deepcopy(sub_bricks)
#print 'start: '
#for i in range(0,len(build_que)):
# print build_que[i]['x']+build_que[i]['px'],', ',build_que[i]['y']+build_que[i]['py']
while placeable == 0:
group, build_que[0:groups[0]], placeable = sort_placeable_ass(
build_que[0:groups[0]], updated_model)
if group == len(build_que[0:groups[0]]
): # if all bricks are unplaceable by std method
# additional tool sort for gol reassembly
group, build_que[0:groups[0]], placeable = sort_placeable_tool(
build_que[0:groups[0]], updated_model)
if group == len(
build_que[0:groups[0]]
): # if all bricks are unplaceable by tool method (only true if some cases are removed)
return group, build_que[0:groups[0]], 'n'
# std tool reassembly
#groups.insert(0,0)
#return groups,build_que,'n'
# reassembly without tool
#return 'n',build_que[0:groups[0]]
groups.insert(0, group)
updated_model = fd.update_model(build_que[groups[0]:groups[1]],
updated_model)
#print 'placeable: '
#for i in range(groups[0],groups[-1]):
# if build_que[i]['r'] == 0 or build_que[i]['r'] == 180:
# print build_que[i]['x'],', ',build_que[i]['y']+build_que[i]['p']
# else:
# print build_que[i]['x']+build_que[i]['p'],', ',build_que[i]['y']
#print 'not placeable: '
#for i in range(0,groups[0]):
# if build_que[i]['r'] == 0 or build_que[i]['r'] == 180:
# print build_que[i]['x'],', ',build_que[i]['y']+build_que[i]['p']
# else:
# print build_que[i]['x']+build_que[i]['p'],', ',build_que[i]['y']
#print '\n'
return groups, build_que, 'y'
def sort_bricks_ass(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))
# sort each layer into sub-groups, label end of each sub-group
opt = 'y'
sub_groups = []
for i in range(0, len(layers) - 1):
#sub_groups.append([0])
#print "layer ", i,": "
sub_group, build_que[layers[i]:layers[i + 1]], opt = copy.deepcopy(
sort_layer_ass(bricks[layers[i]:layers[i + 1]], model))
# only for gol
if opt == 'n':
return build_que[layers[i]:layers[i + 1]], 'n'
sub_groups.append(sub_group)
# optimise picking order of each sub-group
for i in range(0, len(layers) - 1):
for j in range(0, len(sub_groups[i]) - 1):
updated_model = copy.deepcopy(model)
updated_model = fd.update_model(
build_que[layers[i] + sub_groups[i][j + 1]:layers[i] +
sub_groups[i][-1]], updated_model)
build_que[layers[i] + sub_groups[i][j]:layers[i] +
sub_groups[i][j + 1]] = list(
rnd_force_ass(
build_que[layers[i] +
sub_groups[i][j]:layers[i] +
sub_groups[i][j + 1]], updated_model))
# update picking method
build_que = list(list_placing(build_que, model))
return build_que, opt #,p #temp delete p
def list_cost(bricks, model):
cost = 0
#tic1 = time.time()
updated_model = copy.deepcopy(model)
#tic2 = time.time()
k = len(bricks)
#tic3=0
#tic4=0
#tic5=0
#tic6=0
for i in range(0, k):
#tic3 += time.time()
constraints = fd.brick_constraints(bricks[k - 1 - i], updated_model)
#tic4 += time.time()
cost += brick_cost(bricks[k - 1 - i], constraints)
#tic5 += time.time()
updated_model = fd.update_model(bricks[k - 1 - i:k - i], updated_model)
#tic6 += time.time()
#print "times: ",tic2-tic1,tic4-tic3,tic5-tic4,tic6-tic5
return cost
def reassemble(bricks_old, bricks_new, model_old, model_new):
dis_list = []
updated_model = copy.deepcopy(model_old)
# find old bricks not existant in new structure, remove all bricks above
lowest = bricks_old[-1]
for i in range(0, len(bricks_old)):
flag = 0
for j in range(0, len(bricks_new)):
if fd.match_bricks(bricks_old[i], bricks_new[j]) == 1:
flag = 1
break
if flag == 0: #brick doesn't exist in new structure
dis_list.append(bricks_old[i])
if bricks_old[i]['z'] < lowest['z']:
lowest = bricks_old[i]
# find lowest new brick
for i in range(0, len(bricks_new)):
flag = 0
for j in range(0, len(bricks_old)):
if fd.match_bricks(bricks_new[i], bricks_old[j]) == 1:
flag = 1
break
if flag == 0: #brick doesn't exist in old structure
if bricks_new[i]['z'] < lowest['z']:
lowest = bricks_new[i]
# find min no. bricks to safely disasseble
for i in range(0, len(dis_list)):
constraints = fd.brick_constraints(dis_list[i],
copy.deepcopy(updated_model))
if pickable(
dis_list[i]['b'], constraints
) != 1: # if not pickable: find neighbouring bricks to remove
remove_bricks = critical_neighbours(constraints, dis_list[i],
updated_model)
for j in range(0, len(remove_bricks)):
dis_list.append(remove_bricks[j])
dis_list = copy.deepcopy(remove_duplicates(dis_list))
updated_model = fd.update_model(remove_bricks, updated_model)
#above_bricks = critical_above
# remove layers above lowest discrepancy
index = len(bricks_old)
for i in range(0, len(bricks_old)):
if bricks_old[i]['z'] == lowest['z'] + 1:
index = i
break
dis_list = dis_list + list(bricks_old[index:])
if len(dis_list) > 0:
dis_list = copy.deepcopy(remove_duplicates(dis_list))
# update bricks_old list
bricks_intermediate = []
for i in range(0, len(bricks_old)):
flag = 0
for j in range(0, len(dis_list)):
if fd.match_bricks(bricks_old[i], dis_list[j]) == 1:
flag = 1
if flag == 0:
bricks_intermediate.append(bricks_old[i])
# find new bricks not existant in intermediate structure, build all
#lowest = bricks_new[-1]
ass_list = []
for i in range(0, len(bricks_new)):
flag = 0
for j in range(0, len(bricks_intermediate)):
if fd.match_bricks(bricks_new[i], bricks_intermediate[j]) == 1:
flag = 1
if flag == 0: #brick doesn't exist in old structure
ass_list.append(bricks_new[i])
#if bricks_new[i]['z']<lowest['z']:
# lowest = bricks_new[i]
# only for gol
# if not assemblable, sort will return bricks which cannot be assembled, and 'n', otherwise sorted list and 'y'
blocking_bricks = []
que, opt = ass.sort_bricks_ass(ass_list, copy.deepcopy(model_new))
if opt == 'n' and len(que) != 0:
for i in range(0, len(que)):
bb = find_brick(que[i]['x'], que[i]['y'] - 1, que[i]['z'],
model_new)
if bb != None:
blocking_bricks.append(bb)
bb = find_brick(que[i]['x'] + 2, que[i]['y'], que[i]['z'],
model_new)
if bb != None:
blocking_bricks.append(bb)
bb = find_brick(que[i]['x'], que[i]['y'] + 2, que[i]['z'],
model_new)
if bb != None:
blocking_bricks.append(bb)
bb = find_brick(que[i]['x'] - 1, que[i]['y'], que[i]['z'],
model_new)
if bb != None:
blocking_bricks.append(bb)
blocking_bricks = list(remove_duplicates(blocking_bricks))
# check if 1 brick can be removed to fix assembly
ass_list.append(blocking_bricks[0])
for i in range(0, len(blocking_bricks)):
ass_list[-1] = blocking_bricks[i]
que, opt = ass.sort_bricks_ass(ass_list, copy.deepcopy(model_new))
if opt == 'y':
dis_list.append(blocking_bricks[i])
return dis_list, ass_list
# check if 2 bricks can be removed to fix assembly
ass_list[-1] = blocking_bricks[0]
ass_list.append(blocking_bricks[1])
for i in range(0, len(blocking_bricks) - 1):
ass_list[-2] = blocking_bricks[i]
for j in range(i + 1, len(blocking_bricks)):
ass_list[-1] = blocking_bricks[j]
que, opt = ass.sort_bricks_ass(ass_list,
copy.deepcopy(model_new))
if opt == 'y':
dis_list.append(blocking_bricks[i])
dis_list.append(blocking_bricks[j])
return dis_list, ass_list
return 'help'
#index = len(bricks_new)
#for i in range(0,len(bricks_new)):
# if bricks_new[i]['z'] == lowest['z']+1:
# index = i
# break
#ass_list = list(bricks_new[index:])
#ass_list.insert(0,lowest)
return dis_list, ass_list
def reassemble(bricks_old, bricks_new, model_old, model_new):
dis_list = []
updated_model = copy.deepcopy(model_old)
# find old bricks not existant in new structure, remove all bricks above
lowest = bricks_old[-1]
for i in range(0, len(bricks_old)):
flag = 0
for j in range(0, len(bricks_new)):
if fd.match_bricks(bricks_old[i], bricks_new[j]) == 1:
flag = 1
if flag == 0: #brick doesn't exist in old structure
dis_list.append(bricks_old[i])
if bricks_old[i]['z'] < lowest['z']:
lowest = bricks_old[i]
# find lowest new brick
for i in range(0, len(bricks_new)):
flag = 0
for j in range(0, len(bricks_old)):
if fd.match_bricks(bricks_new[i], bricks_old[j]) == 1:
flag = 1
if flag == 0: #brick doesn't exist in old structure
if bricks_new[i]['z'] < lowest['z']:
lowest = bricks_new[i]
# find min no. bricks to safely disasseble
for i in range(0, len(dis_list)):
constraints = fd.brick_constraints(dis_list[i], updated_model)
if pickable(
dis_list[i]['b'], constraints
) != 1: # if not pickable: find neighbouring bricks to remove
remove_bricks = critical_neighbours(constraints, dis_list[i],
updated_model)
for j in range(0, len(remove_bricks)):
dis_list.append(remove_bricks[j])
dis_list = copy.deepcopy(remove_duplicates(dis_list))
updated_model = fd.update_model(remove_bricks, updated_model)
#above_bricks = critical_above
# remove layers above lowest discrepancy
index = len(bricks_old)
for i in range(0, len(bricks_old)):
if bricks_old[i]['z'] == lowest['z'] + 1:
index = i
break
dis_list = dis_list + list(bricks_old[index:])
if len(dis_list) > 0:
dis_list = copy.deepcopy(remove_duplicates(dis_list))
# update bricks_old list
bricks_intermediate = []
for i in range(0, len(bricks_old)):
flag = 0
for j in range(0, len(dis_list)):
if fd.match_bricks(bricks_old[i], dis_list[j]) == 1:
flag = 1
if flag == 0:
bricks_intermediate.append(bricks_old[i])
# find new bricks not existant in intermediate structure, build all
#lowest = bricks_new[-1]
ass_list = []
for i in range(0, len(bricks_new)):
flag = 0
for j in range(0, len(bricks_intermediate)):
if fd.match_bricks(bricks_new[i], bricks_intermediate[j]) == 1:
flag = 1
if flag == 0: #brick doesn't exist in old structure
ass_list.append(bricks_new[i])
#if bricks_new[i]['z']<lowest['z']:
# lowest = bricks_new[i]
#index = len(bricks_new)
#for i in range(0,len(bricks_new)):
# if bricks_new[i]['z'] == lowest['z']+1:
# index = i
# break
#ass_list = list(bricks_new[index:])
#ass_list.insert(0,lowest)
return dis_list, ass_list
