개정판 91a08862
issue #563: 4 test
Change-Id: I92f171c88d34f0d7da903dec521d2932c7434b22
| DTI_PID/DTI_PID/LineNoTracer.py | ||
|---|---|---|
| 919 | 919 |
remain_count_past = remain_count |
| 920 | 920 |
|
| 921 | 921 |
# fourth step : body connected split run or split owner run sort |
| 922 |
fixed_merged_run_infos = [] # [[run_info1, run_info2, ... in order], [merged run items]] |
|
| 923 |
waiting_merged_run_infos = [] # [[run_info1, run_info2, ... in order], [merged run items]] |
|
| 922 |
fixed_merged_run_infos = [] # [[run_info1, run_info2, ... in order], [merged run with items]]
|
|
| 923 |
waiting_merged_run_infos = [] # [[run_info1, run_info2, ... in order], [merged run with items]]
|
|
| 924 | 924 |
|
| 925 | 925 |
# waiting run merge and sort |
| 926 | 926 |
consumed_count_past = 0 |
| ... | ... | |
| 975 | 975 |
if index1 == index2: |
| 976 | 976 |
continue |
| 977 | 977 |
waiting_merged_run_info2 = waiting_merged_run_infos[index2] |
| 978 |
result, merged_run_info, header, reverse = QEngineeringLineTracerRunItem.merge_and_sort_if_possible(waiting_merged_run_info1[1], waiting_merged_run_info2[1]) |
|
| 978 |
result, merged_run_info, header, reverse = QEngineeringLineTracerRunItem.merge_and_sort_if_possible(waiting_merged_run_info1[1], waiting_merged_run_info2[1], sort_connect_info=False)
|
|
| 979 | 979 |
if result: |
| 980 | 980 |
if header: |
| 981 | 981 |
if reverse: |
| ... | ... | |
| 1001 | 1001 |
break |
| 1002 | 1002 |
|
| 1003 | 1003 |
# fixed run merge |
| 1004 |
''' |
|
| 1005 | 1004 |
consumed_count_past = 0 |
| 1006 | 1005 |
for index1 in range(len(fixed_run_infos)): |
| 1007 | 1006 |
if fixed_run_infos[index1].consumed: |
| ... | ... | |
| 1010 | 1009 |
if index1 == index2 or fixed_run_infos[index2].consumed: |
| 1011 | 1010 |
continue |
| 1012 | 1011 |
|
| 1013 |
result, merged_run_info, header, reverse = QEngineeringLineTracerRunItem.merge_and_sort_if_possible(fixed_run_infos[index1], fixed_run_infos[index2]) |
|
| 1012 |
result, merged_run_info, header, reverse = QEngineeringLineTracerRunItem.merge_and_sort_if_possible(fixed_run_infos[index1], fixed_run_infos[index2], sort=False)
|
|
| 1014 | 1013 |
if result: |
| 1015 | 1014 |
fixed_run_infos[index1].consumed = True |
| 1016 | 1015 |
fixed_run_infos[index2].consumed = True |
| 1017 | 1016 |
consumed_count_past += 2 |
| 1018 | 1017 |
if header: |
| 1019 |
waiting_merged_run_infos.append([[fixed_run_infos[index2], fixed_run_infos[index1]], merged_run_info])
|
|
| 1018 |
fixed_merged_run_infos.append([[fixed_run_infos[index2], fixed_run_infos[index1]], merged_run_info])
|
|
| 1020 | 1019 |
else: |
| 1021 |
waiting_merged_run_infos.append([[fixed_run_infos[index1], fixed_run_infos[index2]], merged_run_info])
|
|
| 1020 |
fixed_merged_run_infos.append([[fixed_run_infos[index1], fixed_run_infos[index2]], merged_run_info])
|
|
| 1022 | 1021 |
break |
| 1023 | 1022 |
|
| 1024 | 1023 |
while True: |
| ... | ... | |
| 1028 | 1027 |
consumed_count += 1 |
| 1029 | 1028 |
continue |
| 1030 | 1029 |
|
| 1031 |
for waiting_merged_run_info in waiting_merged_run_infos:
|
|
| 1032 |
result, merged_run_info, header, reverse = QEngineeringLineTracerRunItem.merge_and_sort_if_possible(waiting_merged_run_info[1], fixed_run_infos[index])
|
|
| 1030 |
for fixed_merged_run_info in fixed_merged_run_infos:
|
|
| 1031 |
result, merged_run_info, header, reverse = QEngineeringLineTracerRunItem.merge_and_sort_if_possible(fixed_merged_run_info[1], fixed_run_infos[index], sort=False)
|
|
| 1033 | 1032 |
if result: |
| 1034 | 1033 |
fixed_run_infos[index].consumed = True |
| 1035 | 1034 |
consumed_count += 1 |
| 1036 | 1035 |
if header: |
| 1037 |
waiting_merged_run_info[0].insert(0, fixed_run_infos[index])
|
|
| 1038 |
waiting_merged_run_info[1] = merged_run_info
|
|
| 1036 |
fixed_merged_run_info[0].insert(0, fixed_run_infos[index])
|
|
| 1037 |
fixed_merged_run_info[1] = merged_run_info
|
|
| 1039 | 1038 |
else: |
| 1040 |
waiting_merged_run_info[0].append(fixed_run_infos[index])
|
|
| 1041 |
waiting_merged_run_info[1] = merged_run_info
|
|
| 1039 |
fixed_merged_run_info[0].append(fixed_run_infos[index])
|
|
| 1040 |
fixed_merged_run_info[1] = merged_run_info
|
|
| 1042 | 1041 |
break |
| 1043 | 1042 |
|
| 1044 | 1043 |
if consumed_count_past == consumed_count: |
| ... | ... | |
| 1048 | 1047 |
|
| 1049 | 1048 |
while True: |
| 1050 | 1049 |
merged = False |
| 1051 |
for index1 in range(len(waiting_merged_run_infos)):
|
|
| 1052 |
waiting_merged_run_info1 = waiting_merged_run_infos[index1]
|
|
| 1053 |
for index2 in range(len(waiting_merged_run_infos)):
|
|
| 1050 |
for index1 in range(len(fixed_merged_run_infos)):
|
|
| 1051 |
fixed_merged_run_info1 = fixed_merged_run_infos[index1]
|
|
| 1052 |
for index2 in range(len(fixed_merged_run_infos)):
|
|
| 1054 | 1053 |
if index1 == index2: |
| 1055 | 1054 |
continue |
| 1056 |
waiting_merged_run_info2 = waiting_merged_run_infos[index2]
|
|
| 1057 |
result, merged_run_info, header, reverse = QEngineeringLineTracerRunItem.merge_and_sort_if_possible(waiting_merged_run_info1[1], waiting_merged_run_info2[1])
|
|
| 1055 |
fixed_merged_run_info2 = fixed_merged_run_infos[index2]
|
|
| 1056 |
result, merged_run_info, header, reverse = QEngineeringLineTracerRunItem.merge_and_sort_if_possible(fixed_merged_run_info1[1], fixed_merged_run_info2[1], sort=False)
|
|
| 1058 | 1057 |
if result: |
| 1059 | 1058 |
if header: |
| 1060 |
if reverse: |
|
| 1061 |
for waiting_run_info in waiting_merged_run_info2[0]: |
|
| 1062 |
waiting_run_info.reverse() |
|
| 1063 |
waiting_merged_run_info2[0].reverse() |
|
| 1064 |
waiting_merged_run_info2[0].extend(waiting_merged_run_info1[0]) |
|
| 1065 |
waiting_merged_run_info1[0] = waiting_merged_run_info2[0] |
|
| 1066 |
waiting_merged_run_info1[1] = merged_run_info |
|
| 1059 |
fixed_merged_run_info1[0] = fixed_merged_run_info2[0] |
|
| 1060 |
fixed_merged_run_info1[1] = merged_run_info |
|
| 1067 | 1061 |
else: |
| 1068 |
if reverse: |
|
| 1069 |
for waiting_run_info in waiting_merged_run_info2[0]: |
|
| 1070 |
waiting_run_info.reverse() |
|
| 1071 |
waiting_merged_run_info2[0].reverse() |
|
| 1072 |
waiting_merged_run_info1[0].extend(waiting_merged_run_info2[0]) |
|
| 1073 |
waiting_merged_run_info1[1] = merged_run_info |
|
| 1062 |
fixed_merged_run_info1[0].extend(fixed_merged_run_info2[0]) |
|
| 1063 |
fixed_merged_run_info1[1] = merged_run_info |
|
| 1074 | 1064 |
merged = True |
| 1075 | 1065 |
break |
| 1076 | 1066 |
if merged: |
| 1077 |
waiting_merged_run_infos.pop(index2)
|
|
| 1067 |
fixed_merged_run_infos.pop(index2)
|
|
| 1078 | 1068 |
break |
| 1079 | 1069 |
if not merged: |
| 1080 | 1070 |
break |
| 1081 |
''' |
|
| 1071 |
|
|
| 1072 |
for fixed_run_info in fixed_run_infos: |
|
| 1073 |
if fixed_run_info.consumed: |
|
| 1074 |
continue |
|
| 1075 |
else: |
|
| 1076 |
fixed_merged_run_infos.append([[fixed_run_info], fixed_run_info.run]) |
|
| 1077 |
|
|
| 1078 |
# sort merged waiting runs by using merged fixed runs |
|
| 1079 |
remain_count_past = len(waiting_merged_run_infos) |
|
| 1080 |
while True: |
|
| 1081 |
remain_count = 0 |
|
| 1082 |
for run_index in reversed(range(len(waiting_merged_run_infos))): |
|
| 1083 |
waiting_run_info = waiting_merged_run_infos[run_index][0] |
|
| 1084 |
waiting_merged_run = waiting_merged_run_infos[run_index][1].run |
|
| 1085 |
|
|
| 1086 |
find = False |
|
| 1087 |
for fixed_merged_run_info in fixed_merged_run_infos: |
|
| 1088 |
fixed_merged_run = fixed_merged_run_info[1].run |
|
| 1089 |
if len(waiting_merged_run.items) > 1 and len(fixed_merged_run.items) > 1 and type(waiting_merged_run.items[0]) is QEngineeringLineItem and type(waiting_merged_run.items[-1]) is QEngineeringLineItem: |
|
| 1090 |
if waiting_merged_run.items[0].connectors[0].connectedItem in fixed_merged_run.items and waiting_merged_run.items[-1].connectors[1].connectedItem in fixed_merged_run.items: |
|
| 1091 |
if fixed_merged_run.items.index(waiting_merged_run.items[0].connectors[0].connectedItem) > fixed_merged_run.items.index(waiting_merged_run.items[-1].connectors[1].connectedItem): |
|
| 1092 |
for waiting_run_info in waiting_merged_run_infos[run_index][0]: |
|
| 1093 |
waiting_run_info.reverse() |
|
| 1094 |
waiting_merged_run_infos[run_index][0].reverse() |
|
| 1095 |
reverse_order = [] |
|
| 1096 |
for index in reversed(range(len(waiting_merged_run_infos[run_index][1].run.items))): |
|
| 1097 |
reverse_order.append(waiting_merged_run_infos[run_index][1].run.items[index]) |
|
| 1098 |
waiting_merged_run_infos[run_index][1].run.items = reverse_order |
|
| 1099 |
fixed_merged_run_infos.append(waiting_merged_run_infos[run_index]) |
|
| 1100 |
waiting_merged_run_infos.pop(run_index) |
|
| 1101 |
find = True |
|
| 1102 |
break |
|
| 1103 |
else: |
|
| 1104 |
fixed_merged_run_infos.append(waiting_merged_run_infos[run_index]) |
|
| 1105 |
waiting_merged_run_infos.pop(run_index) |
|
| 1106 |
find = True |
|
| 1107 |
break |
|
| 1108 |
|
|
| 1109 |
if not find: |
|
| 1110 |
remain_count += 1 |
|
| 1111 |
|
|
| 1112 |
if remain_count_past == remain_count: |
|
| 1113 |
break |
|
| 1114 |
else: |
|
| 1115 |
remain_count_past = remain_count |
|
| 1082 | 1116 |
|
| 1083 | 1117 |
except Exception as ex: |
| 1084 | 1118 |
from App import App |
| DTI_PID/DTI_PID/Shapes/EngineeringLineTracerRunItem.py | ||
|---|---|---|
| 36 | 36 |
self.run.reverse() |
| 37 | 37 |
|
| 38 | 38 |
@staticmethod |
| 39 |
def merge_and_sort_if_possible(run_info1, run_info2, sort=True): |
|
| 39 |
def merge_and_sort_if_possible(run_info1, run_info2, sort=True, sort_connect_info=True):
|
|
| 40 | 40 |
""" return True, and merged run items if run is connected, True if run2 is come first """ |
| 41 | 41 |
""" run_info1 is fixed, modify run_info2 """ |
| 42 | 42 |
""" if sort is False, do not modify and sort just merge """ |
| 43 |
""" if sort_connect_info is False just sort item order not connection info and flow """ |
|
| 43 | 44 |
|
| 44 | 45 |
connected = False |
| 45 | 46 |
merged_items = [] |
| ... | ... | |
| 70 | 71 |
connected = True |
| 71 | 72 |
header = False |
| 72 | 73 |
reverse = True |
| 73 |
run_info2.reverse() |
|
| 74 |
if sort_connect_info: |
|
| 75 |
run_info2.reverse() |
|
| 76 |
else: |
|
| 77 |
reverse_order = [] |
|
| 78 |
for index in reversed(range(len(run_info2.run.items))): |
|
| 79 |
reverse_order.append(run_info2.run.items[index]) |
|
| 80 |
run_info2.run.items = reverse_order |
|
| 74 | 81 |
merged_items = run_info1.run.items + run_info2.run.items |
| 75 | 82 |
elif (len(run_info1.run.items) > 1 and len(run_info2.run.items) > 1 and run_info1.run.items[0].is_connected(run_info2.run.items[-1]) and \ |
| 76 | 83 |
run_info2.run.items[-1].is_connected(run_info1.run.items[0])) or \ |
| ... | ... | |
| 95 | 102 |
connected = True |
| 96 | 103 |
header = True |
| 97 | 104 |
reverse = True |
| 98 |
run_info2.reverse() |
|
| 105 |
if sort_connect_info: |
|
| 106 |
run_info2.reverse() |
|
| 107 |
else: |
|
| 108 |
reverse_order = [] |
|
| 109 |
for index in reversed(range(len(run_info2.run.items))): |
|
| 110 |
reverse_order.append(run_info2.run.items[index]) |
|
| 111 |
run_info2.run.items = reverse_order |
|
| 99 | 112 |
merged_items = run_info2.run.items + run_info1.run.items |
| 100 | 113 |
|
| 101 | 114 |
if connected: |
내보내기 Unified diff
