HYTOS

                """ create a svg file by using QSvgGenerator of pyqt5

            node.attrib['class'] = self.name

    def decode_predictions(self, scores, geometry):

        # grab the number of rows and columns from the scores volume, then

        # initialize our set of bounding box rectangles and corresponding

        # confidence scores

        (numRows, numCols) = scores.shape[2:4]

        rects = []

        confidences = []

        # loop over the number of rows

        for y in range(0, numRows):

            # extract the scores (probabilities), followed by the

            # geometrical data used to derive potential bounding box

            # coordinates that surround text

            scoresData = scores[0, 0, y]

            xData0 = geometry[0, 0, y]

            xData1 = geometry[0, 1, y]

            xData2 = geometry[0, 2, y]

            xData3 = geometry[0, 3, y]

            anglesData = geometry[0, 4, y]

            # loop over the number of columns

            for x in range(0, numCols):

                # if our score does not have sufficient probability,

                # ignore it

                if scoresData[x] < 0.5:  # args["min_confidence"]:

                    continue

                # compute the offset factor as our resulting feature

                # maps will be 4x smaller than the input image

                (offsetX, offsetY) = (x * 4.0, y * 4.0)

                # extract the rotation angle for the prediction and

                # then compute the sin and cosine

                angle = anglesData[x]

                cos = np.cos(angle)

                sin = np.sin(angle)

                # use the geometry volume to derive the width and height

                # of the bounding box

                h = xData0[x] + xData2[x]

                w = xData1[x] + xData3[x]

                # compute both the starting and ending (x, y)-coordinates

                # for the text prediction bounding box

                endX = int(offsetX + (cos * xData1[x]) + (sin * xData2[x]))

                endY = int(offsetY - (sin * xData1[x]) + (cos * xData2[x]))

                startX = int(endX - w)

                startY = int(endY - h)

                # add the bounding box coordinates and probability score

                # to our respective lists

                rects.append((startX, startY, endX, endY))

                confidences.append(scoresData[x])

        # return a tuple of the bounding boxes and associated confidences

        return (rects, confidences)

    def getTextAreaInfo(self, imgGray, offset_x, offset_y):

        #from imutils.object_detection import non_max_suppression

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

            cv2.rectangle(ocr_image, (0, 0), ocr_image.shape[::-1], (255, 255, 255), -1)

            mask = cv2.threshold(imgGray, 200, 255, cv2.THRESH_BINARY)[1]

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

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

                    continue

            """

            east = False

            if east:

                # define the two output layer names for the EAST detector model that

                # we are interested -- the first is the output probabilities and the

                # second can be used to derive the bounding box coordinates of text

                layerNames = [

                    "feature_fusion/Conv_7/Sigmoid",

                    "feature_fusion/concat_3"]

                # load the pre-trained EAST text detector

                net = cv2.dnn.readNet("C:\\ProgramData\\Digital PID\\frozen_east_text_detection.pb")

                (H, W) = ocr_image.shape[:2]

                # construct a blob from the image and then perform a forward pass of

                # the model to obtain the two output layer sets

                blob = cv2.dnn.blobFromImage(ocr_image, 1.0, (W, H), (123.68, 116.78, 103.94), swapRB=True, crop=False)

                net.setInput(blob)

                (scores, geometry) = net.forward(layerNames)

                # decode the predictions, then  apply non-maxima suppression to

                # suppress weak, overlapping bounding boxes

                (rects, confidences) = self.decode_predictions(scores, geometry)

                boxes = non_max_suppression(np.array(rects), probs=confidences)

                # loop over the bounding boxes

                for (startX, startY, endX, endY) in boxes:

                    pass

            else:

            """

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

            binary_image = cv2.threshold(ocr_image, 200, 255, cv2.THRESH_BINARY)[1]

            eroded = cv2.erode(binary_image, np.ones((expand_size, expand_size), np.uint8))

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

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

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

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

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

if __name__ == "__main__":

    image = cv2.imread('d:\\Projects\\DTIPID\\Projects\\IX3\\Temp\\OCR_Document_2_Page1.png')

    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    output = gray.copy()

    gray = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY)[1]

    expand_size = 5

    eroded = cv2.erode(gray, np.ones((expand_size, expand_size), np.uint8))

    eroded = cv2.bitwise_not(eroded)

    cv2.imwrite('c:\\temp\\eroded.png', 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

    rects = []

    for bbox in not_containing_bbox:

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

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

        img = gray[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*0.9 < _h) or (_w > 80 > _h):  # width is greater than height

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

            else:

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

        if (w < 5 and h < 5) or (max_width > 80 and max_height > 80):

            continue  # skip too small or big one

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

    merge_size = 10

    # merge rectangles

    interestings = []

    while rects:

        rect = rects.pop()

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

            rect_expand = rect[1].adjusted(-merge_size, 0, merge_size, 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.25 and

                       rect_expand.intersects(x[1].adjusted(-merge_size, 0, merge_size, 0))]

        else:  # y -direction text

            rect_expand = rect[1].adjusted(0, -merge_size, 0, merge_size)

            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.25 and

                       rect_expand.intersects(x[1].adjusted(0, -merge_size, 0, merge_size))]

        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 orientation, bbox in interestings:

        cv2.rectangle(output, (bbox.x(), bbox.y()), (bbox.right(), bbox.bottom()), (0, 255, 0), 1)

    """

    mser = cv2.MSER_create(_min_area=10)

    regions, _ = mser.detectRegions(gray)  # Get the text area

    hulls = [cv2.convexHull(p.reshape(-1, 1, 2)) for p in regions]  # Drawing text areas

    # Processing irregular detection boxes into rectangular boxes

    keep = []

    for c in hulls:

        x, y, w, h = cv2.boundingRect(c)

        cv2.rectangle(output, (x, y), (x + w, y + h), (0, 255, 0), 1)

    """

    #cv2.polylines(output, hulls, 1, (0, 255, 0))

    cv2.imwrite('c:\\temp\\mser.png', output)

# coding: utf-8

class TextInfo:

        self._text = text.replace('—', '-')  # TODO: check this code!!!

        """ return area of area """

        return self.w * self.h

        """ return center of text """

        return (self.getX() + self.getW() * 0.5, self.getY() + self.getH() * 0.5)

        return self.angle