Skip to content

GitLab

Last edited by Pedro Henrique Tonial Pasinato
Page history

Back End

Home Planejamento Arquitetura Geral Front End Back End Banco de Dados Design do Sistema e Mockups Infraestrutura e Orçamento Fluxo e Versionamento

Bem-vindo à WIKI do Back-end

Esta WIKI foi criada para fornecer uma visão geral e instruções detalhadas sobre o backend do projeto HoorTech. Aqui, você encontrará informações sobre a arquitetura do projeto, as tecnologias e bibliotecas utilizadas, e os passos necessários para configurar e rodar o ambiente de desenvolvimento.

Este documento é uma referência completa para desenvolvedores que trabalham no projeto, facilitando a compreensão da estrutura e dos componentes utilizados. Siga os tópicos abaixo para obter informações específicas:

Use esta WIKI como um recurso de apoio para colaborar e desenvolver no Back-end!

Arquitetura Base

Também disponível em: Arquitetura

hoortech_backend/
├── app/                            # Diretório principal da aplicação
│   ├── handtracking/               # Código relacionado ao rastreamento de mãos
│   │   └── handtracking.py         # Script principal de rastreamento
│   ├── model/                      # Modelos de machine learning
│   │   ├── modelo_alphabet.keras   # Modelo de reconhecimento de alfabeto
│   │   └── modelo_vowel.keras      # Modelo de reconhecimento de vogais
│   ├── predictor/                  # Módulos de predição
│   │   ├── predictoralphabet.py    # Predição para alfabeto
│   │   └── predictorvowel.py       # Predição para vogais
│   └── templates/                  # Templates HTML (se aplicável)
├── test/                           # Diretório de testes
│   ├── integration_testing.py      # Testes de integração
│   ├── latra-a-base64.txt          # Arquivo de teste em Base64
│   ├── letra-a.jpg                 # Imagem de teste
│   ├── __init__.py                 # Inicialização do pacote de teste
│   └── create_mock_model.py        # Criação de modelos mock
├── routes.py                       # Definição das rotas da API
├── socket_server.py                # Servidor de WebSocket para comunicação em tempo real
├── instance/                       # Configurações específicas de instância
│   └── config.py                   # Arquivo de configuração do backend
├── models/                         # Diretório para modelos de machine learning
│   └── hand_landmarker.task        # Modelo de marcação de mão
├── .gitignore                      # Arquivos a serem ignorados pelo Git
├── Dockerfile                      # Arquivo de configuração para Docker
├── generate_base64.py              # Script para gerar dados em Base64
├── README.md                       # Instruções do projeto
├── requirements.txt                # Dependências do projeto
└── run.py                          # Script principal para execução do backend

Tecnologias Utilizadas

  • Python: A linguagem de programação usada para desenvolver o backend, escolhida pela sua simplicidade e poderosas bibliotecas de machine learning e análise de dados.

  • Docker: Utilizado para encapsular o backend com todas as dependências, garantindo a consistência do ambiente de execução em diferentes sistemas.

Bibliotecas Utilizadas

  • Flask (v3.0.3): Um framework web leve para Python que facilita a criação de APIs RESTful. Usado para definir rotas e endpoints da aplicação backend.

  • Flask-SocketIO (v5.3.3): Extensão para Flask que permite comunicação em tempo real usando WebSockets, especialmente útil para funcionalidades que necessitam de atualizações instantâneas.

  • Flask-Cors (v3.0.10): Extensão para Flask que permite a configuração de CORS (Cross-Origin Resource Sharing) para o backend, permitindo que recursos sejam acessados a partir de domínios diferentes.

  • gevent (v22.10.2): Biblioteca que fornece uma implementação eficiente de multi-threading em Python, usada para suportar operações assíncronas no servidor Flask.

  • gevent-websocket (v0.10.1): Extensão para gevent que permite o uso de WebSockets, integrando comunicação em tempo real ao backend.

  • opencv-python (v4.10.0.84): Biblioteca poderosa para visão computacional e processamento de imagem. Utilizada para manipulação e análise de imagens, especialmente para extrair landmarks da mão.

  • dnspython (v2.2.1): Biblioteca para manipulação de DNS em Python, usada para operações relacionadas a domínios e servidores de rede.

  • numpy (v1.26.4): Biblioteca para cálculos numéricos de alta performance, frequentemente usada para manipulação de arrays e operações matemáticas.

  • mediapipe (v0.10.14): Biblioteca do Google que fornece modelos prontos para detecção de landmarks (pontos de referência) em imagens, como mãos e rostos. É utilizada para extrair landmarks da mão na aplicação.

  • tensorflow (v2.16.1): Uma biblioteca de machine learning e deep learning que facilita a criação e treinamento de modelos de IA. Usada para carregar e executar o modelo de reconhecimento de letras no backend.

Rodando o Back-end pela Primeira Vez

Siga os passos abaixo para configurar e iniciar o ambiente de desenvolvimento do backend.

Passo a Passo para Execução

Clone o Repositório

Clone o repositório do backend para a sua máquina local e navegue até o diretório do projeto:

git clone https://github.com/seu_usuario/hoortech_backend.git
cd hoortech_backend

Crie o Ambiente Virtual

Para isolar o ambiente de desenvolvimento, crie e ative um ambiente virtual:

  • Windows
python -m venv venv
.\venv\Scripts\activate
  • Linux
python3 -m venv venv
source venv/bin/activate

Instale as Dependências

As dependências estão todas listadas no script requierements.txt

pip install --no-cache-dir -r requirements.txt

Execute o Servidor

Para iniciar o backend, execute o servidor WebSocket com o comando:

python -m app.socket_server

Funcionamento da Aplicação

O backend do projeto HoorTech utiliza Flask para criar um servidor que estará disponível na porta 5003, pronto para receber requisições POST na rota /predict. Esse servidor recebe uma string Base64 de uma imagem no corpo da requisição e retorna, em formato JSON, a letra prevista pelo modelo de IA.

Descrição das Classes

1. HandTracker

  • Local: app/handtracking/handtracking.py
  • Descrição: A classe HandTracker é responsável por processar imagens codificadas em Base64 e extrair landmarks (pontos de referência) da mão. Esses landmarks são posteriormente utilizados para a predição das letras.

Métodos Principais:

  • process_frame(image_base64: str) -> list: Recebe a imagem em Base64, decodifica e utiliza um detector de landmarks para retornar os pontos de referência da mão.

  • decode_image(image_base64: str) -> np.array: Decodifica a string Base64 para uma imagem utilizável.

2. LetterPredictor

  • Local: app/predictor/predictor.py
  • Descrição: A classe LetterPredictor é responsável por carregar o modelo de IA e utilizar landmarks como entrada para prever a letra correspondente.

Métodos Principais:

  • __init__(model_path: str): Inicializa a classe e carrega o modelo salvo no caminho especificado.

  • predict_letter(landmarks: list) -> str: Recebe uma lista de landmarks e retorna a letra prevista pelo modelo.

3. Gerador de Modelo Mock

  • Local: app/test/create_mock_model.py
  • Descrição: Esse script gera um modelo fictício e salva em formato HDF5, permitindo testes de ponta a ponta do sistema sem necessidade do modelo final treinado.

Função Principal:

  • create_mock_model(): Cria e salva um modelo mock que futuramente será substituído pelo modelo treinado.

4. Servidor SocketIO

  • Local: app/socket_server.py
  • Descrição: O servidor é implementado com Flask e Flask-SocketIO, oferecendo uma API para receber imagens codificadas em Base64, processá-las e retornar a letra prevista com base nos landmarks extraídos.

Rota Implementada

  • /predict (Método: POST): Recebe uma imagem em Base64 e retorna a letra prevista com base nos landmarks extraídos pela classe HandTracker e processados pelo modelo de IA na classe LetterPredictor.