개정판 c6498fec
issue #563: bypass sort itself testing and final check remain
Change-Id: I115987584832632527587b7058e87a443add4e15
| DTI_PID/DTI_PID/LineNoTracer.py | ||
|---|---|---|
| 712 | 712 |
for lineNo in docdata.tracerLineNos: |
| 713 | 713 |
lineNo.update_flow_mark(position, length) |
| 714 | 714 |
|
| 715 |
# trace special item |
|
| 716 |
worker.displayMessage.emit('Find line for special item...')
|
|
| 717 |
tracer = SpecialItemTracer([item for item in worker.graphicsView.scene.items() if (type(item) is SymbolSvgItem or type(item) is QEngineeringTextItem) and item.special_item_type], lines) |
|
| 718 |
tracer.execute(worker.displayMessage, worker.updateProgress) |
|
| 719 |
# up to here |
|
| 720 |
|
|
| 715 | 721 |
# sort run flow order |
| 716 | 722 |
fixed_run_infos = [] # QEngineeringLineTracerRunItem s |
| 717 | 723 |
waiting_run_infos = [] # QEngineeringLineTracerRunItem s |
| ... | ... | |
| 726 | 732 |
# if from and to info already was entered, fix run flow |
| 727 | 733 |
if hasattr(lineNo, '_fixed') and lineNo._fixed and not_secondary: |
| 728 | 734 |
fixed_run_infos.append(QEngineeringLineTracerRunItem(run, lineNo, not_trim, not_secondary)) |
| 735 |
run_index += 1 |
|
| 729 | 736 |
continue |
| 730 | 737 |
|
| 731 | 738 |
reference_symbols = [item for item in run.items if issubclass(type(item), SymbolSvgItem) and item.has_in_out_connector()] |
| ... | ... | |
| 793 | 800 |
for run_index in reversed(range(len(waiting_run_infos))): |
| 794 | 801 |
waiting_run_info = waiting_run_infos[run_index] |
| 795 | 802 |
waiting_run = waiting_run_info.run |
| 803 |
|
|
| 804 |
find = False |
|
| 796 | 805 |
for fixed_run_info in fixed_run_infos: |
| 797 | 806 |
fixed_run = fixed_run_info.run |
| 798 | 807 |
if len(waiting_run.items) > 1 and len(fixed_run.items) > 1: |
| ... | ... | |
| 801 | 810 |
waiting_run_info.reverse() |
| 802 | 811 |
fixed_run_infos.append(waiting_run_info) |
| 803 | 812 |
waiting_run_infos.pop(run_index) |
| 813 |
find = True |
|
| 804 | 814 |
break |
| 805 | 815 |
elif waiting_run.items[0].is_connected(fixed_run.items[-1]): |
| 806 | 816 |
fixed_run_infos.append(waiting_run_info) |
| 807 | 817 |
waiting_run_infos.pop(run_index) |
| 818 |
find = True |
|
| 808 | 819 |
break |
| 809 | 820 |
elif waiting_run.items[-1].is_connected(fixed_run.items[-1]): |
| 810 | 821 |
waiting_run_info.reverse() |
| 811 | 822 |
fixed_run_infos.append(waiting_run_info) |
| 812 | 823 |
waiting_run_infos.pop(run_index) |
| 824 |
find = True |
|
| 813 | 825 |
break |
| 814 | 826 |
elif waiting_run.items[-1].is_connected(fixed_run.items[0]): |
| 815 | 827 |
fixed_run_infos.append(waiting_run_info) |
| 816 | 828 |
waiting_run_infos.pop(run_index) |
| 829 |
find = True |
|
| 817 | 830 |
break |
| 818 |
else: |
|
| 819 |
remain_count += 1 |
|
| 820 | 831 |
elif len(fixed_run.items) > 1: |
| 821 | 832 |
# waiting_run is single line |
| 822 | 833 |
if waiting_run.items[0].connectors[0].connectedItem is fixed_run.items[0]: |
| 823 | 834 |
waiting_run_info.reverse() |
| 824 | 835 |
fixed_run_infos.append(waiting_run_info) |
| 825 | 836 |
waiting_run_infos.pop(run_index) |
| 837 |
find = True |
|
| 826 | 838 |
break |
| 827 | 839 |
elif waiting_run.items[0].connectors[0].connectedItem is fixed_run.items[-1]: |
| 828 | 840 |
fixed_run_infos.append(waiting_run_info) |
| 829 | 841 |
waiting_run_infos.pop(run_index) |
| 842 |
find = True |
|
| 830 | 843 |
break |
| 831 | 844 |
elif waiting_run.items[0].connectors[1].connectedItem is fixed_run.items[-1]: |
| 832 | 845 |
waiting_run_info.reverse() |
| 833 | 846 |
fixed_run_infos.append(waiting_run_info) |
| 834 | 847 |
waiting_run_infos.pop(run_index) |
| 848 |
find = True |
|
| 835 | 849 |
break |
| 836 | 850 |
elif waiting_run.items[0].connectors[1].connectedItem is fixed_run.items[0]: |
| 837 | 851 |
fixed_run_infos.append(waiting_run_info) |
| 838 | 852 |
waiting_run_infos.pop(run_index) |
| 853 |
find = True |
|
| 839 | 854 |
break |
| 840 |
else: |
|
| 841 |
remain_count += 1 |
|
| 842 | 855 |
else: |
| 843 | 856 |
if waiting_run.items[0].is_connected(fixed_run.items[0]) and fixed_run.items[0].connectors[0].connectedItem is waiting_run.items[0]: |
| 844 | 857 |
waiting_run.reverse() |
| 845 | 858 |
fixed_run_infos.append(waiting_run_info) |
| 846 | 859 |
waiting_run_infos.pop(run_index) |
| 860 |
find = True |
|
| 847 | 861 |
break |
| 848 | 862 |
elif waiting_run.items[0].is_connected(fixed_run.items[0]) and fixed_run.items[0].connectors[1].connectedItem is waiting_run.items[0]: |
| 849 | 863 |
fixed_run_infos.append(waiting_run_info) |
| 850 | 864 |
waiting_run_infos.pop(run_index) |
| 865 |
find = True |
|
| 851 | 866 |
break |
| 852 | 867 |
elif waiting_run.items[0].is_connected(fixed_run.items[0]) and fixed_run.items[0].connectors[1].connectedItem is waiting_run.items[0]: |
| 853 | 868 |
waiting_run.reverse() |
| 854 | 869 |
fixed_run_infos.append(waiting_run_info) |
| 855 | 870 |
waiting_run_infos.pop(run_index) |
| 871 |
find = True |
|
| 856 | 872 |
break |
| 857 | 873 |
elif waiting_run.items[0].is_connected(fixed_run.items[0]) and fixed_run.items[0].connectors[0].connectedItem is waiting_run.items[0]: |
| 858 | 874 |
fixed_run_infos.append(waiting_run_info) |
| 859 | 875 |
waiting_run_infos.pop(run_index) |
| 876 |
find = True |
|
| 860 | 877 |
break |
| 861 |
else: |
|
| 862 |
remain_count += 1 |
|
| 878 |
if not find: |
|
| 879 |
remain_count += 1 |
|
| 880 |
|
|
| 863 | 881 |
if remain_count_past == remain_count: |
| 864 | 882 |
break |
| 865 | 883 |
else: |
| ... | ... | |
| 868 | 886 |
# third step : body connected run sort |
| 869 | 887 |
fixed_merged_run_infos = [] |
| 870 | 888 |
waiting_mergerd_run_infos = [] |
| 889 |
consumed_count_past = 0 |
|
| 871 | 890 |
for index1 in range(len(waiting_run_infos)): |
| 872 | 891 |
if waiting_run_infos[index1].consumed: |
| 873 | 892 |
continue |
| ... | ... | |
| 875 | 894 |
if index1 == index2 or waiting_run_infos[index2].consumed: |
| 876 | 895 |
continue |
| 877 | 896 |
|
| 878 |
result, merged_run, header = QEngineeringLineTracerRunItem.merge_if_possible(waiting_run_infos[index1], waiting_run_infos[index2]) |
|
| 897 |
result, merged_run_info, header = QEngineeringLineTracerRunItem.merge_if_possible(waiting_run_infos[index1], waiting_run_infos[index2])
|
|
| 879 | 898 |
if result: |
| 880 | 899 |
waiting_run_infos[index1].consumed = True |
| 881 | 900 |
waiting_run_infos[index2].consumed = True |
| 901 |
consumed_count_past += 2 |
|
| 882 | 902 |
if header: |
| 883 |
waiting_mergerd_run_infos.append([index2, index1], merged_run)
|
|
| 903 |
waiting_mergerd_run_infos.append([[index2, index1], merged_run_info])
|
|
| 884 | 904 |
else: |
| 885 |
waiting_mergerd_run_infos.append([index1, index2], merged_run)
|
|
| 905 |
waiting_mergerd_run_infos.append([[index1, index2], merged_run_info])
|
|
| 886 | 906 |
break |
| 887 | 907 |
|
| 888 |
while False: |
|
| 908 |
while True: |
|
| 909 |
consumed_count = 0 |
|
| 889 | 910 |
for index in range(len(waiting_run_infos)): |
| 890 | 911 |
if waiting_run_infos[index].consumed: |
| 912 |
consumed_count += 1 |
|
| 891 | 913 |
continue |
| 892 | 914 |
|
| 893 |
for waiting_mergerd_run_info in waiting_mergerd_run_infos:
|
|
| 894 |
result, merged_run, header = QEngineeringLineTracerRunItem.merge_if_possible(waiting_mergerd_run_info[1], waiting_run_infos[index1])
|
|
| 915 |
for waiting_merged_run_info in waiting_mergerd_run_infos: |
|
| 916 |
result, merged_run_info, header = QEngineeringLineTracerRunItem.merge_if_possible(waiting_merged_run_info[1], waiting_run_infos[index])
|
|
| 895 | 917 |
if result: |
| 896 | 918 |
waiting_run_infos[index].consumed = True |
| 919 |
consumed_count += 1 |
|
| 897 | 920 |
if header: |
| 898 |
waiting_mergerd_run_infos.append(waiting_mergerd_run_info[0].insert(0, index), merged_run) |
|
| 921 |
waiting_merged_run_info[0].insert(0, index) |
|
| 922 |
waiting_merged_run_info[1] = merged_run_info |
|
| 899 | 923 |
else: |
| 900 |
waiting_mergerd_run_infos.append(waiting_mergerd_run_info[0].append(index), merged_run) |
|
| 924 |
waiting_merged_run_info[0].append(index) |
|
| 925 |
waiting_merged_run_info[1] = merged_run_info |
|
| 926 |
|
|
| 927 |
if consumed_count_past == consumed_count: |
|
| 928 |
break |
|
| 929 |
else: |
|
| 930 |
consumed_count_past = consumed_count |
|
| 901 | 931 |
|
| 902 |
# trace special item |
|
| 903 |
worker.displayMessage.emit('Find line for special item...')
|
|
| 904 |
tracer = SpecialItemTracer([item for item in worker.graphicsView.scene.items() if (type(item) is SymbolSvgItem or type(item) is QEngineeringTextItem) and item.special_item_type], lines) |
|
| 905 |
tracer.execute(worker.displayMessage, worker.updateProgress) |
|
| 906 |
# up to here |
|
| 907 | 932 |
except Exception as ex: |
| 908 | 933 |
from App import App |
| 909 | 934 |
message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)
|
| DTI_PID/DTI_PID/Shapes/EngineeringLineTracerRunItem.py | ||
|---|---|---|
| 15 | 15 |
|
| 16 | 16 |
def __init__(self, run, lineNo=None, not_trim=None, not_secondary=None, consumed=False): |
| 17 | 17 |
self.run = run |
| 18 |
self.lineNo = lineNo if lineNo else self.run.onwer
|
|
| 18 |
self.lineNo = lineNo if lineNo else self.run.owner
|
|
| 19 | 19 |
|
| 20 | 20 |
if not_trim: |
| 21 | 21 |
self.not_trim = not_trim |
| ... | ... | |
| 38 | 38 |
@staticmethod |
| 39 | 39 |
def merge_if_possible(run_info1, run_info2): |
| 40 | 40 |
""" return True and merged run items if run is connected, return True if run2 is come first """ |
| 41 |
return False, [], False
|
|
| 41 |
""" run_info1 is fixed, modify run_info2"""
|
|
| 42 | 42 |
|
| 43 | 43 |
connected = False |
| 44 | 44 |
merged_items = [] |
| ... | ... | |
| 63 | 63 |
run_info2.reverse() |
| 64 | 64 |
merged_items = run_info2.run.items + run_info1.run.items |
| 65 | 65 |
|
| 66 |
return connected, merged_items, header |
|
| 66 |
if connected: |
|
| 67 |
merged_run = QEngineeringRunItem() |
|
| 68 |
merged_run.items = merged_items |
|
| 69 |
|
|
| 70 |
return connected, QEngineeringLineTracerRunItem(merged_run), header |
|
내보내기 Unified diff
