HYTOS

# coding: utf-8

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

import sys

import math

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

            """

            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 occured({}) 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):

        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)

            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])

        #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):

        from EngineeringAbstractItem import QEngineeringAbstractItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringRunItem import QEngineeringRunItem

        try:

            foundCount = 1

            while foundCount:

                foundCount = 0

                notMatches = []

                for line in lines_and_symbols:

                    if line.owner is not None: continue

                    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)]

                    if line_matches or symbol_matches:

                        foundCount += 1

                        connected_items = self.find_connected_objects(line)

                        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

                        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 occured({}) 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

        try:

            docData = AppDocData.instance()

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

            if 1 == len(configs):

                configs = docData.getConfigs('Line No', 'Configuration')

                for lineno in self._lineNos:

                    _from = lineno.prop('From')

                    _to = lineno.prop('To')

                    lineno.conns.clear()

                    minDist = None

                    startLine = None

                    for line in self._lines:

                        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 _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 = lineno

                        _to.owner = lineno

                        continue

                    else:

                        lineno.set_property('From', None)

                        lineno.set_property('To', None)

                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)

                    if updateProgress: updateProgress.emit(maxValue)

                # find secondary lines

                lines_and_symbols = self._lines + self._symbols

                self.find_secondary_lines(lines_and_symbols)

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

                for lineno in self._lineNos:

                    lineno.conns.clear()

                    minDist = None

                    startLine = None

                    for line in [line for line in lineno.runs[0].items if type(line) is QEngineeringLineItem and (line._lineType == 'Primary' or line._lineType == 'Secondary')]:

                        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(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]

            if orphanLines + orphanSymbols:

                maxValue = len(orphanLines)

                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 orphanLines:

                            orphanLines.remove(item)

                            updateProgress.emit(maxValue)

                    self.find_secondary_lines(orphans)

                    for item in orphans[:]:

                        if item.owner is not None:

                            orphans.remove(item)

                            updateProgress.emit(maxValue)

                    docData.tracerLineNos.append(trimLineNo)

            #(docData.tracerLineNos))

            if updateProgress: updateProgress.emit(maxValue)

        except Exception as ex:

            from App import App 

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

            AppDocData.instance().ex.logger.critical('message')

            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):

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringEquipmentItem import QEngineeringEquipmentItem

        from SymbolSvgItem import SymbolSvgItem

        visited = [start]

        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'):

                            match = True

                            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)]

                    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)]

                    nextMatches = symbolMatches + lineMatches

                elif issubclass(type(obj), SymbolSvgItem):

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

                    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)]

                    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 = [lineMatches[0]]

                # 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 occured({}) 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 

'''

def connectAttrImpl(worker, update_line_type):

    import os, math

    from App import App

    from LineNoTracer import LineNoTracer

    from AppDocData import AppDocData

    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

    try:

        worker.displayMessage.emit('Initiating...')

        docdata = AppDocData.instance()

        symbols = []

        lines = []

        lineNos = []

        specBreak = []

        lineIndicator = []

        vendor_packages = [item for item in worker.graphicsView.scene.items() if type(item) is QEngineeringVendorItem]

        end_breaks = []

        #flow_marks = []

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

            if not end_break.prop('Freeze'):

                end_break.transfer.onRemoved.emit(end_break)

                #worker.graphicsView.scene.removeItem(end_break)

            else:

                end_breaks.append(end_break)

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

            if not flow_mark.prop('Freeze'):

                flow_mark.transfer.onRemoved.emit(flow_mark)

                #worker.graphicsView.scene.removeItem(end_break)

            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.graphicsView.scene.items():

            if type(item) is QEngineeringSpecBreakItem:

                specBreak.append(item)

            elif issubclass(type(item), SymbolSvgItem) and not type(item) is QEngineeringUnknownItem:

                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)

                lines.append(item)

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

                lineIndicator.append(item)

            elif issubclass(type(item), QEngineeringTextItem):

                item.owner = None

        # 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, specBreak, lineIndicator, vendor_packages, end_breaks)

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

        # up to here

        # connect attribute

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

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

        for text in texts:

            text.onwer = None

        for symbol in symbols:

            try:

                symbol.connectAttribute(texts)

            except Exception as ex:

                from App import App 

                message = 'error occured({}) 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)

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

        labels = [symbol for symbol in symbols if type(symbol) is QEngineeringInstrumentItem and not symbol.has_connection]

        #print(labels[0])

        valves = [symbol for symbol in symbols if (type(symbol) is QEngineeringInstrumentItem and symbol.has_connection) and type(symbol) is not QEngineeringReducerItem and type(symbol) is not QEngineeringEquipmentItem \

            and type(symbol) is not QEngineeringOPCItem and type(symbol) is not QEngineeringSpecBreakItem]

        #print(valves[0])

        for valve in valves:

            valve.connectAttribute(labels, clear=False)

        for symbol in symbols:

            for assoc in symbol.associations():

                if assoc.owner is None:

                    assoc.owner = symbol

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

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

        for text in texts:

            text.findOwner(lines)

        texts = [item for item in worker.graphicsView.scene.items() if type(item) is QEngineeringSizeTextItem or type(item) is QEngineeringValveOperCodeTextItem or type(item) is QEngineeringTagNoTextItem]            

        for text in texts:

            text.findOwner(symbols)

        """ update line type """

        if update_line_type == True:

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

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

            #for line in lines: line.lineType = 'Primary'

            for line in lines: line.update_line_type()

        """make end break"""

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

        if len(end_break_names) is not 0:

            svgFileName = end_break_names[0].sName

            symbol = docdata.getSymbolByQuery('name', svgFileName)

            svgFilePath = os.path.join(docdata.getCurrentProject().getSvgFilePath(), symbol.getType(), svgFileName+'.svg')

            #end_breaks = []

            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

                #end_breaks.extend(lineNo.end_break())

            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 connector.connectedItem.owner is not line_end.owner:

                        end_break = SymbolSvgItem.createItem(symbol.getType(), 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(), 5.7, 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 dulplication

                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.addSvgItemToScene(worker.graphicsView.scene)

        """make flow mark"""

        for line in lines:

            line.flowMark = None

            line.update_arrow()

        configs = docdata.getConfigs('Flow Mark')

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

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

        for lineNo in lineNos + docdata.tracerLineNos:

            lineNo.update_flow_mark(position, length)

        '''

        line_names = docdata.getSymbolListByType('type', 'Flow Mark')

        if len(line_names) is not 0:

            svgFileName = line_names[0].sName

            symbol = docdata.getSymbolByQuery('name', svgFileName)

            svgFilePath = os.path.join(docdata.getCurrentProject().getSvgFilePath(), symbol.getType(), svgFileName+'.svg')

            allowed_error = 0.000001

            for lineNo in lineNos + docdata.tracerLineNos:

                for run in lineNo.runs:

                    pre = None

                    preRadian = None

                    for item in run.items:

                        if pre is None and type(item) is QEngineeringLineItem and (item._lineType == 'Primary' or item._lineType == 'Secondary'):

                            pre = item

                            start = item.line().p1()

                            end = item.line().p2()

                            _dir = [(end.x() - start.x())/item.length(), (end.y() - start.y())/item.length()]

                            radian = math.atan2(_dir[0], _dir[1]) - math.pi / 2

                            preRadian = radian if radian >= 0 else radian + 2 * math.pi

                            preDir = _dir

                            #print(_dir)

                            continue

                        elif type(item) is QEngineeringLineItem and (item._lineType == 'Primary' or item._lineType == 'Secondary'):

                            pre._flowMark = []

                            start = item.line().p1()

                            end = item.line().p2()

                            _dir = [(end.x() - start.x())/item.length(), (end.y() - start.y())/item.length()]

                            radian = math.atan2(_dir[0], _dir[1]) - math.pi / 2

                            currRadian = radian if radian >= 0 else radian + 2 * math.pi

                            if abs(currRadian - preRadian) > allowed_error:

                                # insert flow mark at pre line

                                #print(currRadian)

                                flow_mark = SymbolSvgItem.createItem(symbol.getType(), svgFilePath)

                                pt = [pre.connectors[1].center()[0] - float(symbol.getOriginalPoint().split(',')[0]) - preDir[0] * 20, pre.connectors[1].center()[1] - float(symbol.getOriginalPoint().split(',')[1]) - preDir[1] * 20]

                                origin = [0,0]

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

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

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

                                flow_mark.buildItem(svgFileName, symbol.getType(), preRadian, pt, [flow_mark.boundingRect().width(), flow_mark.boundingRect().height()], origin, [], symbol.getBaseSymbol(), symbol.getAdditionalSymbol(), symbol.getHasInstrumentLabel())

                                flow_mark.setToolTip('owner : ' + str(pre))

                                flow_mark.area = 'Drawing'

                                flow_mark.owner = pre

                                flow_mark.setParentItem(pre)

                                pre._flowMark.append(flow_mark)

                                flow_marks.append(flow_mark)

                                pre = item

                                preDir = _dir

                                preRadian = currRadian

            for flow_mark in flow_marks:

                if not flow_mark.prop('Freeze'):

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

                    flow_mark.addSvgItemToScene(worker.graphicsView.scene)

            '''

    except Exception as ex:

        from App import App 

        message = 'error occured({}) 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)

    except:

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

        sys.excepthook(type1, value, traceback)

    finally:

        worker.finished.emit()