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, specBreak, lineIndicator):

        try:

            self._symbols = symbols

            #for symbol in self._symbols: symbol.owner = None

            self._lines = lines

            #for line in self._lines: line.owner = None

            self._lineNos = lineNos

            self._specBreak = specBreak

            self._specBreakUID = []

            self._lineIndicator = lineIndicator

            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:

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

    '''

        @brief  find primary lines connected to given line no

        @author humkyung

    '''

    def findPrimaryLines(self, lineno):

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringRunItem import QEngineeringRunItem

        connectedItems = []

        if 1 == len(lineno.conns):

            connectedItems = self.findConnectedObjects(lineno.conns[0], toler=10)

            for item in connectedItems: 

                item.owner = lineno # set item's owner

                item.linkedItem = lineno

            pipeRun = QEngineeringRunItem()

            pipeRun.items = connectedItems

            lineno.runs.append(pipeRun)

        return connectedItems

    '''

        @brief  find secondary lines

        @author humkyung

    '''

    def findSecondaryLines(self, lines):

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringRunItem import QEngineeringRunItem

        try:

            foundCount = 1

            while foundCount:

                foundCount = 0

                notMatches = []

                for line in lines:

                    if line.linkedItem is not None: continue

                    matches = [x for x in self._lines if x.linkedItem is not None and x.isConnectable(line)]

                    if matches:

                        foundCount += 1

                        connectedItems = self.findConnectedObjects(line, toler=10)

                        # set connection object

                        for idx in range(len(line.connectors)):

                            if line.connectors[idx].connectedItem is None: line.connectors[idx].connectedItem = matches[0]

                        # up to here

                        for item in connectedItems:

                            item.owner = matches[0].owner   # set item's owner

                            item.linkedItem = matches[0].owner

                        pipeRun = QEngineeringRunItem()

                        pipeRun.items = connectedItems

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

                            matches[0].owner.runs.append(pipeRun)

                    else:

                        notMatches.append(line)

                lines = notMatches

        except Exception as ex:

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

    '''

        @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=50):

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

                delimiter = configs[0].value

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

                docData.tracerLineNos.clear()

                ## 기존에 찾은 것 유지

                #for lineNo in self._lineNos:

                #    lineNo.conns.clear()

                docData.tracerLineNos = self._lineNos

                remainLineNos = []

                remainLines = []

                for lineno in docData.tracerLineNos:

                    ## CONN은 유지

                    if lineno.conns:

                        continue

                    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)

                    else:

                        remainLineNos.append(lineno)

                ## lineIndicator

                extendPixel = 10

                for lineIndicator in self._lineIndicator:

                    maxOverLap = 0

                    matchLineNo = None

                    liInRect = [round(lineIndicator.boundingRect().x()), round(lineIndicator.boundingRect().y()), round(lineIndicator.boundingRect().x() + lineIndicator.boundingRect().width()), round(lineIndicator.boundingRect().y() + lineIndicator.boundingRect().height())]

                    for remainLineNo in remainLineNos:

                        xOverlap = False

                        yOverlap = False

                        extendDx = remainLineNo.size[0] if lineIndicator.isVH == 'V' else remainLineNo.size[1]

                        reNoRect = [round(remainLineNo.loc[0] - extendDx), round(remainLineNo.loc[1] - extendDx), round(remainLineNo.loc[0] + remainLineNo.size[0] + extendDx), round(remainLineNo.loc[1] + remainLineNo.size[1] + extendDx)]

                        w, h = 0, 0                        

                        for x1 in range(reNoRect[0], reNoRect[2] + 1):

                            for x2 in range(liInRect[0], liInRect[2] + 1):

                                if x1 - x2 is 0:

                                    xOverlap = True

                                    w += 1

                        if not xOverlap:

                            continue

                        for y1 in range(reNoRect[1], reNoRect[3] + 1):

                            for y2 in range(liInRect[1], liInRect[3] + 1):

                                if y1 - y2 is 0:

                                    yOverlap = True

                                    h += 1

                        if not xOverlap or not yOverlap:

                            continue

                        overLapRate = (w / lineIndicator.boundingRect().width() * 100) if lineIndicator.boundingRect().width() > lineIndicator.boundingRect().height() else (h / lineIndicator.boundingRect().height() * 100)

                        #print(overLapRate)

                        if maxOverLap < overLapRate:

                            maxOverLap = overLapRate

                            matchLineNo = remainLineNo

                            #lineIndicator.setBrush(QBrush(QColor(255, 0, 0, 127)))

                    if matchLineNo is not None:

                        #print(matchLineNo.text() + ' indicator : ' + str(lineIndicator.boundingRect().x()) + ', ' + str(lineIndicator.boundingRect().y()))

                        matchLine = None

                        x1, y1, x2, y2 = round(lineIndicator.boundingRect().x() + lineIndicator.otherLine[0]), round(lineIndicator.boundingRect().y() + lineIndicator.otherLine[1]), round(lineIndicator.boundingRect().x() + lineIndicator.otherLine[2]), round(lineIndicator.boundingRect().y() + lineIndicator.otherLine[3])

                        startXorY = (min(liInRect[0], liInRect[2]) - extendPixel) if lineIndicator.isVH == 'V' else (min(liInRect[1], liInRect[3]) - extendPixel)

                        endXorY = (max(liInRect[0], liInRect[2]) + extendPixel) if lineIndicator.isVH == 'V' else (max(liInRect[1], liInRect[3]) + extendPixel)

                        fXorY = []

                        for dXOrdY in range(startXorY, endXorY + 1): # if horizontal -> Y, if vertical -> X

                            if lineIndicator.isVH == 'V':

                                fXorY.append(round(((y2-y1)/(x2-x1))*dXOrdY + y1 - ((y2-y1)/(x2-x1))*x1)) # f(x)

                            else:

                                fXorY.append(round(((x2-x1)/(y2-y1))*dXOrdY + x1 - ((x2-x1)/(y2-y1))*y1)) # f(y)

                        for line in self._lines:

                            axis1Overlap = False

                            axis2Overlap = False

                            lX1, lY1, lX2, lY2 = int(line.startPoint()[0]), int(line.startPoint()[1]), int(line.endPoint()[0]), int(line.endPoint()[1])

                            if lineIndicator.isVH == 'V':

                                range11 = range(startXorY, endXorY + 1)

                                range12 = range(min(lX1, lX2), max(lX1, lX2)+ 1)

                                range21 = fXorY

                                range22 = range(min(lY1, lY2), max(lY1, lY2) + 1)

                            else:

                                range11 = range(startXorY, endXorY + 1)

                                range12 = range(min(lY1, lY2), max(lY1, lY2) + 1)

                                range21 = fXorY

                                range22 = range(min(lX1, lX2), max(lX1, lX2) + 1)

                            for axis11 in range11:

                                for axis12 in range12:

                                    if axis11 - axis12 is 0:

                                        axis1Overlap = True

                                        break

                                if axis1Overlap: break

                            if not axis1Overlap:

                                continue

                            for axis21 in range21:

                                for axis22 in range22:

                                    if axis21 - axis22 is 0:

                                        axis2Overlap = True

                                        break

                                if axis2Overlap: break

                            if axis1Overlap and axis2Overlap:

                                matchLine = line

                                break

                        if matchLine is not None:

                            matchLineNo.conns.append(matchLine)

                            lineIndicator.lineIndicator = 'Match'

                            lineIndicator.setBrush(QBrush(QColor(0, 0, 255, 127)))

                            #print('connected ' + matchLineNo.text() + ' and ' + matchLine.uid)                     

                ## up to here

                # set start line's owner

                for lineno in docData.tracerLineNos:

                    if lineno.conns: 

                        lineno.conns[0].owner = lineno

                        lineno.conns[0].linkedItem = lineno

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

                # find primary lines

                for lineno in docData.tracerLineNos:

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

                    self.findPrimaryLines(lineno)

                    updateProgress.emit(maxValue)

                # find secondary lines

                lines = self._lines

                self.findSecondaryLines(lines)

                updateProgress.emit(maxValue)

            ### make trim lines

            updateProgress.emit(-1) # reset progressbar

            displayMessage.emit('TrimLine Topology Construction')

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

            if orphanLines:

                maxValue = len(orphanLines)

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

                while len(orphanLines) > 0:

                    trimLineNo = QEngineeringTrimLineNoTextItem()

                    trimLineNo.conns.append(orphanLines[0])

                    orphanLines[0].owner = trimLineNo

                    orphanLines[0].linkedItem = trimLineNo

                    connectedItems = self.findPrimaryLines(trimLineNo)

                    for item in connectedItems:

                        if item in orphanLines:

                            orphanLines.remove(item)

                            updateProgress.emit(maxValue)

                    self.findSecondaryLines(orphanLines)

                    for item in orphanLines[:]:

                        if item.linkedItem is not None:

                            orphanLines.remove(item)

                            updateProgress.emit(maxValue)

                    docData.tracerLineNos.append(trimLineNo)

            updateProgress.emit(maxValue)

        except Exception as ex:

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

    '''

        @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 findConnectedObjects(self, startLine, toler):

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringEquipmentItem import QEngineeringEquipmentItem

        from SymbolSvgItem import SymbolSvgItem

        visited = [startLine]

        try:

            pool = []

            pool.append((0, startLine))

            while len(pool) > 0:

                sign, obj = pool.pop()

                if type(obj) is QEngineeringLineItem:

                    symbolMatches = [x for x in self._symbols if (x.linkedItem is None) and (x not in visited) and len(obj.connectIfPossible(x, toler)) > 0]

                    lineMatches = [x for x in self._lines if (x.linkedItem is None) and (x is not obj) and (x not in visited) and (len(obj.connectIfPossible(x, toler)) > 0)]

                elif issubclass(type(obj), SymbolSvgItem):

                    lineMatches = [x for x in self._lines if (x.linkedItem is None) and (x not in visited) and len(obj.connectIfPossible(x, toler)) > 0]

                    symbolMatches = [x for x in self._symbols if (x.linkedItem is None) and (x is not obj) and (x not in visited) and (len(obj.connectIfPossible(x, toler)) > 0)]

                # order connected objects

                matches = []

                matches.extend([x for x in symbolMatches if not issubclass(type(x), QEngineeringEquipmentItem)])    # except equipment

                matches.extend(lineMatches)

                # specBreak 확인

                isContainSpecBreak = False

                for uid in self._specBreakUID:

                    if obj.uid == uid:

                        isContainSpecBreak = True

                    for item in matches:

                        if item.uid == uid:

                            isContainSpecBreak = True

                    if isContainSpecBreak:

                        break

                # specBreak 포함시

                if isContainSpecBreak:

                    isConnSpecBreak = obj.isConnectSpecBreak(self._specBreak)

                    if isConnSpecBreak[0]:

                        connector = isConnSpecBreak[1]

                        removeList = []

                        if connector.connectedItem is not None:

                            for item in matches:

                                if item == connector.connectedItem:

                                    removeList.append(connector.connectedItem)

                        # connectedItem 제거

                        if connector.connectedItem is not None:

                            connector.connectedItem.disconnectedItemAtConnector(connector)

                        obj.disconnectedItemAtConnector(connector)

                        for item in removeList:

                            matches.remove(item)

                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:

                    pool.append((-1, match))

                    visited.insert(0, match)

                for match in rhs:

                    pool.append((1, match))

                    visited.append(match)

                # up to here

        except Exception as ex:

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

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

    from LineNoTracer import LineNoTracer

    from AppDocData import AppDocData

    from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

    try:

        symbols = []

        lines = []

        lineNos = []

        specBreak = []

        lineIndicator = []

        for item in worker.graphicsView.scene.items():

            if type(item) is QEngineeringSpecBreakItem:

                specBreak.append(item)

            elif issubclass(type(item), SymbolSvgItem):

                #item.owner = None

                item.linkedItem = None

                symbols.append(item)

            elif type(item) is QEngineeringLineNoTextItem:

                #item.owner = None

                item.linkedItem = None

                item.runs.clear()

                lineNos.append(item)

            elif type(item) is QEngineeringLineItem:

                #item.owner = None

                item.linkedItem = None

                lines.append(item)

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

                lineIndicator.append(item)

        # trace line no

        tracer = LineNoTracer(symbols, lines, lineNos, specBreak, lineIndicator)

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

        # up to here

        # connect attribut

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

        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)

        # up to here

    except Exception as ex:

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

    finally:

        worker.finished.emit()