HYTOS

import json

import base64

        # send uncroped image

    def request_text_box_tile(self, img_infos, img_path, score_path):

        try:

            if not self.text_connection():

                return []

            text_box = '/stream_text_box'

            imgs = [info[4] for info in img_infos]

            str_imgs = []

            for img in imgs:

                _, bts = cv2.imencode('.png', img)

                #bts = bts.tostring()

                bts = base64.b64encode(bts).decode()

                str_imgs.append(bts)

            response = requests.post(self._url + text_box, data=json.dumps(str_imgs))

            box_list = response.json()['text_box_list']

            # for debug

            if len(img_infos) != len(box_list):

                print('check return values')

                return

            for index in range(len(img_infos)):

                img_infos[index].append(box_list[index])

            return img_infos

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

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

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

    def get_text_image_tile(self, img, size=[1300, 1300], overlap=100):

        """ return image tile """

        width, height = img.shape[1], img.shape[0]

        width_count, height_count = width // size[0] + 1, height // size[1] + 1

        b_width, b_height = width_count * size[0], height_count * size[1]

        b_img = np.zeros((b_height, b_width), np.uint8) + 255

        b_img[:height, :width] = img[:, :]

        tile_info_list = []

        for row in range(height_count):

            for col in range(width_count):

                t_width = size[0] if height_count == 1 else (\

                    size[0] + overlap * 2 if col != 0 and col != height_count - 1 else size[0] + overlap)

                t_height = size[1] if width_count == 1 else (\

                    size[1] + overlap * 2 if row != 0 and row != width_count - 1 else size[1] + overlap)

                t_y = 0 if row == 0 else row * size[1] - overlap

                t_x = 0 if col == 0 else col * size[0] - overlap

                t_img = b_img[t_y:t_y + t_height, t_x:t_x + t_width]

                tile_info_list.append([row, col, t_x, t_y, t_img.copy()])

                #Image.fromarray(tile_info_list[-1][4]).show()

        return tile_info_list

        elif False:

        else:

            app_web_service = AppWebService()

            #boxes = app_web_service.request_text_box(ocr_image, img_path, score_path)

            tile_image_infos = self.get_text_image_tile(ocr_image)

            img_infos = app_web_service.request_text_box_tile(tile_image_infos, img_path, score_path)

            boxes = []

            for info in img_infos:

                for box in info[5]:

                    box[0] = box[0] + info[0]

                    box[1] = box[1] + info[1]

                    box[4] = box[4] + info[0]

                    box[5] = box[5] + info[1]

                boxes.extend(info[5])

        # merge tile text box

        overlap_merges = []

        for rect1 in rects:

            for rect2 in rects:

                if rect1 is rect2:

                    continue

                l1, l2 = rect1.left(), rect2.left()

                r1, r2 = rect1.right(), rect2.right()

                l_x, s_x = [l1, r1], [l2, r2]

                t1, t2 = rect1.top(), rect2.top()

                b1, b2 = rect1.bottom(), rect2.bottom()

                l_y, s_y = [t1, b1], [t2, b2]

                if not (max(l_x) < min(s_x) or max(s_x) < min(l_x)) and \

                    (max(l_y) < min(s_y) or max(s_y) < min(l_y)):

                    inserted = False

                    for merge in overlap_merges:

                        if rect1 in merge and rect2 in merge:

                            inserted = True

                            break

                        elif rect1 in merge and rect2 not in merge:

                            merge.append(rect2)

                            inserted = True

                            break

                        elif rect2 in merge and rect1 not in merge:

                            merge.append(rect1)

                            inserted = True

                            break

                    if not inserted:

                        overlap_merges.append([rect1, rect2])

        for merge in overlap_merges:

            for rect in merge:

                if rect in rects:

                    rects.remove(rect)

                else:

                    print(str(rect))

        for merge in overlap_merges:

            max_x, max_y, min_x, min_y = 0, 0, sys.maxsize, sys.maxsize

            for rect in merge:

                if rect.left() < min_x:

                    min_x = rect.left()

                if rect.right() > max_x:

                    max_x = rect.right()

                if rect.top() < min_y:

                    min_y = rect.top()

                if rect.bottom() > max_y:

                    max_y = rect.bottom()

            rect = QRect(min_x, min_y, max_x - min_x, max_y - min_y)

            rects.append(rect)

        # up to here

        # merge adjacent text box

        for merge in v_merges + h_merges:

            if merge in v_merges:

                rect._vertical = True

            else:

                rect._vertical = False

        # up to here

def get_text_box_batch(infos):

    boxes_list = []

    for info in infos:

        boxes_list.append(get_text_box(info[0], info[1], info[2], info[3]))

    return boxes_list

def get_text_box(img, img_path=None, score_path=None, trained_model=None):

    parser.add_argument('--cuda', default=True, type=str2bool, help='Use cuda for inference')

    parser.add_argument('--canvas_size', default=1000, type=int, help='image size for inference')

import json, base64

# craft

# service streamer

sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)) + '\\service_streamer_master')

# deep ocr

try:

    #from model import get_prediction, batch_prediction

    import text_craft

    from service_streamer import ThreadedStreamer

    streamer = ThreadedStreamer(text_craft.get_text_box_batch, batch_size=64)

except ImportError as ex:

    ex

    pass

    if request.method == 'POST':

        r = request

        nparr = np.fromstring(r.data, np.uint8)

        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)

        #img = img.reshape(1, -1)

        boxes = text_craft.get_text_box(img, img_path=None, score_path=None, trained_model=os.path.dirname(os.path.realpath(__file__)) + '\\CRAFT_pytorch_master\\weights\\craft_mlt_25k.pth')

        return jsonify({'text_box': boxes})

@app.route('/stream_text_box', methods=['POST'])

def stream_text_box():

    if request.method == 'POST':

        r = request

        str_imgs = json.loads(r.data)

        imgs = []

        for str_img in str_imgs:

            str_img = base64.b64decode(str_img)

            nparr = np.fromstring(str_img, np.uint8)

            img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)

            imgs.append(img)

        boxes_list = []

        for img in imgs:

            boxes = streamer.predict([[img, None, None, os.path.dirname(os.path.realpath(__file__)) + '\\CRAFT_pytorch_master\\weights\\craft_mlt_25k.pth']])

            boxes_list.append(boxes[0])

        return jsonify({'text_box_list': boxes_list})

    app.run(debug=True)