HYTOS

            cv2.drawContours(image, selectedContours, -1, (255, 255, 255), -1)

        return image

                    textDetector.recognizeText(area.img, offset, textAreas, searchedSymbolList, worker,

                textDetector.remove_text_from_image(area.img, offset)

        list = []

        ocr_image = None

        try:

            app_doc_data = AppDocData.instance()

            project = app_doc_data.getCurrentProject()

            configs = app_doc_data.getConfigs('Text Size', 'Max Text Size')

            maxTextSize = int(configs[0].value) if 1 == len(configs) else 100

            minSize = 5

            ocr_image = np.ones(imgGray.shape, np.uint8) * 255

            # binaryImg, mask = cv2.threshold(imgGray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

            binaryImg, mask = cv2.threshold(imgGray, 200, 255, cv2.THRESH_BINARY)

            contours, hierarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)

            for contour in contours:

                # remove too big one or horizontal/vertical line

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

                area = cv2.contourArea(contour, True)

                # skip one which size is greater than max size or less then minimum size

                if area >= 0:

                    if (w > maxTextSize or h > maxTextSize) or (w <= minSize and h <= minSize):

                        continue

                if area >= 0:

                    cv2.drawContours(ocr_image, [contour], -1, (0, 0, 0), -1)

                    cv2.drawContours(ocr_image, [contour], -1, (255, 255, 255), 1)

                    cv2.drawContours(ocr_image, [contour], -1, (255, 255, 255), -1)

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

            cv2.imwrite(path, ocr_image)

            rects = []

            configs = app_doc_data.getConfigs('Text Recognition', 'Expand Size')

            expandSize = int(configs[0].value) if 1 == len(configs) else 10

            configs = app_doc_data.getConfigs('Text Recognition', 'Shrink Size')

            shrinkSize = int(configs[0].value) if 1 == len(configs) else 0

            eroded = cv2.erode(ocr_image, np.ones((expandSize, expandSize), np.uint8))

            eroded = cv2.bitwise_not(eroded)

            bboxes = []

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

            for contour in contours:

                area = cv2.contourArea(contour, True)

                if area < 0:

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

                    bboxes.append(QRect(x, y, w, h))

            # exclude bounding boxes contains child bounding box

            not_containing_bbox = []

            for bbox in bboxes:

                matches = [_bbox for _bbox in bboxes if bbox != _bbox and bbox.contains(_bbox)]

                if not matches:

                    not_containing_bbox.append(bbox)

            # up to here

            for bbox in not_containing_bbox:

                x, y = bbox.left(), bbox.top()

                w, h = bbox.width(), bbox.height()

                img = ocr_image[bbox.top():bbox.bottom(), bbox.left():bbox.right()]

                img = cv2.bitwise_not(img)

                horizontal, max_width = 0, 0

                vertical, max_height = 0, 0

                _contours, _ = cv2.findContours(img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

                for xx in _contours:

                    [_x, _y, _w, _h] = cv2.boundingRect(xx)

                    max_width = _x if _x > max_width else max_width

                    max_height = _y if _y > max_height else max_height

                    if (_w < _h) or (_w > maxTextSize > _h):  # width is greater than height

                        horizontal += 1 + (_w * _h) / (w * h)

                    else:

                        vertical += 1 + (_w * _h) / (w * h)

                if (w < minSize and h < minSize) or (max_width > maxTextSize and max_height > maxTextSize):

                    continue  # skip too small or big one

                rects.append([0 if horizontal > vertical else 90, QRect(x, y, w, h)])

            configs = app_doc_data.getConfigs('Text Recognition', 'Merge Size')

            mergeSize = int(configs[0].value) if 1 == len(configs) else 10

            # merge rectangles

            interestings = []

            while rects:

                rect = rects.pop()

                if 0 == rect[0]:    # x-direction text

                    rectExpand = rect[1].adjusted(-mergeSize, 0, mergeSize, 0)

                    matches = [x for x in rects if (x[0] == rect[0]) and

                               abs(x[1].height() - rect[1].height()) < (x[1].height() + rect[1].height())*0.5 and

                               abs(x[1].center().y() - rect[1].center().y()) < rect[1].height()*0.5 and

                               rectExpand.intersects(x[1])]

                else:               # y -direction text

                    rectExpand = rect[1].adjusted(0, -mergeSize, 0, mergeSize)

                    matches = [x for x in rects if (x[0] == rect[0]) and

                               abs(x[1].width() - rect[1].width()) < (x[1].width() + rect[1].width())*0.5 and

                               abs(x[1].center().x() - rect[1].center().x()) < rect[1].width()*0.5 and

                               rectExpand.intersects(x[1])]

                if matches:

                    for _rect in matches:

                        rect[1] = rect[1].united(_rect[1])

                        if _rect in rects:

                            rects.remove(_rect)

                    rects.append(rect)

                else:

                    interestings.append(rect)

            for rect in interestings:

                matches = [_rect for _rect in interestings if rect != _rect and _rect[1].contains(rect[1])]

                # if there is no boxes which contains

                if not matches:

                    angle = rect[0]

                    list.append(ti.TextInfo('', round(offsetX) + rect[1].x(), round(offsetY) + rect[1].y(), rect[1].width(),

                                            rect[1].height(), angle))

        except Exception as ex:

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

                                                           sys.exc_info()[-1].tb_lineno)

            print(message)

            text_info_array = np.array_split(tInfoList, THREAD_MAX_WORKER if len(tInfoList) > THREAD_MAX_WORKER else \

                len(tInfoList))

            """"

    def remove_text_from_image(self, imgSrc, offset):

        # remove recognized text from image

        for text in self.textInfoList:

            x = round(text.getX() - offset[0])

            y = round(text.getY() - offset[1])

            width = round(text.getW())

            height = round(text.getH())

            cv2.rectangle(imgSrc, (x, y), (x + width, y + height), 255, -1)

        # up to here

        # DEBUG

        #cv2.imwrite("c:\\temp\\remove_texts.png", imgSrc)

DEFAULT_CONF_COMM = "--psm {}"

            _conf += f" -c tessedit_char_whitelist=\"{conf}\""

        thickness = 10

                    tmp = QRect(minx, miny, maxx - minx, maxy - miny)

                    matches = [merged_box for merged_box in merged_boxes if

                               (merged_box.top() - tmp.center().y())*(merged_box.bottom() - tmp.center().y()) < 0]

                    if matches:

                        matches[0].setLeft(min(matches[0].left(), minx))

                        matches[0].setTop(min(matches[0].top(), miny))

                        matches[0].setRight(max(matches[0].right(), maxx))

                        matches[0].setBottom(max(matches[0].bottom(), maxy))

                    else:

                        merged_boxes.append(QRect(minx, miny, maxx - minx, maxy - miny))

                    """

                    """

        """

        """