HYTOS

# coding: utf-8

""" This is AppWebService module """

# import urllib.request

# import urllib.parse

import json

import requests

import cv2

import sys, os

import base64

import numpy as np

from AppDocData import AppDocData

from PyQt5 import QtCore, QtGui, QtWidgets

from PyQt5.QtWidgets import *

class AppWebService:

    """ This is AppDatabase class """

    def __init__(self, url=None):

        if not url:

            configs = AppDocData.instance().getConfigs('Engine', 'Address')

            self._url = configs[0].value if configs else None

        else:

            self._url = url

        #self._url = 'http://192.168.0.21:80'

    def test_connection(self):

        try:

            if not self._url:

                return False

            url = self._url + '/Test_Connection'

            response = requests.get(url)

            if response.status_code == 200:

                return True

            else:

                mb = QMessageBox()

                mb.setIcon(QMessageBox.Critical)

                mb.setWindowTitle('Error')

                mb.setText('status code({}) : {}'.format(str(response.status_code), response.text))

                mb.exec_()

                return False

        except Exception as ex:#requests.exceptions.RequestException as ex:

            mb = QMessageBox()

            mb.setIcon(QMessageBox.Critical)

            mb.setWindowTitle('Error')

            mb.setText('{}'.format(ex))

            mb.exec_()

            return False

    def request_symbol_box(self, name, img):

        # send uncroped image

        try:

            if not self.test_connection():

                return []

            data = { 'name':name, 'img':None }

            symbol_box = '/recognition/symbol_box'

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

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

            data['img'] = bts

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

            return response.json()['symbol_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 []

    def request_text_box(self, img):

        # send uncroped image, test code

        try:

            if not self.test_connection():

                return []

            text_box = '/recognition/text_box'

            _, 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 []

    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 []            

    def request_text_box_tile(self, img_infos):

        """ main code """

        try:

            if not self.test_connection():

                return []

            text_box = '/recognition/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)

            return []

    def request_upload_training_data(self, project_name, tiles, xmls) -> bool:

        """ main code """

        try:

            if not self.test_connection():

                return []

            upload_data = '/training/upload_training_data'

            data = {'name': project_name, 'count': len(tiles) + len(xmls), 'tiles': [], 'xmls': []}

            for tile in tiles:

                with open(tile.encode('utf-8'), 'rb') as stream:

                    _bytes = stream.read()

                    numpyArray = np.asarray(bytearray(_bytes), dtype=np.uint8)

                    image = cv2.imdecode(numpyArray, cv2.IMREAD_UNCHANGED)

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

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

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

                    data['tiles'].append((os.path.basename(tile) , bts))

            for xml in xmls:

                with open(xml.encode('utf-8'), 'r') as stream:

                    rects = stream.read()

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

                    data['xmls'].append((os.path.basename(xml), rects))

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

            count = response.json()['count']

            return data['count'] == count

        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 False

    def request_execute_training(self, name, classes, bigs):

        """request symbol training on server"""

        try:

            if not self.test_connection():

                return []

            training_model = '/training/training_model'

            data = {'name': name, 'classes': classes, 'bigs': bigs}

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

            count = response.json()['count']

            return count == 1

        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 False