HYTOS

                self.show_item_properties(self._item)

                key_item = QTableWidgetItem(self.tr("Start"))

                key_item.setFlags(Qt.ItemIsEnabled)

                self.setItem(3, 1, key_item)

                self.setItem(3, 3, QTableWidgetItem('({},{})'.format(pt[0], pt[1])))

                key_item = QTableWidgetItem(self.tr("End"))

                key_item.setFlags(Qt.ItemIsEnabled)

                self.setItem(4, 1, key_item)

                self.setItem(4, 3, QTableWidgetItem('({},{})'.format(pt[0], pt[1])))

                    if items:

                        lineItem.connect_if_possible(items[-1], 5)

                    else:

                        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 and selected[0] is not lineItem:

                    self.graphicsView.scene().addItem(lineItem)

                    app_doc_data.lines.append(lineItem)

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

                if selected and selected[0] is not items[-1]:

                    if type(selected[0]) is QEngineeringConnectorItem:

                        items[-1].connect_if_possible(selected[0].parent, 5)

                    length = items[0].length() * 0.5

                    dir = items[0].perpendicular()

                    if self.parent.isHorizontal():

                    else:

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

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

                         (issubclass(type(item), SymbolSvgItem) or issubclass(type(item),

                                                                              QEngineeringTextItem) or issubclass(

                             type(item), QEngineeringLineItem) or type(item) is QEngineeringConnectorItem)]

                if len(items) > 0:

                    if not hasattr(self, '_underItem') or self._underItem is not items[0]:

                        if hasattr(self, '_underItem') and self._underItem is not None:

                elif hasattr(self, '_underItem') and self._underItem is not None:

                    self._underItem.hoverLeaveEvent(event)

                    self._underItem = None

                if items and self.parent not in items and type(items[0]) is QEngineeringLineItem:

                    length = items[0].length() * 0.5

                    dir = items[0].perpendicular()

                    if self.parent.isHorizontal():

                    else:

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

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

        @date   2018.04.16

    '''

        at = self.line().p1()

        return (at.x(), at.y())

        @date   2018.04.16

    '''

        at = self.line().p2()

        return (at.x(), at.y())

    def distanceTo(self, pt):

        from shapely.geometry import Point, LineString

        line = LineString([(startPt[0], startPt[1]), (endPt[0], endPt[1])])

        dist = line.distance(Point(pt[0], pt[1]))

    def perpendicular(self):

        import math

        dx, dy = -dy, dx

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

        dx /= length

    def angle(self):

        import math

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

        dot = self.dotProduct((1, 0), (dx, dy))

    def length(self):

        import math

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

        return math.sqrt(dx * dx + dy * dy)

    def isHorizontal(self):

        import math

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

    def isVertical(self):

        import math

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

        import math

        from shapely.geometry import Point, LineString

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

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

        import math

        try:

            angle = self.getAngle(rhs)

            if (angle == 0) or (angle == math.pi): return True

        except ZeroDivisionError:

        from EngineeringConnectorItem import QEngineeringConnectorItem

        if type(item) is QEngineeringLineItem:

            dx = endPt[0] - startPt[0]

            dy = endPt[1] - startPt[1]

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

        elif type(item) is QEngineeringConnectorItem:

            lhs = [end_pt[0] - start_pt[0], end_pt[1] - start_pt[1]]

            length = math.sqrt(lhs[0] * lhs[0] + lhs[1] * lhs[1])

        from SymbolSvgItem import SymbolSvgItem

        # line의 Point 정의

        if item is not None and type(item) is QEngineeringLineItem:

            selected = startPoint if self._selectedIndex == 0 else endPoint if self._selectedIndex else []

            if selected:

    def arrangeVertexOrder(self, arranged):

        import math

        index = 0

        indexed = 0

                    type(line.connectors[0].connectedItem), SymbolSvgItem)) or (

                                   line.connectors[1].connectedItem is not None and issubclass(

                               type(line.connectors[1].connectedItem), SymbolSvgItem))

            elif self.isVertical() and line.isVertical():

                flag = (line.connectors[0].connectedItem is not None and issubclass(

                    type(line.connectors[0].connectedItem), SymbolSvgItem)) or (

                                   line.connectors[1].connectedItem is not None and issubclass(

                               type(line.connectors[1].connectedItem), SymbolSvgItem))

        return False

        import math

        try:

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

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

            if length > lineLength:

                return True

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

            if length > lineLength:

                return True

        res = []

        try:

            if issubclass(type(obj), SymbolSvgItem):

                            res.append(start_pt)

                            res.append(obj.connectors[i].center())

            elif type(obj) is QEngineeringLineItem:

                if obj.connectors[0].connectedItem is None and self.distanceTo(_startPt) < toler:

                    if self.connectors[0].connectedItem is None and \

                            (Point(start_pt[0], start_pt[1]).distance(Point(_startPt[0], _startPt[1])) < toler):

            docData = AppDocData.instance()

            area = docData.getArea('Drawing')

            length = self.length()

            direction = [(endPt[0] - startPt[0]) / length, (endPt[1] - startPt[1]) / length]

                                            -angle, Point(0, 0), use_radians=True)

                #symbol.connectors[i].sceneConnectPoint = (origin.x + rotatedPt.x, origin.y + rotatedPt.y)

            length1 = math.sqrt(dx1 * dx1 + dy1 * dy1)

            length2 = math.sqrt(dx2 * dx2 + dy2 * dy2)

            if length1 < length2:

                processLine.connectors[0].connectedItem = symbol

                processLine.connectors[1].connectedItem = self.connectors[1].connectedItem

                self.scene().addItem(processLine)

                symbol.connectors[0].connectedItem = self

                symbol.connectors[1].connectedItem = processLine

            else:

                processLine.connectors[0].connectedItem = symbol

                processLine.connectors[1].connectedItem = self.connectors[1].connectedItem

                self.scene().addItem(processLine)

            symbol.connectors[1].connectedItem

            pts = []

            self.scene().removeItem(connected)

    def drawToImage(self, img, color, thickness):

        """write recognized lines to image"""

        try:

            cv2.line(img, (round(ptStart[0]), round(ptStart[1])), (round(ptEnd[0]), round(ptEnd[1])), color, thickness)

            # up to here

        except Exception as ex:

            uidNode.text = str(self.uid)

            node.append(uidNode)

            startNode = Element('STARTPOINT')

            startNode.text = '{},{}'.format(startPt[0], startPt[1])

            polyline = Element('polyline')

            polyline.attrib['fill'] = 'none'

            polyline.attrib['points'] = f"{start_pt[0]},{start_pt[1]} " \

                                        f"{end_pt[0]},{end_pt[1]}"

            node.append(polyline)

        if event.buttons() == Qt.LeftButton:

            pos = event.scenePos()

            dx = ptStart[0] - pos.x()

            dy = ptStart[1] - pos.y()

            if math.sqrt(dx * dx + dy * dy) < 10:

                self._selectedIndex = 0

                return

            dx = ptEnd[0] - pos.x()

            dy = ptEnd[1] - pos.y()

            if math.sqrt(dx * dx + dy * dy) < 10:

        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].center()[0],

                                                                     self.connectors[i].center()[1])) < toler):

        # uuidNode = Element(LLINE_UUID)

        # uuidNode.text = line.uid

        startPointNode = Element(LLINE_START_POINT_NODE_NAME)

        endPointNode = Element(LLINE_END_POINT_NODE_NAME)

        # lineInfoNode.append(uuidNode)

        lineInfoNode.append(startPointNode)

        lineInfoNode.append(endPointNode)