HYTOS

    def request_ocr_gcloud(self, img):

        # send uncroped image

        try:

            if not self.test_connection():

                return []

            text_box = '/recognition/ocr'

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

            bts = bts.tostring()

            response = requests.post(self._url + text_box, data=bts)

            return response.json()['text_box']

        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)

            return []            

                #Worker.drawFoundTextsOnCanvas(mainRes, textInfoList)

    def get_text_using_gcloud(self, imgGray, areaInfos, offset, searchedSymbolList, worker):

        import math

        from AppWebService import AppWebService

        try:

            app_doc_data = AppDocData.instance()

            total_x = 0

            total_y = 0

            max_y = 0

            gap = 45

            line_gap = 15

            for areaInfo in areaInfos:

                if areaInfo.getAngle() == 0:

                    total_x = total_x + areaInfo.getW()

                    total_y = total_y + areaInfo.getH()

                    if max_y < areaInfo.getH():

                        max_y = areaInfo.getH()

                else:

                    total_x = total_y + areaInfo.getH()

                    total_y = total_x + areaInfo.getW()

                    if max_y < areaInfo.getW():

                        max_y = areaInfo.getW()

            average_x = (total_x / len(areaInfos)) + gap

            average_y = (total_y) / len(areaInfos) + gap

            num_x = int(math.sqrt(((average_y + gap) * len(areaInfos)) / (average_x + gap)))

            num_y = (len(areaInfos) / num_x) + 15

            _canvas = np.zeros((int(max_y * num_y) + gap, int(average_x * num_x) + 2 * gap), np.uint8)

            _canvas[::] = 255

            y_position = gap

            x_position = gap

            y_max = 0

            for text in areaInfos:

                # set angle 0 if symbol contains the text area is instrumentation

                category = None

                if searchedSymbolList:

                    contains = [symbol for symbol in searchedSymbolList if symbol.contains(text)]

                    if contains:

                        _type = contains[0].getType()

                        category = app_doc_data.getSymbolCategoryByType(_type)

                        if 'Instrumentation' == category:

                            text.setAngle(0)

                # up to here

                angle = text.getAngle()

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

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

                right = left + text.getW()

                bottom = top + text.getH()

                _textImg = imgGray[top:bottom, left:right]

                textImg = _textImg.copy()

                if textImg.shape[0] != text.getH() or textImg.shape[1] != text.getW():

                    continue

                if (angle == 0 and x_position + text.getW() + 2 * line_gap >= _canvas.shape[1]) or (angle != 0 and x_position + text.getH() + 2 * line_gap >= _canvas.shape[1]):

                    x_position = gap

                    y_position = y_position + y_max + gap

                    y_max = 0

                if angle == 0:

                    _canvas[y_position:y_position + text.getH(), x_position:x_position + text.getW()] = textImg[:]

                    cv2.rectangle(_canvas, (x_position - line_gap, y_position - line_gap), (x_position + text.getW() + 2 * line_gap, y_position + text.getH() + 2 * line_gap), 100, 5)

                    x_position = x_position + text.getW() + gap

                    if y_max < text.getH():

                        y_max = text.getH()

                else:

                    textImg = cv2.rotate(textImg, cv2.ROTATE_90_CLOCKWISE)

                    _canvas[y_position:y_position + text.getW(), x_position:x_position + text.getH()] = textImg[:]

                    cv2.rectangle(_canvas, (x_position - line_gap, y_position - line_gap), (x_position + text.getH() + 2 * line_gap, y_position + text.getW() + 2 * line_gap), 100, 5)

                    x_position = x_position + text.getH() + gap

                    if y_max < text.getW():

                        y_max = text.getW()

            indices = np.where(_canvas == [0])

            minx, maxx = min(indices[1]), max(indices[1])

            miny, maxy = min(indices[0]), max(indices[0])

            _canvas = _canvas[0:maxy + gap, 0:]

            cv2.imwrite(os.path.join(app_doc_data.getCurrentProject().getTempPath(), "request_img.png"), _canvas)

            app_web_service = AppWebService()

            img_infos = app_web_service.request_ocr_gcloud(_canvas)

            print(img_infos)

        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)

            if worker is not None:

                worker.displayLog.emit(MessageType.Error, message)

            configs = app_doc_data.getConfigs('Engine', 'Text Area')

                if (configs and int(configs[0].value) is 1) or not configs:

                    text_info_array = np.array_split(tInfoList, App.THREAD_MAX_WORKER

                        if len(tInfoList) > App.THREAD_MAX_WORKER else len(tInfoList))

                    with futures.ThreadPoolExecutor(max_workers=App.THREAD_MAX_WORKER) as pool:

                        future_text = {pool.submit(TextDetector.recognizeTextFromImage, tInfo, imgSrc, offset,

                                            searchedSymbolList, worker, listWidget, maxProgressValue):

                                    tInfo for tInfo in text_info_array}

                        for future in futures.as_completed(future_text):

                            try:

                                data = future.result()

                                if data:

                                    self.textInfoList.extend(data)

                            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)

                                if worker:

                                    worker.displayLog.emit(MessageType.Error, message)

                else:

                    self.get_text_using_gcloud(imgSrc, tInfoList, offset, searchedSymbolList, worker)

def get_gcloud_ocr(img):

    return ['test']

@api.route('/ocr')

@api.expect(text_recognition_parser)

class GcloudTextRecognition(Resource):

    def post(self):

        args = text_recognition_parser.parse_args()

        img_file = request.files['img_file']

@recognition_service.route('/ocr', methods=['POST'])

def gcloud_ocr():

    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_gcloud_ocr(img)

        return jsonify({'text_box': boxes})