HYTOS

                from EngineeringLineItem import QEngineeringLineItem

                from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

                from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

                if self._attr is not None:

                    item = self.imageViewer.scene.itemAt(scenePos, QTransform())

                        self.onSuccess.emit()

                    elif item is not None and self._attr.AttributeType == 'Conn' and (issubclass(type(item), QEngineeringLineItem) or issubclass(type(item), SymbolSvgItem)):

                        self.onSuccess.emit()

                    elif item is not None and issubclass(type(self._item), QEngineeringSpecBreakItem) and self._attr.AttributeType == 'Comp Item':

                        self._item.attrs[self._attr] = str(item.uid)

                self.setItem(2, 1, QTableWidgetItem(self.symData.type))

                self.setItem(3, 1, QTableWidgetItem(str(round(math.degrees(self.symData.angle)))))

                self.setItem(4, 1, QTableWidgetItem(str(self.symData.origin)))

                icon = QtGui.QIcon()

                icon.addPixmap(QtGui.QPixmap(":/newPrefix/doubleclick.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)

                owner_item.setIcon(icon)

        qy = origin[1] + math.sin(angle) * dx + math.cos(angle) * dy

        return [qx, qy]

    '''

        @brief  check if given two lines are connected

        @author humkyung

                        connectedLines.append(mergedLine)

                        for match in matches: connectedLines.remove(match)

        except Exception as ex:

    '''

        @brief  connect line to nearest connection point of symbol

        @author humkyung

        @date   2018.04.13

    '''

        distStart.sort()

        distEnd.sort()

        if distStart[0][0] < distEnd[0][0]:

            dx = distStart[0][1][0] - startPt[0]

            dy = distStart[0][1][1] - startPt[1]

            if abs(dir[0]) > abs(dir[1]):

            else:

        else:

            dx = distEnd[0][1][0] - endPt[0]

            dy = distEnd[0][1][1] - endPt[1]

            if abs(dir[0]) > abs(dir[1]):

            else:

    '''

        @brief  extend line to intersection point

    '''

    def connectLineToLine(self, lhs, rhs, toler=20):

        try:

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

            if length == 0: return

            dx /= length

            dy /= length

            shapelyRightLine = shapely.geometry.LineString(rightLine)

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

            if length == 0: return

            dx /= length

            dy /= length

            shapelyLine = shapely.geometry.LineString(line)

            pt = shapelyRightLine.intersection(shapelyLine)

            if (pt is not None) and (type(pt) == shapely.geometry.point.Point):

                    else:

                    else:

        except Exception as ex:

            from App import App 

            from AppDocData import MessageType

            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  detech line thickness

        @author humkyung

        img = area.img

        if True:

            image, contours, hierarchy = cv2.findContours(imgNot, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

            if len(contours) is 0:

                foundCount = 0

                notMatches = []

                for line in lines:

                    if matches:

                        foundCount += 1

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

            ### make trim lines

            updateProgress.emit(-1) # reset progressbar

            if orphanLines:

                maxValue = len(orphanLines)

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

                    self.findSecondaryLines(orphanLines)

                    for item in orphanLines[:]:

                            orphanLines.remove(item)

                            updateProgress.emit(maxValue)

            updateProgress.emit(maxValue)

        except Exception as ex:

    '''

        @brief      find objects connected to given line while loop

            while len(pool) > 0:

                sign, obj = pool.pop()

                if type(obj) is QEngineeringLineItem:

                elif issubclass(type(obj), SymbolSvgItem):

                # order connected objects

                matches = []

                # up to here

        except Exception as ex:

        return visited

            if type(item) is QEngineeringSpecBreakItem:

                specBreak.append(item)

            elif issubclass(type(item), SymbolSvgItem):

                symbols.append(item)

            elif type(item) is QEngineeringLineNoTextItem:

                item.runs.clear()

                lineNos.append(item)

            elif type(item) is QEngineeringLineItem:

                lines.append(item)

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

                lineIndicator.append(item)

                    lineItem.transfer.onRemoved.connect(self.itemRemoved)

                    lineItem.lineType = lineType

                    if items:

                    else:

                        pt = lineItem.startPoint()

                        selected = [item for item in self.graphicsView.scene.items(QPointF(pt[0], pt[1])) if type(item) is QEngineeringConnectorItem or type(item) is QEngineeringLineItem]

                        if selected:

                    items.append(lineItem)

                    self.graphicsView.scene.addItem(lineItem)

                pt = items[-1].endPoint()

                selected = [item for item in self.graphicsView.scene.items(QPointF(pt[0], pt[1])) if type(item) is QEngineeringConnectorItem and item.parent is not items[-1]]

                if selected:

        finally:

            self.graphicsView.scene.removeItem(self.actionLine.tag._polyline)

            self.actionLine.tag.reset()

            while len(pool) > 0:

                line = pool.pop()

                print('{} - ({})'.format(line, len(pool)))

                if rhs:

                    pool.extend(rhs)

                    visited.extend(rhs)

                        item.arrangeVertexOrder(line)

                # skip jointed symbols

                if symbolPool:

                    selected = []

                    visited.extend(symbolPool)

                    while len(symbolPool) > 0:

                        symbol = symbolPool.pop()

                        if rhs:

                            symbolPool.extend(rhs)

                            visited.extend(rhs)

                    # find lines which are connected last symbol

                    for symbol in selected:

                        if rhs:

                            pool.extend(rhs)

                            visited.extend(rhs)

                listWidget.addItem(worker.tr('Creating detected infos...'))

                worker.displayTitle.emit(worker.tr('Creating detected infos...'))

                createDetectedItems(searchedSymbolList, textInfoList, otherTextInfoList if otherTextInfoList is not None else [], titleBlockTextInfoList if titleBlockTextInfoList is not None else [])

                if isLineChecked:

                        connectedLines.extend(res)

            # line detection without symbol connection point info

            windowSize = appDocData.getSlidingWindowSize()

            thickness = int(windowSize[1])

            for line in remainLines:

                line.append(thickness)

            connectedLines.extend(remainLines)

                # connect line to symbol

                try:

                        for symbol in matches:

                except Exception as ex:

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

                    worker.displayLog.emit(MessageType.Error, message)

                configs = appDocData.getConfigs('Line Detector', 'Length to connect line')

                toler = int(configs[0].value) if configs else 20

                try:

                        # get closest line

                        selected = []

                        for match in matches:

                            if dist[0] < toler or dist[1] < toler:

                                selected.append(match)

                        # up to here

                        for match in matches:

            listWidget.addItem(worker.tr('Creating lines...'))

            for pts in connectedLines:

                processLine = QEngineeringLineItem(vertices=[(area.x + param[0], area.y + param[1]) for param in pts[:-1]], thickness=pts[2])

                processLine.area = 'Drawing'

                if processLine.length() > 100: # TODO: check critical length

                    processLine.addFlowArrow()

        except Exception as ex:

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

            worker.displayLog.emit(MessageType.Error, message)

    DEFAULT_COLOR = '#0000FF'

    HOVER_COLOR   = '#BC4438'

    def __init__(self, parent=None):

        self._color = self.DEFAULT_COLOR # default color

        self._owner = None

    except ImportError:

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

from EngineeringLineItem import QEngineeringLineItem

"""

        self._spec_break = None

        self.highlight = False

        self.connectedItem = None

        self.sceneConnectPoint = None

        self.connectPoint = None

        self._hoverItem = None

        self.setRect(self._loc[0] - round(self.SMALL_SIZE*0.5), self._loc[1] - round(self.SMALL_SIZE*0.5), self.SMALL_SIZE, self.SMALL_SIZE)

        self.update()

    '''

        @brief  highlight connector

        @authro humkyung

                pt = items[0].intersection([start, end])

                if (pt is not None) and (type(pt) == shapely.geometry.point.Point):

                    self.setPos((pt.x, pt.y))

            elif items and type(items[0]) is QEngineeringConnectorItem:

                self.setPos(items[0].center())

                        if connect.connectedItem == self.parent:

                            connect.connectedItem = None

            else:

                pt = [event.scenePos().x(), event.scenePos().y()]

                if self._drawing_mode == QEngineeringConnectorItem.AXIS_MODE:

        else:

            return False

    @staticmethod

    def fromXml(node):

        """

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree

        node = Element('CONNECTOR')

        return node

        return clone

    '''

        @brief  return start point

        @author humkyung

        rhs = LineString(line)

        return lhs.intersection(rhs)

    '''

        @brief      check if two lines are connectable

        @author     humkyung

        @history    Jeongwoo 18.05.15 Add check pt's type

                    Jeongwoo 18.05.16 Add length == 0 check

    '''

        import math

        startPt = line.startPoint()

        return (pt is not None) and (type(pt) == shapely.geometry.point.Point)

    '''

        @author     humkyung

        @date       2018.06.26

        @history    humkyung 2018.07.03 allow item to be line or symbol

    '''

    '''

        @brief      join line to symbol

        return False

    '''

        @author     humkyung

        @date       2018.04.16

        @history    humkyung 2018.05.08 check if line is possible to be connected

                    Jeongwoo 2018.05.15 Split if-statement and Connect each symbol and line

    '''

        from shapely.geometry import Point

        from SymbolSvgItem import SymbolSvgItem

        res = []

        startPt = self.startPoint() 

                    if (Point(startPt[0], startPt[1]).distance(Point(pt[0], pt[1])) < toler):

                        if self.connectors[0].connectedItem is None:

                        if obj.connectors[i].connectedItem is None:

                        res.append(obj)

                    if (Point(endPt[0], endPt[1]).distance(Point(pt[0], pt[1])) < toler):

                        if self.connectors[1].connectedItem is None:

                        if obj.connectors[i].connectedItem is None:

                        res.append(obj)

            elif type(obj) is QEngineeringLineItem:

                _startPt = obj.startPoint()

                _endPt = obj.endPoint()

        except Exception as ex:

            from App import App 

            from AppDocData import MessageType

            if connectors is not None:

                iterIndex = 0

                for connector in connectors.iter('CONNECTOR'):

                    iterIndex += 1

        except Exception as ex:

            from App import App 

            connectorsNode = Element('CONNECTORS')

            for connector in self.connectors:

            node.append(connectorsNode)

            # up to here

from AppDocData import *

from EngineeringConnectorItem import QEngineeringConnectorItem

from EngineeringAbstractItem import QEngineeringAbstractItem

from UserInputAttribute import UserInputAttribute

import SelectAttributeCommand

        @author humkyung

        @date   2018.04.13

    '''

        for connector in self.connectors:

            if (math.sqrt(dx*dx + dy*dy) < toler): return True

            if (math.sqrt(dx*dx + dy*dy) < toler): return True

        return False

    '''

        @author     humkyung

        @date       2018.07.03

    '''

    '''

        @brief      connect line and symbol is able to be connected and return line

        @author     humkyung

        @history    humkyung 2018.05.08 check if symbol is possible to be connected

                    Jeongwoo 2018.05.15 Connect each symbol and line

    '''

        from shapely.geometry import Point

        from EngineeringLineItem import QEngineeringLineItem

        res = []

        try:

            if type(obj) is QEngineeringLineItem:

                for i in range(len(self.connectors)):

                    if (Point(startPt[0], startPt[1]).distance(Point(self.connectors[i].sceneConnectPoint[0], self.connectors[i].sceneConnectPoint[1])) < toler):

                        if self.connectors[i].connectedItem is None:

                        if obj.connectors[0].connectedItem is None:

                        res.append(obj)

                    if (Point(endPt[0], endPt[1]).distance(Point(self.connectors[i].sceneConnectPoint[0], self.connectors[i].sceneConnectPoint[1])) < toler):

                        if self.connectors[i].connectedItem is None:

                        if obj.connectors[1].connectedItem is None:

                        res.append(obj)

            elif issubclass(type(obj), SymbolSvgItem):

                        _pt = Point(obj.connectors[j].sceneConnectPoint[0], obj.connectors[j].sceneConnectPoint[1])

                        if (_pt.distance(Point(self.connectors[i].sceneConnectPoint[0], self.connectors[i].sceneConnectPoint[1])) < toler):

                            if self.connectors[i].connectedItem is None:

                            res.append(obj)

        except Exception as ex:

        return res

            connectorsNode = Element('CONNECTORS')

            for connector in self.connectors:

            node.append(connectorsNode)

            connectionNode = Element('CONNECTIONPOINT')

                if connectors is not None:

                    iterIndex = 0

                    for connector in connectors.iter('CONNECTOR'):

                        iterIndex += 1

                # get associations 

        path = os.path.join(project.getTempPath(), 'OCR_{}.png'.format(appDocData.imgName))

        if os.path.isfile(path):

            imgOCR = cv2.threshold(cv2.cvtColor(imgOCR, cv2.COLOR_BGR2GRAY), 127, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)[1]

            # remove recognized text from image

            temp = img[y:y+height, x:x+width]

            imgOCR = cv2.erode(imgOCR, np.ones((3,3), np.uint8))

            imgXOR = cv2.bitwise_xor(temp, mask)

            img[y:y+height, x:x+width] = cv2.bitwise_not(imgXOR)