3dtof_viewer/Viewer/GrpcClient.py

import time
from PyQt5.QtWidgets import QMessageBox
import grpc
import def_pb2 as pb
import def_pb2_grpc as mrpc
import threading
from concurrent.futures import ThreadPoolExecutor
def singleton(cls):
    _instance = {}

    def inner():
        if cls not in _instance:
            _instance[cls] = cls()
        return _instance[cls]
    return inner
@singleton
class GrpcStream(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.threadpool=ThreadPoolExecutor(5)
        self.exit_=False
        self.features_=None
        self.measures_=None
        self.imagesCallBack=None
        self.cloudCallBack=None
        self.MeasureDataCallBack=None
    def SetDataCallBack(self,ImagesCallback,CloudsCallBack,MeasureDataCallback):
        self.imagesCallBack=ImagesCallback
        self.cloudCallBack=CloudsCallBack
        self.MeasureDataCallBack=MeasureDataCallback
    def GrabImage(self,ip,port,id): # id:1-4,其他表示所有
        connectstr='%s:%d'%(ip,port)
        self.channel=grpc.insecure_channel(connectstr)
        self.stub = mrpc.StreamServerStub(self.channel)
        cmd=pb.RequestCmd()
        cmd.Id=id

        resImage=self.stub.GetImage(cmd)
        if self.imagesCallBack is not None:
            self.imagesCallBack(resImage)

    def GrabCloud(self,ip,port,id): # id:1-4,其他表示所有
        connectstr='%s:%d'%(ip,port)
        self.channel=grpc.insecure_channel(connectstr)
        self.stub = mrpc.StreamServerStub(self.channel)
        cmd=pb.RequestCmd()
        cmd.Id=id

        resCloud=self.stub.GetCloud(cmd)
        if self.cloudCallBack is not None:
            self.cloudCallBack(resCloud)
    def OpenDataStream(self,ip,port):
        connectstr='%s:%d'%(ip,port)
        channel=grpc.insecure_channel(connectstr)
        stub = mrpc.StreamServerStub(channel)
        cmd=pb.RequestCmd()
        self.measures_ = stub.OpenMeasureDataStream(cmd)
    def CloseDataStream(self,ip,port):
        connectstr='%s:%d'%(ip,port)
        channel=grpc.insecure_channel(connectstr)
        stub = mrpc.StreamServerStub(channel)
        cmd=pb.RequestCmd()
        stub.CloseMeasureDataStream(cmd)
    def OpenImageStream(self,ip,port):
        connectstr='%s:%d'%(ip,port)
        channel=grpc.insecure_channel(connectstr)
        stub = mrpc.StreamServerStub(channel)
        cmd=pb.RequestCmd()
        self.features_ = stub.OpenImageStream(cmd)

    def CloseImageStream(self,ip,port):
        connectstr='%s:%d'%(ip,port)
        channel=grpc.insecure_channel(connectstr)
        stub = mrpc.StreamServerStub(channel)
        cmd=pb.RequestCmd()
        stub.CloseImageStream(cmd)

    def loopImageStream(self):
        while self.exit_ == False:
            time.sleep(0.001)
            if self.features_ is not None:
                try:
                    for feature in self.features_:  #流式返回的结果
                        if self.imagesCallBack is not None:
                            self.imagesCallBack(feature)
                except Exception as e:
                    self.features_=None

    def loopDataStream(self):
        while self.exit_ == False:
            time.sleep(0.001)
            if self.measures_ is not None:
                try:
                    for measure in self.measures_:
                        if self.MeasureDataCallBack is not None:
                            self.MeasureDataCallBack(measure)
                except Exception as e:
                    if self.MeasureDataCallBack is not None:
                        info=pb.MeasureInfo()
                        info.error=str(e)
                        self.MeasureDataCallBack(info)
                    self.measures_=None
    def run(self):
        self.threadpool.submit(self.loopImageStream)
        self.threadpool.submit(self.loopDataStream)

        print(" close ")
    def close(self):
        self.exit_=True
        self.threadpool.shutdown()
        self.join()