Como o usuário ajuda as organizações a integrar as câmeras térmicas - Parte 2

Na parte 1 deste blog, descrevemos como as câmeras térmicas e outras novas tecnologias se tornarão a segunda natureza no mundo pósCOVID. Para esta parte mostraremos um exemplo de configuração.

Usamos um servidor de gerenciamento de vídeo (VMS) com uma plataforma de software que se integra com câmeras de centenas de diferentes fornecedores - incluindo câmeras que suportam análise in-camera e/ou imagem térmica. Os usuários podem configurar eventos dentro da plataforma VMS ou dentro de um mecanismo de regras de uma câmera inteligente. Estes eventos podem ser disparadores de distância de objetos (ou seja, detecção de objetos com uma distância inferior a 1,5 metros entre eles), disparadores de contagem de objetos (ou seja, detecção de um certo número de visitantes dentro de um local) ou disparadores de temperatura (ou seja, detecção de objetos com temperatura acima de 38 graus centígrados).

Qualquer um destes eventos pode acionar uma chamada HTTP para a API do Usuário, permitindo que o Servidor do Usuário altere automaticamente o conteúdo em uma parede de vídeo, em um display individual ou em um grupo de displays. Quão simples é isso de se implantar? São necessárias apenas três etapas:

1. Configurar os eventos no mecanismo analítico incorporado à câmera ou na plataforma VMS baseada em software.
2. Configurar um ouvinte HTTP; para monitorar as chamadas HTTP recebidas vindas de sensores externos.
3. Configurar um comutador de fonte; um conjunto de instruções de software para o API do usuário sobre o conteúdo a ser exibido nas diferentes telas com base no acionador externo. Isto pode ser um texto-aviso, um vídeo de instruções, alimentação de câmera ao vivo, um slide powerpoint ou qualquer outro tipo de conteúdo que o cliente decida exibir.

O resultado final (usando Python) contém 26 linhas de código na aplicação principal: 

se __nome__ == '__main__':

    # Ligar a tomada à porta     
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_address = ('192.168.1.100', 8081)
    print ('starting up on %s port %s' % server_address)
    sock.bind(server_address)
    
    # Ouça as conexões de entrada
    sock.listen(1)    
    enquanto Verdadeiro:
        # Aguarde uma conexão proveniente de um sensor externo
        imprimir ("à espera de uma conexão")
        conexão, client_address = sock.accept()
        tente:
            imprimir ("conexão de", endereço_do_cliente)
            # Receba os dados em pequenos pedaços e os leia
            enquanto Verdadeiro:
                data = connection.recv(512)
                se dados: 
                    # extrair os dados provenientes da chamada HTTP da câmera. 
                    câmera = extrato(dados)
                    # login no Servidor de usuário para recuperar o cookie de autenticação              
                    session_header = login()
                    # determinar o que está tocando atualmente nas telas
                    current_source = is_playing(session_header, 'Shop-Floor')
                    # mudar o conteúdo dos displays para uma fonte pré-configurada (em 
                    # este exemplo uma mensagem de advertência HTML
                    switch_source(session_header,'shop-Floor','HTML Warning')
                    # esperar 5 segundos 
                    tempo.de sono(5)
                    # voltar ao conteúdo que estava jogando originalmente
                    switch_source(session_header, 'Shop-Floor', current_source)
                    #delete_source(session_header,'PIP_Dynamic')    
                    tempo.de sono(5) 
                    intervalo
                senão:
                    imprimir (sys.stderr, 'não mais dados de', client_address)
                    intervalo         
        finalmente:
            # Limpar a conexão
            connection.close()

Portanto, vamos percorrer este projeto passo a passo.

Etapa 1: Configuração dos eventos no cameera ou VMS

Neste exemplo, usamos o mecanismo analítico integrado de nossa plataforma VMS de terceiros que recebe e grava as imagens das câmeras alimentadas por várias câmeras. Os administradores podem configurar diferentes eventos dentro do mecanismo de regras da câmera... Isto pode ser um gatilho de movimento ou um gatilho analítico pelo qual o software VMS analisa as entradas de vídeo e detecta eventos para cada câmera, por exemplo:

1. Uma pessoa que entra em uma área específica da janela gravada.
2. Uma pessoa atravessando uma linha virtual de A -> B (balcão de visitantes)
3. Uma pessoa atravessando uma linha virtual de B -> A (balcão de visitantes)
4. Uma pessoa com temperatura corporal elevada (> 38 graus)

Cada evento tem uma chamada para ação; por exemplo, um PEDIDO HTTP para nosso ouvinte da web no número 192.168.1.100:8081 com conteúdo de mensagens como o nome da câmera e qualificação do evento. Um exemplo de regra de evento é mostrado na figura abaixo.

Passo 2: o ouvinte HTTP

Um servidor web HTTP é um processo simples que está rodando em sua máquina e faz exatamente duas coisas:

1. Ouve as solicitações http recebidas em um endereço de soquete TCP específico (endereço IP e um número de porta)
2. Trata deste pedido e age quando uma mensagem é recebida no endereço do soquete.

In this example; our listener is listening to port 8081 on it's external Ethernet interface on IP address 192.168.1.100. If incoming connections are detected, the data received in the HTTP message is collected and processed under a <call to action> routine. This is the routine of instructing the Userful server what to do. Enter your text here ...

# Ligar a tomada à porta     
    soquete de importação
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_address = ('192.168.1.100', 8081)
    print ('starting up on %s port %s' % server_address)
    sock.bind(server_address) 
    # Ouça as conexões de entrada
    sock.listen(1)   
 
    enquanto Verdadeiro:
        # Aguarde uma conexão proveniente de um sensor externo
        imprimir ("à espera de uma conexão")
        conexão, client_address = sock.accept()
        tente:
            imprimir ("conexão de", endereço_do_cliente)
            # Receba os dados em pequenos pedaços e os leia
            enquanto Verdadeiro:
                data = connection.recv(512)
                se dados: 

                senão:
                    imprimir (sys.stderr, 'não mais dados de', client_address)
                    intervalo         
        finalmente:
            # Limpar a conexão
            connection.close()
  

Antes de mudarmos nossa fonte nas telas, verificamos qual fonte está tocando atualmente em uma zona (ou seja, grupo de telas). Dessa forma, podemos retornar ao conteúdo original uma vez que um evento tenha passado. O código abaixo detectará o nome da fonte que está tocando no momento (ou seja, nome do jogador da sinalização, ou outro). Ao chamar esta função, passamos nosso cookie de autenticação e nome de zona.

  def is_playing (cabeçalho da_sessão, zona):
    get_url = api_url_base + '/api/zonas/byname/' + zona
    resposta = pedidos.get(url=get_url, headers=session_header)
    se resposta.status_code == 200:
        data = response.content
        dict = json.loads(dados)
        sourceID = dict['playSourceId'] 
        sourceName = get_source_info(session_header,sourceID)
        print(fonteName, 'is playing')
    senão:
        imprimir (resposta.status_code)
    fonte de retornoNome

def get_source_info (cabeçalho_de_sessão, sourceID):
    get_url = api_url_base + '/api/sources/' + sourceID
    resposta = pedidos.get(url=get_url, headers=session_header)
    se resposta.status_code == 200:
        data = response.content
        dict = json.loads(dados)
    senão:
        imprimir (resposta.status_code)
    retornar dict['sourceName'] 

  

Agora que determinamos o nome da fonte atualmente em jogo, podemos mudar a fonte para aquela zona:

  def switch_source(session_header, zone_name, source_name):
    post_url = api_url_base + '/api/zonas/byname/' + nome_da_zona + '/switch?destinoNome_da_fonte=' + nome_da_fonte
    resposta = requests.put(url=post_url, headers=session_header)
    valor = Falso
    se resposta.status_code == 200:
        data = response.content
        valor = json.loads(data)["isPlaying"]
        print('Source Switched')
    senão:
        imprimir (resposta.status_code)
    valor de retorno 

  

And that is it…. The <CALL TO ACTION> in our HTTP Listener becomes: (1) retrieve the AUTH cookie for the Userful Server, (2) Detect current source playing in a particular zone, (3) Switch the content on the displays to a 'HTML Warning' message stored on the local server (4) Pause for some time, (5) Switch back to the original source.

  # login no Servidor de usuário para recuperar o cookie de autenticação              
                    session_header = login()
                    # determinar o que está tocando atualmente nas telas
                    fonte = is_playing(session_header, 'Zone-3')
                    # mudar o conteúdo das telas para uma fonte pré-configurada (neste exemplo, uma mensagem de advertência HTML
                    switch_source(session_header,'Zone-3','HTML Warning')
                    # esperar 5 segundos 
                    tempo.de sono(5)
                    # voltar ao conteúdo que estava jogando originalmente
                    switch_source(session_header, 'Zone-3', fonte)
                    #delete_source(session_header,'PIP_Dynamic')    
                    tempo.de sono(5) 
                    intervalo 

  

Podemos expandir este script olhando realmente para os dados que foram recebidos na chamada HTTP vindos da câmera ou da plataforma VMS. Estes dados podem conter informações sobre a câmera e/ou a fonte de disparo e estas informações podem ser usadas para exibir diferentes tipos de conteúdo. Pense na alimentação ao vivo da câmera ou - se a câmera estiver contando pessoas - exibindo quantos clientes estão na loja e quantos clientes adicionais podem entrar na loja.