HYTOS

                            target_cursor.execute(f"SET IDENTITY_INSERT {table} ON")

                        try:

                            sql = f"select * from {table}"

                            cursor.execute(sql)

                            col_names = ','.join(list(map(lambda x: '[' + x[0] + ']', cursor.description)))

                            for row in rows:

                                cols = ','.join(['?' for item in row])

                                sql = app_doc_data.project.database.to_sql(f"insert into {table}({col_names}) values({cols})")

                                target_cursor.execute(sql, params)

                        finally:

                            if app_doc_data.project.database.db_type == 'MSSQL' and table == 'Symbol':

        finally:

            QApplication.restoreOverrideCursor()

        """convert record to string"""

        from datetime import datetime

        res = []

                res.append(None)

            else:  # for numeric values

        return res

            copyfile(app_doc_data.get_template_symbol_library_path(), target)

            with app_doc_data.project.database.connect() as conn:

                with sqlite3.connect(target, isolation_level=None) as target_conn:

                    target_conn.row_factory = sqlite3.Row

                    target_cursor = target_conn.cursor()

                        for row in rows:

                            cols = ','.join(['?' for item in row])

                            sql = f"insert into {table} values({cols})"

                            target_cursor.execute(sql, params)

                    target_cursor.execute('commit')

        from TextDetector import TextDetector

        appDocData = AppDocData.instance()

        appDocData.imgName = self.imageName

        img = cv2.imread(self.imgPath, 1)

        imgGray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

        area = appDocData.getArea('Drawing')

        offset = (area.x, area.y) if area is not None else (0, 0)

        thresholdImg = cv2.threshold(imgGray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]

        areaImg = thresholdImg[round(area.y):round(area.y + area.height), round(area.x):round(area.x + area.width)]

        areaImg = cv2.bitwise_not(areaImg)

        contours, hierarchy = cv2.findContours(areaImg, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

        for contour in contours:

            [x, y, w, h] = cv2.boundingRect(contour)

            if (w < 40 or h < 40):

                areaImg[y:y + h, x:x + w] = 0

        areaImg = cv2.bitwise_not(areaImg)

        verticalLineList = []

        horizontalLineList = []

        self.findLines(areaImg, verticalLineList, horizontalLineList)

        for vLine in verticalLineList:

            p1 = vLine[0]

            p2 = vLine[1]

            x = p1[0]

            areaImg[p1[1]:p2[1], x] = 255

        for vLine in horizontalLineList:

            p1 = vLine[0]

            p2 = vLine[1]

            y = p1[1]

            areaImg[y, p1[0]:p2[0]] = 255

        areaImg = cv2.bitwise_not(areaImg)

        recList = self.getContours(areaImg)

        self.toXml(recList, offset)

        self.tableSetting()

        self.progress.setValue(self.progress.maximum())

    def findLines(self, areaImg, verticalLineList, horizontalLineList):

        verticalProcessList = []

        horizontalProcessList = []

        jumpValue = int(areaImg.shape[1] / os.cpu_count())

        value = 0

        for cpuIndex in range(os.cpu_count()):

            verticalProcessList.append((_process, _queue))

            value = value + jumpValue

        jumpValue = int(areaImg.shape[0] / os.cpu_count())

        value = 0

        for cpuIndex in range(os.cpu_count()):

            horizontalProcessList.append((_process, _queue))

            value = value + jumpValue

        progressCount = len(verticalProcessList) + len(horizontalProcessList) + 1

        percentGage = int(100 / progressCount)

        percent = percentGage

        self.progress.setValue(percent)

        QApplication.processEvents()

        for process in verticalProcessList:

            process[0].start()

        for index in range(len(verticalProcessList)):

            verticalLineList.extend(verticalProcessList[index][1].get())

            verticalProcessList[index][0].join()

            horizontalProcessList[index][0].start()

        for process in horizontalProcessList:

            horizontalLineList.extend(process[1].get())

            process[0].join()

        contours, hierarchy = cv2.findContours(areaImg, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

        lineWidth = 5

        recList = []

        tempRecList = []

            [x, y, w, h] = cv2.boundingRect(contour)

            tempRecList.append([x - lineWidth, y - lineWidth, x + w + lineWidth, y + h + lineWidth])

        while len(tempRecList):

            rec1 = tempRecList[0]

            _temp = []

    def toXml(self, recList, offset):

        xml = Element('BOXES')

        for rec in recList:

            [x1, y1, x2, y2] = rec

            w = x2 - x1