HYTOS

                # symbol insert test

                '''

                elif len(svg.connectors) == 2:

                    matches = [item for item in scene.items() if (type(item) is QEngineeringLineItem) and (item.distanceTo([round(scenePos.x()), round(scenePos.y())]) < 20)]

                    svg.addSvgItemToScene(scene, True if not auto else False)

                    if matches:

                        matches[0].insert_symbol(svg, scenePos)

                else:

                    svg.addSvgItemToScene(scene, True if not auto else False)

                '''

    def insert_symbol(self, symbol, pos: QPointF):

        """split line and join symbol and line"""

        import math

        from App import App

        from shapely.geometry import Point, LineString

        from shapely import affinity

        def perpendicular(pts):

            import math

            dx, dy = pts[1][0] - pts[0][0], pts[1][1] - pts[0][1]

            dx, dy = -dy, dx

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

            dx /= length

            dy /= length

            return (dx, dy)

        def intersection(pts, line):

            import math

            from shapely.geometry import Point, LineString

            start_pt, end_pt = pts[0], pts[1]

            dx, dy = end_pt[0] - start_pt[0], end_pt[1] - start_pt[1]

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

            if length == 0:

                return None

            dx /= length

            dy /= length

            lhs = LineString(

                [(start_pt[0] - dx * 20, start_pt[1] - dy * 20), (end_pt[0] + dx * 20, end_pt[1] + dy * 20)])

            rhs = LineString(line)

            return lhs.intersection(rhs)

        def dot_product(lhs, rhs):

            return sum([lhs[i] * rhs[i] for i in range(len(lhs))])

        def angle(pts):

            import math

            start_pt, end_pt = pts[0], pts[1]

            dx, dy = end_pt[0] - start_pt[0], end_pt[1] - start_pt[1]

            dot = dot_product((1, 0), (dx, dy))

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

            return math.acos(dot / length)

        try:

            x1, y1, x2, y2 = self.line().x1(), self.line().y1(), self.line().x2(), self.line().y2()

            path = QPainterPath()

            path.moveTo(x1, y1)

            path.lineTo(x2, y2)

            pts = []

            for idx in range(path.elementCount()):

                ele = path.elementAt(idx)

                if ele.isMoveTo():

                    pts.clear()

                    pts.append((ele.x, ele.y))

                elif ele.isLineTo():

                    if len(pts) > 1:

                        pts.pop(0)

                    pts.append((ele.x, ele.y))

                    vec = perpendicular(pts)

                    line = [(pos.x() - vec[0] * 20, pos.y() - vec[1] * 20),

                            (pos.x() + vec[0] * 20, pos.y() + vec[1] * 20)]

                    origin = intersection(pts, line)

                    if type(origin) is Point:

                        dx, dy = origin.x - pos.x(), origin.y - pos.y()

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

                        symbol.moveBy(origin.x - pos.x(), origin.y - pos.y())

                        symbol.loc = [round(origin.x - symbol.symbolOrigin[0], 1),

                                      round(origin.y - symbol.symbolOrigin[1], 1)]

                        symbol.size = [symbol.boundingRect().width(), symbol.boundingRect().height()]

                        symbol.angle = round(angle(pts), 2)

                        symbol.setRotation(math.radians(-symbol.angle))

                        if 2 == len(symbol.connectors):  # 2 way component

                            symbol_connectors = symbol.connectors

                            dx1 = symbol_connectors[0].center()[0] - pts[0][0]

                            dy1 = symbol_connectors[0].center()[1] - pts[0][1]

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

                            dx2 = symbol_connectors[1].center()[0] - pts[0][0]

                            dy2 = symbol_connectors[1].center()[1] - pts[0][1]

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

                            if length1 < length2:

                                _vertices = []

                                """create a new line"""

                                _vertices.append(self.start_point())

                                _vertices.append(symbol_connectors[0].center())

                                new_line = QEngineeringLineItem(_vertices)

                                self.scene().addItem(new_line)

                                if self.connectors[0].connectedItem:

                                    new_line.connectors[0].connect(self.connectors[0].connectedItem)

                                new_line.connectors[1].connect(symbol)

                                symbol_connectors[0].connect(new_line)

#

                                #"""update stream line"""

                                _vertices.clear()

                                _vertices.append(symbol_connectors[1].center())

                                _vertices.append(self.end_point())

                                self.setLine(_vertices[0][0], _vertices[0][1], _vertices[1][0], _vertices[1][1])

                                self.connectors[0].connect(symbol)

                                symbol_connectors[1].connect(self)

                                self.scene().update()

                                #"""up to here"""

                                return

                            else:

                                """create a new line"""

                                _vertices = []

                                _vertices.append(self.start_point())

                                _vertices.append(symbol_connectors[1].center())

                                new_line = QEngineeringLineItem(_vertices)

                                self.scene().addItem(new_line)

                                if self.connectors[0].connectedItem:

                                    new_line.connectors[0].connect(self.connectors[0].connectedItem)

                                new_line.connectors[1].connect(symbol)

                                symbol_connectors[1].connect(new_line)

                                #"""up to here"""

                                _vertices.clear()

                                connector_center = symbol_connectors[0].center()

                                _vertices.append([connector_center[0], connector_center[1]])

                                _vertices.append(self.end_point())

                                self.setLine(_vertices[0][0], _vertices[0][1], _vertices[1][0], _vertices[1][1])

                                self.connectors[0].connect(symbol)

                                symbol_connectors[0].connect(self)

                                self.scene().update()

                                return

                        """

                        symbol.loc = [origin.x - symbol.symbolOrigin[0], origin.y - symbol.symbolOrigin[1]]

                        symbol.size = [symbol.boundingRect().width(), symbol.boundingRect().height()]

                        self.scene().addItem(symbol)

                        """

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

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