HYTOS

# coding: utf-8

""" This is line no tracer module """

import sys

import math

import asyncio

import shapely

from AppDocData import AppDocData, MessageType

from EngineeringLineItem import QEngineeringLineItem

from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from QEngineeringFlowArrowItem import QEngineeringFlowArrowItem

from SymbolSvgItem import SymbolSvgItem

from EngineeringTextItem import QEngineeringTextItem

from EngineeringUnknownItem import QEngineeringUnknownItem

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import *

        from PyQt4.QtGui import *

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

class LineNoTracer:

    '''

        @history    2018.04.26 Jeongwoo Variable name changed (texts → lineNos)

    '''

    def __init__(self, symbols, lines, lineNos, specBreaks, lineIndicators, vendors, end_breaks):

        try:

            self._symbols = symbols

            self._lines = lines

            self._lineNos = lineNos

            self._spec_breaks = specBreaks

            self._lineIndicator = lineIndicators

            self._end_breaks = end_breaks

            self.maxValue = None

            """

            for spec in self._specBreak:

                for attr in spec.attrs:

                    if type(attr) is tuple and attr[1] != '':

                        self._specBreakUID.append(attr[1])

            """

        except Exception as ex:

            from App import App

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                           sys.exc_info()[-1].tb_lineno)

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

        @brief  find primary lines connected to given line no

        @author humkyung

    '''

    def find_primary_lines(self, lineno, include_signal=True):

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringRunItem import QEngineeringRunItem

        connected_items = []

        _from = lineno.prop('From')

        _to = lineno.prop('To')

        if _from and _to and lineno.empty():

            connected_items = self.find_connected_objects(_from, to=_to, primary=True, include_signal=include_signal)

            if _from in connected_items and _to in connected_items:

                start = connected_items.index(_from)

                end = connected_items.index(_to)

                if start < end:

                    connected_items = connected_items[start:end + 1]

                else:

                    connected_items = connected_items[end:start + 1]

                    connected_items.reverse()

        elif (not _from or not _to) and (1 == len(lineno.conns)):

            connected_items = self.find_connected_objects(lineno.conns[0], include_signal=include_signal)

        # print(connected_items)

        if connected_items:

            for item in connected_items:

                item.owner = lineno  # set item's owner

            line_run = QEngineeringRunItem()

            line_run.items = connected_items

            line_run.arrange_flow_direction()

            line_run.owner = lineno

            lineno.runs.append(line_run)

            lineno.set_property('From', connected_items[0])

            lineno.set_property('To', connected_items[-1])

        if _to is not None and connected_items and connected_items[-1] is not _to:

            _to.owner = None

        return connected_items

    '''

        @brief  find secondary lines

        @author humkyung

    '''

    def find_secondary_lines(self, lines_and_symbols, include_signal=True, is_trim=False):

        from EngineeringAbstractItem import QEngineeringAbstractItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringRunItem import QEngineeringRunItem

        from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

        try:

            foundCount = 1

            while foundCount:

                foundCount = 0

                notMatches = []

                for line in lines_and_symbols:

                    if line.owner is not None: continue

                    if not include_signal and type(line) is QEngineeringLineItem and not line.is_piping(): continue

                    if not is_trim:

                        line_matches = [x for x in self._lines if

                                        x.owner and line.is_connected(x, QEngineeringAbstractItem.CONNECTED_AT_BODY)]

                        symbol_matches = [x for x in self._symbols if

                                          x.owner and line.is_connected(x) and x.canBeSecondary(line)]

                    else:

                        line_matches = [x for x in self._lines if x.owner and type(

                            x.owner) is QEngineeringTrimLineNoTextItem and line.is_connected(x,

                                                                                             QEngineeringAbstractItem.CONNECTED_AT_BODY)]

                        symbol_matches = [x for x in self._symbols if x.owner and type(

                            x.owner) is QEngineeringTrimLineNoTextItem and line.is_connected(x) and x.canBeSecondary(

                            line)]

                    if line_matches or symbol_matches:

                        foundCount += 1

                        connected_items = self.find_connected_objects(line, include_signal=include_signal)

                        owner = line_matches[0].owner if line_matches else symbol_matches[0].owner

                        for item in connected_items:

                            item.owner = owner  # set item's owner

                        if connected_items:

                            line_run = QEngineeringRunItem()

                            line_run.items = connected_items

                            line_run.arrange_flow_direction()

                            if line_run.items is not None and len(line_run.items) > 0:

                                line_run.owner = owner

                                owner.runs.append(line_run)

                    else:

                        notMatches.append(line)

                # lines_and_symbols = notMatches

        except Exception as ex:

            from App import App

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                           sys.exc_info()[-1].tb_lineno)

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

        @brief      trace line no

        @author     humkyung

        @date       2018.04.16

        @history    2018.04.26 Jeongwoo docDatalineNos = self.lineNos, Not For loop

                    humkyung 2018.05.08 add flow arrow

                    Jeongwoo 2018.05.14 Add [runs] on Primary/Secondary Line - Need to modify Secondary Line

                    Jeongwoo 2018.05.15 Make Comments [lineno.conns[0].owner = lineno]

                    Jeongwoo 2018.05.17 Modify find secondary lines with 'while'

                                        Modify find secondary lines with 'while' used sublist for unconnected line

                    humkyung 2018.05.18 set start line's owner before tracing

    '''

    def execute(self, displayMessage, updateProgress, toler=600):

        from EngineeringLineItem import QEngineeringLineItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringRunItem import QEngineeringRunItem

        from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

        from EngineeringEquipmentItem import QEngineeringEquipmentItem

        try:

            app_doc_data = AppDocData.instance()

            configs = app_doc_data.getConfigs('Line No', 'Delimiter')

            if 1 == len(configs):

                #configs = app_doc_data.getConfigs('Line No', 'Configuration')

                for line_no in self._lineNos:

                    _from = line_no.prop('From')

                    _to = line_no.prop('To')

                    line_no.conns.clear()

                    minDist = None

                    startLine = None

                    for line in [line for line in self._lines if line.owner is None and line.is_piping(strong=True)]:

                        dist = line.distanceTo((line_no.center().x(), line_no.center().y()))

                        if (minDist is None) or (dist < minDist):

                            minDist = dist

                            startLine = line

                    if (startLine is not None) and (minDist < toler):

                        line_no.conns.append(startLine)

                        if not _from or not _to:

                            startLine.owner = line_no

                    if _from and _to and \

                            (type(_from) is QEngineeringLineItem or issubclass(type(_from), SymbolSvgItem)) and \

                            (type(_to) is QEngineeringLineItem or issubclass(type(_to), SymbolSvgItem)):

                        _from.owner = line_no

                        _to.owner = line_no

                        line_no._fixed = True

                    else:

                        line_no.set_property('From', None)

                        line_no.set_property('To', None)

                        line_no._fixed = False

                self.maxValue = len(self._lineNos) + 1  # line no's count + secondary line

                # find primary lines

                # sort line no with from,to value

                self._lineNos.sort(

                    key=lambda line_no: (1 if line_no.prop('From') else 0) + (1 if line_no.prop('To') else 0),

                    reverse=True)

                for lineno in self._lineNos:

                    if displayMessage: displayMessage.emit('{} {}'.format(lineno.text(), 'Topology Construction'))

                    self.find_primary_lines(lineno, include_signal=False)

                    if updateProgress: updateProgress.emit(self.maxValue)

                # find secondary lines

                lines_and_symbols = self._lines + self._symbols

                self.find_secondary_lines(lines_and_symbols, include_signal=False)

                # double check conn line cuz startLine may need at first step

                for lineno in self._lineNos:

                    lineno.conns.clear()

                    minDist = None

                    startLine = None

                    if len(lineno.runs) is 0:

                        continue

                    for line in [line for line in lineno.runs[0].items if

                                 type(line) is QEngineeringLineItem and line.is_piping(strong=True)]:

                        dist = line.distanceTo((lineno.center().x(), lineno.center().y()))

                        if (minDist is None) or (dist < minDist):

                            minDist = dist

                            startLine = line

                    if (startLine is not None):  # and (minDist < toler):

                        lineno.conns.append(startLine)

                if updateProgress: updateProgress.emit(self.maxValue)

            # make trim lines

            updateProgress.emit(-1)  # reset progressbar

            displayMessage.emit('Unknown line Topology Construction')

            orphanLines = [line for line in self._lines if line.owner is None]

            orphanSymbols = [symbol for symbol in self._symbols if

                             symbol.owner is None and type(symbol) is not QEngineeringEquipmentItem]

            if orphanLines + orphanSymbols:

                self.maxValue = len(orphanLines) + 1

                orphanLines = sorted(orphanLines, key=lambda param: param.length(), reverse=True)

                orphans = orphanLines + orphanSymbols

                while len(orphans) > 0:

                    trimLineNo = QEngineeringTrimLineNoTextItem()

                    trimLineNo.conns.append(orphans[0])

                    orphans[0].owner = trimLineNo

                    # orphanLines[0].linkedItem = trimLineNo

                    connectedItems = self.find_primary_lines(trimLineNo)

                    for item in connectedItems:

                        if item in orphans:

                            orphans.remove(item)

                            updateProgress.emit(self.maxValue)

                    self.find_secondary_lines(orphans, is_trim=True)

                    for item_index in reversed(range(len(orphans))):

                        item = orphans[item_index]

                        if item.owner is not None:

                            orphans.remove(item)

                            updateProgress.emit(self.maxValue)

                    app_doc_data.tracerLineNos.append(trimLineNo)

            if updateProgress: updateProgress.emit(self.maxValue)

        except Exception as ex:

            from App import App

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                           sys.exc_info()[-1].tb_lineno)

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

        @brief      find objects connected to given line while loop

        @author     humkyung

        @date       2018.04.16

        @history    humkyung 2018.05.08 find symbol or line connected to given object

                    humkyung 2018.05.10 set found object's owner

                    humkyung 2018.05.17 try to connect both symbol and line

                    humkyung 2018.06.22 order connected objects

    '''

    def find_connected_objects(self, start, to=None, primary=False, include_signal=True):

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringEquipmentItem import QEngineeringEquipmentItem

        from EngineeringInstrumentItem import QEngineeringInstrumentItem

        from SymbolSvgItem import SymbolSvgItem

        visited = [start]

        break_at_first = None

        try:

            pool = []

            pool.append((0, start))

            while len(pool) > 0:

                sign, obj = pool.pop()

                # """ check obj is upstream or downstream of spec break """

                # matches = [spec_break for spec_break in self._spec_breaks if spec_break.is_connected(obj)]

                # if matches or issubclass(type(obj), QEngineeringEquipmentItem):

                #    visited.pop(visited.index(obj))

                #    continue

                # print('obj={} pool={}'.format(obj, pool))

                match = False

                if not primary:

                    for end_break in self._end_breaks:

                        if obj is end_break.owner or obj is end_break.prop('Connected Item'):

                            if end_break.owner.is_connected(end_break.prop('Connected Item')) and \

                                    end_break.prop('Connected Item').is_connected(end_break.owner) and \

                                    len(visited) is not 1:

                                match = True

                                if obj.is_connected(break_at_first):

                                    visited.pop(visited.index(obj))

                                break

                            elif end_break.owner.is_connected(end_break.prop('Connected Item')) and \

                                    end_break.prop('Connected Item').is_connected(end_break.owner):

                                break_at_first = obj

                                break

                if issubclass(type(obj), QEngineeringEquipmentItem):

                    visited.pop(visited.index(obj))

                    continue

                elif match:

                    continue

                """ end loop if obj is to """

                if to is not None and str(obj.uid) == str(to.uid): break

                # nextmatches list always has one item

                if type(obj) is QEngineeringLineItem:

                    symbolMatches = [x for x in self._symbols if (x.owner is None or x.owner == start.owner) and (

                            x not in visited) and obj.is_connected(x)]

                    if include_signal:

                        lineMatches = [x for x in self._lines if

                                       (x.owner is None or x.owner == start.owner) and (x is not obj) and (

                                               x not in visited) and obj.is_connected(x)]

                    else:

                        lineMatches = [x for x in self._lines if

                                       x.is_piping() and (x.owner is None or x.owner == start.owner) and (

                                               x is not obj) and (x not in visited) and obj.is_connected(x)]

                    nextMatches = symbolMatches + lineMatches

                elif issubclass(type(obj), SymbolSvgItem):

                    # symbol can be connected with line and another symbol at the same time

                    if include_signal:

                        lineMatches = [x for x in self._lines if (x.owner is None or x.owner == start.owner) and (

                                x not in visited) and obj.is_connected(x)]

                    else:

                        lineMatches = [x for x in self._lines if

                                       x.is_piping() and (x.owner is None or x.owner == start.owner) and (

                                               x not in visited) and obj.is_connected(x)]

                    symbolMatches = [x for x in self._symbols if

                                     (x.owner is None or x.owner == start.owner) and (x is not obj) and (

                                             x not in visited) and obj.is_connected(x, None)]

                    nextMatches = symbolMatches + lineMatches

                    if len(nextMatches) > 1:  # choose one if connected items are more than 2

                        matches = [x for x in visited if obj.is_connected(x)]

                        if matches:

                            next_connected = [x for x in nextMatches if obj.next_connected(x, matches[0])]

                            if next_connected:

                                nextMatches = next_connected

                            else:

                                nextMatches = []

                    # if obj symbol has break connector and nextMatch connected that connector than break line group

                    if nextMatches and obj.break_connector and [index for index in obj.break_connector if

                                                                obj.connectors[index].connectedItem is nextMatches[0]]:

                        match = True

                        break

                # if obj item connected symbol that has break connector then break line group

                if nextMatches:

                    pop_index = []

                    index = 0

                    for nextMatch in nextMatches:

                        if hasattr(nextMatch, 'break_connector'):

                            if [index for index in nextMatch.break_connector if

                                nextMatch.connectors[index].connectedItem is obj]:

                                pop_index.append(index)

                        index += 1

                    for index in reversed(pop_index):

                        nextMatches.pop(index)

                        # order connected objects

                matches = []

                matches.extend(nextMatches)

                if sign == 0 and len(matches) > 1:

                    mid = int(len(matches) * 0.5)

                    lhs = matches[0:mid]

                    rhs = matches[mid:]

                elif sign == -1:

                    lhs = matches

                    rhs = []

                else:

                    lhs = []

                    rhs = matches

                for match in lhs:

                    # print(match)

                    pool.append((-1, match))

                    visited.insert(0, match)

                for match in rhs:

                    # print(match)

                    pool.append((1, match))

                    visited.append(match)

                # up to here

        except Exception as ex:

            from App import App

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                           sys.exc_info()[-1].tb_lineno)

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        # print(visited)

        return visited

'''

    @brief      connect attributes

    @author     humkyung

    @date       2018.06.17

    @history    humkyung 2018.06.21 paste connect attributes codes from recognizeLine function

                kyouho  2018.09.14  clear Item's owner 

'''

async def connectAttrImpl(worker, update_line_type, update_flow_mark, update_spec):

    from App import App

    import uuid

    from LineNoTracer import LineNoTracer

    from AppDocData import AppDocData

    from EngineeringAbstractItem import QEngineeringAbstractItem

    from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

    from EngineeringInstrumentItem import QEngineeringInstrumentItem

    from EngineeringReducerItem import QEngineeringReducerItem

    from EngineeringEquipmentItem import QEngineeringEquipmentItem

    from QEngineeringOPCItem import QEngineeringOPCItem

    from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

    from EngineeringVendorItem import QEngineeringVendorItem

    from EngineeringEndBreakItem import QEngineeringEndBreakItem

    from EngineeringFlowMarkItem import QEngineeringFlowMarkItem

    from EngineeringReservedWordTextItem import QEngineeringReservedWordTextItem

    from QEngineeringSizeTextItem import QEngineeringSizeTextItem

    from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

    from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

    from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

    from EngineeringErrorItem import QEngineeringErrorItem

    from EngineeringTextItem import QEngineeringTextItem

    from SpecialItemTypesDialog import SpecialItemTracer

    try:

        docdata = AppDocData.instance()

        worker.display_message.emit('Initializing...')

        ALL_ITEM = [item for item in worker.scene.items() if issubclass(type(item), QEngineeringAbstractItem)]

        for item in ALL_ITEM:

            item.setVisible(False)

        QApplication.processEvents()

        symbols = []

        lines = [item for item in worker.scene.items() if type(item) is QEngineeringLineItem]

        lineNos = []

        spec_breaks = []

        lineIndicator = []

        vendor_packages = [item for item in worker.scene.items() if

                           type(item) is QEngineeringVendorItem and item.pack_type == 'Vendor Package']

        equip_packages = [item for item in worker.scene.items() if

                          type(item) is QEngineeringVendorItem and item.pack_type == 'Equipment Package']

        end_breaks = []

        notes = []

        flow_marks = []

        for error_item in [item for item in worker.scene.items() if type(item) is QEngineeringErrorItem]:

            error_item.transfer.onRemoved.emit(error_item)

        for end_break in [item for item in worker.scene.items() if type(item) is QEngineeringEndBreakItem]:

            if not end_break.prop('Freeze'):

                end_break.transfer.onRemoved.emit(end_break)

            else:

                end_breaks.append(end_break)

        QApplication.processEvents()

        '''

        for flow_mark in [item for item in worker.scene.items() if type(item) is QEngineeringFlowMarkItem]:

            if not flow_mark.prop('Freeze'):

                flow_mark.transfer.onRemoved.emit(flow_mark)

            else:

                flow_marks.append(flow_mark)

        '''

        configs = docdata.getConfigs('Supplied by Tag Rule', 'by Vendor')

        vendorTag = configs[0].value if configs else 'By Vendor'

        for item in worker.scene.items():

            if type(item) is QEngineeringSpecBreakItem:

                spec_breaks.append(item)

            elif issubclass(type(item), SymbolSvgItem) and not (type(item) is QEngineeringErrorItem) and not (

                    type(item) is QEngineeringUnknownItem) and item.type != 'Notes' and not (

                    type(item) is QEngineeringEndBreakItem):

                matches = [vendor_package for vendor_package in vendor_packages if vendor_package.includes(item)]

                if matches:

                    item.set_property('Supplied By', vendorTag)

                else:

                    item.set_property('Supplied By', '')

                symbols.append(item)

            elif type(item) is QEngineeringLineNoTextItem:

                lineNos.append(item)

            elif type(item) is QEngineeringLineItem:

                # matches = [vendor_package for vendor_package in vendor_packages if vendor_package.includes(item)]

                # if not matches: lines.append(item)

                # for check line disappear bug

                pass

                # lines.append(item)

            elif type(item) is QEngineeringUnknownItem and item.lineIndicator != 'False':

                lineIndicator.append(item)

            elif issubclass(type(item), QEngineeringTextItem):

                item.owner = None

            elif item.type == 'Notes':

                notes.append(item)

        QApplication.processEvents()

        # remove unknown line's

        pastTrim = docdata.tracerLineNos

        treeWidget = App.mainWnd().itemTreeWidget

        for pastTrimIndex in reversed(range(len(pastTrim))):

            if type(pastTrim[pastTrimIndex]) is QEngineeringTrimLineNoTextItem:

                try:

                    connected_items = pastTrim[pastTrimIndex].getConnectedItems()

                    for item in connected_items:

                        treeWidget.addTreeItem(treeWidget.SymbolsTreeItem, item)

                    pastTrim[pastTrimIndex].explode()

                finally:

                    pass

        # trace line no

        tracer = LineNoTracer(symbols, lines, lineNos, spec_breaks, lineIndicator, vendor_packages, end_breaks)

        tracer.execute(worker.display_message, worker.updateProgress)

        # up to here

        # connect attribute

        worker.display_message.emit('Connecting Attribute...')

        QApplication.processEvents()

        texts = [item for item in worker.scene.items() if issubclass(type(item), QEngineeringTextItem)]

        for symbol in symbols:

            try:

                symbol.connectAttribute(texts)

            except Exception as ex:

                message = 'error occurred({}) in {}:{}'.format(repr(ex), sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                               sys.exc_info()[-1].tb_lineno)

                worker.display_message.emit(message)

        """ try to connect label to valve """

        labels = [symbol for symbol in symbols if symbol.iType == 19]  # Labels - Symbol => Instrument

        valves = [symbol for symbol in symbols if

                  symbol.iType == 34 or symbol.iType == 17 or symbol.iType == 22]  # Specialty Components, In-Line, Relief Devices

        for label in labels:

            label.connectAttribute(valves, clear=False)

        # for slope, etc.., symbol to line

        labels = [symbol for symbol in symbols if symbol.iType == 30]  # Labels - Line => Piping

        for label in labels:

            label.connectAttribute(lines, clear=False)

        '''

        # for alarm, symbol to symbol : no more used

        labels = [symbol for symbol in symbols if symbol.iType == 29]  # Labels - Piping Components => Instrument

        valves = [symbol for symbol in symbols if symbol.iType == 25]  # System Functions

        for label in labels:

            label.connectAttribute(valves, clear=False)

        '''

        QApplication.processEvents()

        for symbol in symbols:

            for assoc in symbol.associations():

                if assoc.owner is None:

                    assoc.owner = symbol

        """ restore note text item owner """

        for note in notes:

            for noteText in note.associations():

                noteText.owner = note

        """ try to find text item's owner """

        texts = [item for item in worker.scene.items() if type(item) is QEngineeringReservedWordTextItem]

        for text in texts:

            text.findOwner(lines)

        QApplication.processEvents()

        # restore and save manual edited attr's text item

        texts = [item for item in worker.scene.items() if issubclass(type(item), QEngineeringTextItem)]

        targetText = []

        for text in texts:

            found = False

            for symbol in symbols + lines:

                for attr in list(symbol.attrs.keys()):

                    # skip freezed attr or already consumed by symbol

                    if attr.AssocItem == text:

                        text.owner = symbol

                        found = True

                        break

                    # restore missing attr

                    elif type(attr.AssocItem) is str or type(attr.AssocItem) is uuid.UUID:

                        if str(attr.AssocItem) == str(text.uid):

                            symbol.add_assoc_item(text)

                            attr.AssocItem = text

                            text.owner = symbol

                            found = True

                        break

                if found: break

            if not found and (

                    type(text) is QEngineeringSizeTextItem or type(text) is QEngineeringValveOperCodeTextItem or \

                    type(text) is QEngineeringTagNoTextItem or type(text) is QEngineeringTextItem):

                targetText.append(text)

        worker.need_update_texts = []

        targetText = sorted(targetText, key=lambda param: len(param.text()), reverse=True)

        for symbol in symbols + equip_packages:

            symbol._skip = False

        for text in targetText:

            ret = text.findOwner(symbols) if type(text) is not QEngineeringTagNoTextItem else text.findOwner(

                symbols + equip_packages)

            if ret:

                worker.need_update_texts.append([text, ret])

        """ update line type """

        if update_line_type:

            worker.display_message.emit('Updating Line Type...')

            for line in lines:

                line.update_line_type()

        QApplication.processEvents()

        """ make end break """

        make_end_break(worker, end_breaks, lineNos)

        QApplication.processEvents()

        """ update spec break """

        if update_spec:

            make_spec(worker, spec_breaks, lines, lineNos)

        worker.updateProgress.emit(tracer.maxValue)

        # trace special item

        worker.display_message.emit('Finding line for special item...')

        QApplication.processEvents()

        tracer = SpecialItemTracer([item for item in worker.scene.items() if

                                    (type(item) is SymbolSvgItem or type(item) is QEngineeringTextItem) and

                                    item.special_item_type], lines)

        tracer.execute(worker.display_message, worker.updateProgress)

        # up to here

        ''' sort run flow order '''

        worker.display_message.emit('Sorting Lines...')

        QApplication.processEvents()

        sort_run_flow(worker)

        QApplication.processEvents()

        """ make flow mark """

        if update_flow_mark:

            make_flow_mark(worker, lines)

        ''' get line no's from/to equipment '''

        for lineNo in lineNos:

            lineNo.clear_attr_and_assoc_item()

            lineNo.EvaluatedEQ()

        ALL_ITEM = [item for item in worker.scene.items() if issubclass(type(item), QEngineeringAbstractItem)]

        for item in ALL_ITEM:

            item.setVisible(True)

    except Exception as ex:

        message = 'error occurred({}) in {}:{}'.format(repr(ex), sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                       sys.exc_info()[-1].tb_lineno)

        worker.display_message.emit(message)

    except:

        (type1, value, traceback) = sys.exc_info()

        sys.excepthook(type1, value, traceback)

def make_end_break(worker, end_breaks, lineNos):

    ''' make end break '''

    from App import App

    import os

    try:

        docdata = AppDocData.instance()

        end_break_names = docdata.getSymbolListByType('type', 'End Break')

        if len(end_break_names) is not 0:

            svgFileName = end_break_names[0].sName

            symbol = end_break_names[0]

            svgFilePath = os.path.join(docdata.getCurrentProject().getSvgFilePath(), symbol.getType(),

                                       svgFileName + '.svg')

            lineNo_froms = []

            lineNo_tos = []

            for lineNo in lineNos:

                # lineNo_froms.append(lineNo.prop('From')) if lineNo.prop('From') is not None else None

                # lineNo_tos.append(lineNo.prop('To')) if lineNo.prop('To') is not None else None

                for run in lineNo.runs:

                    start = [run.items[0]]

                    end = [run.items[-1]] if run.items[0] is not run.items[-1] else []

                    lineNo_froms.extend(start)

                    lineNo_tos.extend(end)

            for line_end in lineNo_froms + lineNo_tos:

                # print(type(line_end))

                for connector in line_end.connectors:

                    if connector.connectedItem is not None and type(

                            connector.connectedItem.owner) is QEngineeringLineNoTextItem and connector.connectedItem.owner is not line_end.owner:

                        end_break = SymbolSvgItem.createItem(symbol.getType(), None, svgFilePath)

                        pt = [connector.center()[0] - float(symbol.getOriginalPoint().split(',')[0]),

                              connector.center()[1] - float(symbol.getOriginalPoint().split(',')[1])]

                        origin = [0, 0]

                        if 2 == len(symbol.getOriginalPoint().split(',')):

                            tokens = symbol.getOriginalPoint().split(',')

                            origin = [pt[0] + float(tokens[0]), pt[1] + float(tokens[1])]

                        end_break.buildItem(svgFileName, symbol.getType(), 3.83, pt,

                                            [end_break.boundingRect().width(), end_break.boundingRect().height()],

                                            origin, [], symbol.getBaseSymbol(), symbol.getAdditionalSymbol(),

                                            symbol.getHasInstrumentLabel())

                        end_break.set_property('Connected Item', connector.connectedItem)

                        end_break.setToolTip('owner : ' + str(line_end))

                        end_break.area = 'Drawing'

                        end_break.owner = line_end

                        end_breaks.append(end_break)

            if end_breaks:

                # check duplication

                dupl = set()

                for i in range(len(end_breaks)):

                    for j in range(len(end_breaks)):

                        if i == j:

                            continue

                        else:

                            setI = set([end_breaks[i].owner, end_breaks[i].prop('Connected Item')])

                            setJ = set([end_breaks[j].owner, end_breaks[j].prop('Connected Item')])

                            if not (setI - setJ):

                                index = [i, j]

                                index.sort()

                                index = tuple(index)

                                dupl.add(index)

                # print(dupl)

                dupl = list(set(

                    [(indexSet[1] if not end_breaks[indexSet[1]].prop('Freeze') else indexSet[0]) for indexSet in

                     list(dupl)]))

                dupl.sort(reverse=True)

                # print(dupl)

                for index in dupl:

                    end_breaks.pop(index)

                for end_break in end_breaks:

                    if not end_break.prop('Freeze'):

                        end_break.transfer.onRemoved.connect(App.mainWnd().itemRemoved)

                        # end break can be modeled only piping line

                        if (type(end_break.owner) is not QEngineeringLineItem or (

                                type(end_break.owner) is QEngineeringLineItem and (

                                end_break.owner.lineType == 'Secondary' or end_break.owner.lineType == 'Primary'))) \

                                and (type(end_break.prop('Connected Item')) is not QEngineeringLineItem or (

                                type(end_break.prop('Connected Item')) is QEngineeringLineItem and (

                                end_break.prop('Connected Item').lineType == 'Secondary' or end_break.prop(

                            'Connected Item').lineType == 'Primary'))):

                            end_break.addSvgItemToScene(worker.scene)

    except Exception as ex:

        message = 'error occurred({}) in {}:{}'.format(repr(ex), sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                       sys.exc_info()[-1].tb_lineno)

        worker.display_message.emit(message)

def make_spec(worker, spec_breaks, lines, lineNos):

    ''' update spec break '''

    from App import App

    import os, math

    try:

        docdata = AppDocData.instance()

        freezed_spec_breaks = []

        for spec_break in spec_breaks:

            if not spec_break.prop('Freeze'):

                spec_break.transfer.onRemoved.emit(spec_break)

            else:

                freezed_spec_breaks.append(spec_break)

        for line in lines:

            line.clear_labels()

        spec_break_names = docdata.getSymbolListByType('type', 'Segment Breaks')

        if len(spec_break_names) is not 0:

            configs = docdata.getConfigs('Range', 'Detection Ratio')

            ratio = float(configs[0].value) if 1 == len(configs) else 1.5

            ratio *= 2

            svgFileName = spec_break_names[0].sName

            symbol = spec_break_names[0]

            svgFilePath = os.path.join(docdata.getCurrentProject().getSvgFilePath(), symbol.getType(),

                                       svgFileName + '.svg')

            specBreakAttrsFull = [attr for attr in docdata.getSymbolAttribute('Segment Breaks') if

                                  attr.Target == 'ALL' and (

                                          attr.AttributeType == 'Spec' or attr.AttributeType == 'String')]

            specBreakAttrs = [attr.Attribute for attr in specBreakAttrsFull]

            line_ends = []

            # append upstream first and append downstream

            for lineNo in lineNos:

                for run in lineNo.runs:

                    line_ends.append(run.items[0]) if issubclass(type(run.items[0]), SymbolSvgItem) or (

                            type(run.items[0]) is QEngineeringLineItem and (

                            run.items[0].lineType == 'Secondary' or run.items[

                        0].lineType == 'Primary')) else None

            for lineNo in lineNos:

                for run in lineNo.runs:

                    if run.items[0] is not run.items[-1]:

                        line_ends.append(run.items[-1]) if issubclass(type(run.items[-1]), SymbolSvgItem) or (

                                type(run.items[-1]) is QEngineeringLineItem and (

                                run.items[-1].lineType == 'Secondary' or run.items[

                            -1].lineType == 'Primary')) else None

            spec_breaks = []

            for line_end in line_ends:

                for connector in line_end.connectors:

                    if connector.connectedItem is not None and type(

                            connector.connectedItem.owner) is QEngineeringLineNoTextItem and connector.connectedItem.owner is not line_end.owner:

                        spec_break = []  # upstream, downstream, [spec, up value, down value], ... , [ ... ]

                        match = False

                        for prop, value in [[prop, value] for prop, value in line_end.owner.getAttributes().items()

                                            if prop.Attribute in specBreakAttrs]:

                            for prop2, value2 in [[prop2, value2] for prop2, value2 in

                                                  connector.connectedItem.owner.getAttributes().items() if

                                                  prop2.Attribute in specBreakAttrs and prop2.UID == prop.UID]:

                                if str(prop.UID) == str(prop2.UID) and value != value2:

                                    if not match:

                                        spec_break.extend([line_end, connector.connectedItem])

                                        match = True

                                    spec_break.append([prop.Attribute, value, value2])

                        if match:

                            spec_breaks.append(spec_break)

            if spec_breaks:

                # check duplication

                dupl = set()

                for i in range(len(spec_breaks)):

                    for j in range(len(spec_breaks)):

                        if i == j:

                            continue

                        else:

                            setI = set([spec_breaks[i][0], spec_breaks[i][1]])

                            setJ = set([spec_breaks[j][0], spec_breaks[j][1]])

                            if not (setI - setJ):

                                index = [i, j]

                                index.sort()

                                index = tuple(index)

                                dupl.add(index)

                dupl = list(set([(indexSet[1]) for indexSet in list(dupl)]))

                dupl.sort(reverse=True)

                for index in dupl:

                    spec_breaks.pop(index)

                # up to here

                spec_break_items = []

                for spec in spec_breaks:

                    dupl = False

                    for freezed in freezed_spec_breaks:

                        freezed_attrs = freezed.getAttributes()

                        up = [attr.AssocItem for attr in freezed_attrs if attr.Attribute == 'UpStream']

                        down = [attr.AssocItem for attr in freezed_attrs if attr.Attribute == 'DownStream']

                        if up and down:

                            if (up[0] is spec[0] and down[0] is spec[1]) or (

                                    up[0] is spec[1] and down[0] is spec[0]):

                                dupl = True

                                break

                    if dupl:

                        continue

                    for connector in spec[0].connectors:

                        if connector.connectedItem is spec[1]:

                            spec_break = SymbolSvgItem.createItem(symbol.getType(), None, svgFilePath)

                            pt = [40 + connector.center()[0] - float(symbol.getOriginalPoint().split(',')[0]),

                                  60 + connector.center()[1] - float(symbol.getOriginalPoint().split(',')[1])]

                            origin = [0, 0]

                            if 2 == len(symbol.getOriginalPoint().split(',')):

                                tokens = symbol.getOriginalPoint().split(',')

                                origin = [pt[0] + float(tokens[0]), pt[1] + float(tokens[1])]

                            spec_break.buildItem(svgFileName, symbol.getType(), 3.14, pt,

                                                 [spec_break.boundingRect().width(),

                                                  spec_break.boundingRect().height()], origin, [],

                                                 symbol.getBaseSymbol(), symbol.getAdditionalSymbol(),

                                                 symbol.getHasInstrumentLabel())

                            attrs = spec_break.getAttributes()

                            for key in attrs.keys():

                                if key.Attribute == 'UpStream':

                                    attrs[key] = str(spec[0])

                                    spec_break.add_assoc_item(spec[0], key.AttrAt, force=True)

                                    key.AssocItem = spec[0]

                                elif key.Attribute == 'DownStream':

                                    attrs[key] = str(spec[1])

                                    spec_break.add_assoc_item(spec[1], key.AttrAt, force=True)

                                    key.AssocItem = spec[1]

                            for attr, value, value2 in spec[2:]:

                                for full in specBreakAttrsFull:

                                    if full.Attribute == attr:

                                        attrs[full] = [value, value2]

                            # find label text for spec break line

                            stream_line = [spec[0], spec[1]]

                            stream_track = [spec[1], spec[0]]

                            stream_res = [False, False]

                            for index in range(len(stream_line)):

                                while True:

                                    if type(stream_line[index]) is QEngineeringLineItem:

                                        stream_res[index] = True

                                        break

                                    else:

                                        find_next = False

                                        connected_count = 0

                                        for connectorr in stream_line[index].connectors:

                                            connected_count += 1

                                            if connectorr.connectedItem and stream_track[

                                                index] is not connectorr.connectedItem and stream_line[

                                                index].next_connected(stream_track[index],

                                                                      connectorr.connectedItem):

                                                stream_track[index] = stream_line[index]

                                                stream_line[index] = connectorr.connectedItem

                                                find_next = True

                                                break

                                        if not find_next:

                                            # prevent infinite loop

                                            if connected_count == 2:

                                                for connectorr in stream_line[index].connectors:

                                                    if connectorr.connectedItem and not connectorr.connectedItem is \

                                                                                        stream_track[index]:

                                                        stream_line[index] = connectorr.connectedItem

                                                        stream_track[index] = stream_line[index]

                                                        find_next = True

                                                        break

                                                if not find_next:

                                                    break

                                            else:

                                                break

                            if stream_res[0] and stream_res[1]:

                                texts = [item for item in worker.scene.items() if

                                         type(item) is QEngineeringTextItem and item.owner is None]

                                positioning = False

                                for attr, value, value2 in spec[2:]:

                                    up_texts = [text for text in texts if text.text() == value]

                                    down_texts = [text for text in texts if text.text() == value2]

                                    up_down_texts = [up_texts, down_texts]

                                    up_down_find = [None, None]

                                    for index in range(len(up_down_texts)):

                                        minDist = sys.maxsize

                                        for up_down_text in up_down_texts[index]:

                                            dx = connector.center()[0] - up_down_text.center().x()

                                            dy = connector.center()[1] - up_down_text.center().y()

                                            dist = (

                                                           up_down_text.sceneBoundingRect().height() + up_down_text.sceneBoundingRect().width()) * ratio / 2

                                            length = math.sqrt(dx * dx + dy * dy)

                                            if length < dist and length < minDist:

                                                up_down_find[index] = up_down_text

                                    if up_down_find[0] and up_down_find[1]:

                                        for index in range(len(stream_line)):

                                            attrs = stream_line[index].getAttributes()

                                            for key in attrs.keys():

                                                if key.Attribute == attr:

                                                    attrs[key] = up_down_find[index].text()

                                                    key.AssocItem = up_down_find[index]

                                                    stream_line[index].add_assoc_item(up_down_find[index],

                                                                                      key.AttrAt, force=True)

                                                    up_down_find[index].owner = stream_line[index]

                                                    break

                                        if not positioning:

                                            # set spec break position between

                                            positioning = True

                                            new_x = round(

                                                (up_down_find[0].center().x() + up_down_find[1].center().x()) / 2)

                                            new_y = round(

                                                (up_down_find[0].center().y() + up_down_find[1].center().y()) / 2)

                                            spec_break.loc = [new_x - spec_break.symbolOrigin[0],

                                                              new_y - spec_break.symbolOrigin[1]]

                                            spec_break.origin = [new_x, new_y]

                                            pivot = None

                                            for connector in spec[0].connectors:

                                                if connector.connectedItem is spec[1]:

                                                    pivot = connector.sceneBoundingRect().center()

                                                    break

                                            if abs(up_down_find[0].center().x() - up_down_find[

                                                1].center().x()) < abs(

                                                up_down_find[0].center().y() - up_down_find[1].center().y()):

                                                if new_x > pivot.x():

                                                    spec_break.angle = 1.57

                                                else:

                                                    spec_break.angle = 4.71239

                                            else:

                                                if new_y > pivot.y():

                                                    spec_break.angle = 3.14

                                                else:

                                                    spec_break.angle = 0

                                            # make show prop true

                                            spec_break.set_property('Show', True)

                            spec_break_items.append(spec_break)

                for spec_break_item in spec_break_items:

                    spec_break_item.transfer.onRemoved.connect(App.mainWnd().itemRemoved)

                    spec_break_item.addSvgItemToScene(worker.scene)

                spec_break_items.extend(freezed_spec_breaks)

    except Exception as ex:

        message = 'error occurred({}) in {}:{}'.format(repr(ex), sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                       sys.exc_info()[-1].tb_lineno)

        worker.display_message.emit(message)

def make_flow_mark(worker, lines):

    ''' make flow mark '''

    try:

        docdata = AppDocData.instance()

        for line in lines:

            line.flowMark = None

            # line.update_arrow()

        configs = docdata.getConfigs('Flow Mark', 'Position')

        position = int(configs[0].value) if 1 == len(configs) else 100

        configs = docdata.getConfigs('Flow Mark', 'Length')

        length = int(configs[0].value) if 1 == len(configs) else 200

        for line in [line for line in lines if line.is_piping(True)]:

            line.update_flow_mark(position, length)

            line.update_arrow()

        # for lineNo in docdata.tracerLineNos:

        #    lineNo.update_flow_mark(position, length)

    except Exception as ex:

        message = 'error occurred({}) in {}:{}'.format(repr(ex), sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                       sys.exc_info()[-1].tb_lineno)

        worker.display_message.emit(message)

def sort_run_flow(worker):

    ''' sort runs '''

    from EngineeringLineTracerRunItem import QEngineeringLineTracerRunItem

    try:

        docdata = AppDocData.instance()

        fixed_run_infos = []  # QEngineeringLineTracerRunItem s

        waiting_run_infos = []  # QEngineeringLineTracerRunItem s

        runs = []

        # first step : make fixed run using symbol info

        for lineNo in [lineNo for lineNo in docdata.tracerLineNos if len(lineNo.runs) > 0]:

            not_trim = True if type(lineNo) is QEngineeringLineNoTextItem else False

            run_index = 0

            for run in lineNo.runs:

                not_secondary = True if run_index is 0 else False

                # if from and to info already was entered, fix run flow

                if hasattr(lineNo, '_fixed') and lineNo._fixed and not_secondary:

                    fixed_run_infos.append(QEngineeringLineTracerRunItem(run, lineNo, not_trim, not_secondary))

                    run_index += 1

                    continue

                reference_symbols = [item for item in run.items if

                                     issubclass(type(item), SymbolSvgItem) and item.has_in_out_connector()]

                # runs can know flow directly

                if len(run.items) > 1 and len(reference_symbols) > 0:

                    for reference_symbol in reference_symbols:

                        # place at first

                        if reference_symbol is run.items[0]:

                            if len([connector_index for connector_index in reference_symbol.in_out_connector[0] \

                                    if reference_symbol.connectors[connector_index].connectedItem is run.items[1]]) > 0:

                                info = QEngineeringLineTracerRunItem(run, lineNo, not_trim, not_secondary)

                                info.reverse()

                                fixed_run_infos.append(info)

                                break