rede neural convolucional aplicada a vis ao...
TRANSCRIPT
UNIVERSIDADE TECNOLOGICA FEDERAL DO PARANADAELN - DEPARTAMENTO ACADEMICO DE ELETRONICA
CURSO DE ENGENHARIA ELETRONICA
ANDRE LUIZ BERTONI
DIEGO VIEIRA DE SOUZA FEDER
REDE NEURAL CONVOLUCIONAL APLICADA A VISAO
COMPUTACIONAL PARA DETECCAO DE INCENDIO
TRABALHO DE CONCLUSAO DE CURSO
CURITIBA2018
ANDRE LUIZ BERTONI
DIEGO VIEIRA DE SOUZA FEDER
REDE NEURAL CONVOLUCIONAL APLICADA A VISAO
COMPUTACIONAL PARA DETECCAO DE INCENDIO
Trabalho de Conclusao de Curso apresentado ao Curso deEngenharia Eletronica da Universidade Tecnologica Federaldo Parana, como requisito parcial para a obtencao do tıtulode Bacharel.
Orientador: Prof. Daniel Rossato de OliveiraUniversidade Tecnologica Federal do Parana
CURITIBA2018
ANDRÉ LUIZ BERTONI
DIEGO VIEIRA DE SOUZA FEDER
REDE NEURAL CONVOLUCIONAL APLICADA À VISÃO
COMPUTACIONAL PARA DETECÇÃO DE INCÊNDIO
Este Trabalho de Conclusão de Curso de Graduação foi apresentado como requisito
parcial para obtenção do título de Engenheiro Eletrônico, do curso de Engenharia
Eletrônica do Departamento Acadêmico de Eletrônica (DAELN) outorgado pela
Universidade Tecnológica Federal do Paraná (UTFPR). Os alunos foram arguidos
pela Banca Examinadora composta pelos professores abaixo assinados. Após
deliberação, a Banca Examinadora considerou o trabalho aprovado.
Curitiba, 07 de dezembro de 2018.
____________________________________ Prof. Dr. Robinson Vida Noronha
Coordenador de Curso Engenharia Eletrônica
____________________________________ Profª. Drª. Carmen Caroline Rasera
Responsável pelos Trabalhos de Conclusão de Curso de Engenharia Eletrônica do DAELN
BANCA EXAMINADORA
______________________________________
Prof. Me. Daniel Rossato de Oliveira
Universidade Tecnológica Federal do Paraná
Orientador
_____________________________________
Prof. Dr. Robinson Vida Noronha
Universidade Tecnológica Federal do Paraná
_____________________________________
Prof. Me. Luiz Fernando Copetti
Universidade Tecnológica Federal do Paraná
A folha de aprovação assinada encontra-se na Coordenação do Curso de Engenharia Eletrônica.
AGRADECIMENTOS
Agradecemos as nossas famılias e amigos por todo amor e apoio incondicional fornecido,
ate nos momentos de maior dificuldade.
Agradecemos a todos os professores que nos ensinaram durante essa trajetoria e
guiaram nossos aprendizados para a conclusao dessa etapa.
Agradecemos tambem a Universidade Tecnologica Federal do Parana, seu corpo
docente, direcao e administracao por toda a estrutura providenciada ao longo desse perıodo.
Eu basicamente me sinto como uma arvoreenquanto outras pessoas sao apenas galhos.(WEST, Kanye, 2010)
RESUMO
BERTONI, Andre L.; FEDER, Diego V. de S.;. Rede Neural Convolucional Aplicada a VisaoComputacional para Deteccao de Incendio. 2018. 80 f. Trabalho de Conclusao de Curso – Cursode Engenharia Eletronica, Universidade Tecnologica Federal do Parana. Curitiba, 2018.
Para este projeto foi desenvolvido um sistema de alerta de incendio que utiliza: uma camera,um Raspberry Pi, um sistema de visao computacional e um aplicativo android.Utilizamos o Raspberry Pi como bloco principal. E ele que esta conectado diretamente a camerae processa a imagem recebida com um algoritmo inteligente.O algoritmo do sistema consiste em tres partes: filtragem de cores, deteccao de movimento eauto-aprendizagem. Avaliando assim se existe um princıpio de incendio occorendo.O aplicativo android foi desenvolvido com uma interface user-friendly, e tem como funcoesenviar avisos ao usuario e garantir acesso a camera do sistema em tempo real.
Palavras-chave: Seguranca, Alarme, Incendio, Visao Computacional, Processamento de Ima-gens, Android
ABSTRACT
BERTONI, Andre L.; FEDER, Diego V. de S.;. Convolutional Neural Network Based FireDetection through Computer Vision. 2018. 80 f. Trabalho de Conclusao de Curso – Curso deEngenharia Eletronica, Universidade Tecnologica Federal do Parana. Curitiba, 2018.
In this project, we developed a fire alarm system consisting in: a camera, a Raspberry Pi, acomputer vision system and an android application.The Raspberry Pi is considered the leading piece. It is connected directly to a digital camerathat processes the received image with an intelligent algorithm.The system algorithm consists of three parts: color filtering, motion detection and self-learning.Evaluating then, if there is a fire principle occurring.The Android application was developed with a user-friendly interface, with the duty to sendwarnings to the user and provide access to the system camera in real time.
Keywords: Security, Fire, Computer vision, Image processing, Android
LISTA DE FIGURAS
Figura 1 – Diagrama funcional da utilizacao de um sistema embarcado. . . . . . . . . 14
Figura 2 – Funcionamento basico de uma camera digital. . . . . . . . . . . . . . . . . 15
Figura 3 – Esquematico informacao e decisao. . . . . . . . . . . . . . . . . . . . . . 16
Figura 4 – Representacao entrada e saıda - rede neural artificial. . . . . . . . . . . . . 18
Figura 5 – Pilha de software - TensorFlow. . . . . . . . . . . . . . . . . . . . . . . . 20
Figura 6 – Representacao de um modelo LeNet. . . . . . . . . . . . . . . . . . . . . 21
Figura 7 – Ambiente de Desenvolvimento Android Studio. . . . . . . . . . . . . . . . 22
Figura 8 – A pilha de software do Android. . . . . . . . . . . . . . . . . . . . . . . . 23
Figura 9 – Ciclo de vida da atividade. . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Figura 10 – Representacao de comunicacao por sockets entre servidor e cliente. . . . . 26
Figura 11 – Raspberry Pi 3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Figura 12 – Camera USB (Logitech C270) utilizada. . . . . . . . . . . . . . . . . . . . 29
Figura 13 – Busca google imagens - velas acesas. . . . . . . . . . . . . . . . . . . . . 31
Figura 14 – Codigo para salvar as URLs das imagens exibidas. . . . . . . . . . . . . . . 31
Figura 15 – Estrutura dos diretorios contendo as imagens do dataset. . . . . . . . . . . 32
Figura 16 – Codigo Python para download das imagens. . . . . . . . . . . . . . . . . . 32
Figura 17 – Codigo responsavel pela verificacao da integridade das imagens baixadas. . 33
Figura 18 – Download das imagens pelo terminal Anaconda. . . . . . . . . . . . . . . 33
Figura 19 – Codigo responsavel pela construcao do classificador de imagens Keras. . . . 34
Figura 20 – Bibliotecas utilizadas no arquivo train network.py. . . . . . . . . . . . . . . 35
Figura 21 – Codigo responsavel pela entrada dos argumentos. . . . . . . . . . . . . . . 35
Figura 22 – Codigo de inicializacao das variaveis de treinamento, listas e diretorios. . . 36
Figura 23 – Codigo para pre-processamento das imagens. . . . . . . . . . . . . . . . . 36
Figura 24 – Estrutura do diretorio do dataset. . . . . . . . . . . . . . . . . . . . . . . 37
Figura 25 – Codigo para alterar escala das imagens e criar splits. . . . . . . . . . . . . 37
Figura 26 – Criacao de dados atraves da ImageDataGenerator(). . . . . . . . . . . . . 38
Figura 27 – Codigo para inicializar, treinar e salvar modelo de rede. . . . . . . . . . . . 38
Figura 28 – Rede neural com 26 epochs e precisao de 96,45%. . . . . . . . . . . . . . 39
Figura 29 – Treinamento de redes neurais - precisao e perdas. . . . . . . . . . . . . . . 39
Figura 30 – Diferentes estados do aplicativo TCC - Fire Alarm. . . . . . . . . . . . . . 40
Figura 31 – Notificacao gerada pela troca ao estado DANGER! . . . . . . . . . . . . . 41
Figura 32 – Notificacao gerada pela troca ao estado WARNING. . . . . . . . . . . . . 41
Figura 33 – Visualizacao da CameraActivity. . . . . . . . . . . . . . . . . . . . . . . . 42
Figura 34 – Fluxograma simplificado da MainActivity. . . . . . . . . . . . . . . . . . . 42
Figura 35 – Comandos utilizados para instalacao do TensorFlow no Raspberry Pi. . . . 43
Figura 36 – Comandos utilizados para instalacao das bibliotecas HDF5 e h5py no Rasp-
berry Pi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Figura 37 – Comandos utilizados para instalacao das bibliotecas HDF5 e h5py no Rasp-
berry Pi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Figura 38 – Comandos utilizados para instalacao das bibliotecas HDF5 e h5py no Rasp-
berry Pi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Figura 39 – Comandos utilizados para importar as bibliotecas ja compiladas no Raspberry
Pi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Figura 40 – Declara e importa o modelo de rede neural a ser utilizado pelo Raspberry Pi. 45
Figura 41 – Codigo de inicializacao e parametrizacao do sistema de deteccao de incendio. 45
Figura 42 – Codigo de carregamento do modelo de rede e inicializacao da camera. . . . 46
Figura 43 – Codigo de captura de frames da stream de vıdeo. . . . . . . . . . . . . . . 46
Figura 44 – Codigo para pre-processamento e envio dos frames para a rede neural. . . . 47
Figura 45 – Codigo de classificacao das imagens. . . . . . . . . . . . . . . . . . . . . . 47
Figura 46 – Codigo de acionamento do alarme. . . . . . . . . . . . . . . . . . . . . . 47
Figura 47 – Reinicializacao da contagem de frames consecutivos. . . . . . . . . . . . . 47
Figura 48 – Construcao do frame para exibicao na tela. . . . . . . . . . . . . . . . . . 48
Figura 49 – Deteccao de fogo na imagem com 93,88% de confianca. . . . . . . . . . . 48
Figura 50 – Codigo responsavel pelo envio de novos eventos. . . . . . . . . . . . . . . 49
Figura 51 – Codigo responsavel pela visualizacao do vıdeo. . . . . . . . . . . . . . . . 50
Figura 52 – Fluxograma do funcionamento do codigo. . . . . . . . . . . . . . . . . . . 50
Figura 53 – Captura de tela durante teste da rede neural. . . . . . . . . . . . . . . . . 51
Figura 54 – Captura de tela durante teste da rede neural. . . . . . . . . . . . . . . . . 52
Figura 55 – Captura de tela durante teste da rede neural. . . . . . . . . . . . . . . . . 52
Figura 56 – Teste em luminosidade, luz - antes do treinamento. . . . . . . . . . . . . . 53
Figura 57 – Teste em luminosidade, luz - apos devido treinamento. . . . . . . . . . . . 54
Figura 58 – Captura de tela durante teste de tempo real. . . . . . . . . . . . . . . . . 55
Figura 59 – Captura de tela do aplicativo apos recebimento de notificacao. . . . . . . . 55
LISTA DE ABREVIATURAS E SIGLAS
API Application Program Interface
ART Android Runtime
CNN Convolutional Neural Network
DNN Deep Neural Network
FPS Frames Per Second
HAL Hardware Abstraction Layer
ID Identification
IP Internet Protocol
RAM Random Access Memory
RGB Red Green Blue
SMS Short Message Service
SSD Single Shot Detector
SSH Secure Shell
TCP Transmission Control Protocol
UI User Interface
USB Universal Serial Bus
Wi-Fi Wireless Fidelity
XML eXtensible Markup Language
SUMARIO
1 – INTRODUCAO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.1 OBJETIVOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.1.1 Objetivo geral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.1.2 Objetivos especıficos . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.2 JUSTIFICATIVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2 – FUNDAMENTACAO TEORICA . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.1 SISTEMAS EMBARCADOS . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2 CAMERAS DE VIDEO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3 VISAO COMPUTACIONAL . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3.1 Aquisicao de imagens . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3.2 Processamento de imagem . . . . . . . . . . . . . . . . . . . . . . . 16
2.3.3 Analise e compreensao de imagens . . . . . . . . . . . . . . . . . . 16
2.3.4 OpenCV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4 APRENDIZAGEM DE MAQUINA . . . . . . . . . . . . . . . . . . . . . . . 17
2.4.1 Metodos de aprendizagem de maquina . . . . . . . . . . . . . . . . 17
2.4.2 Redes neurais artificiais . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4.3 Deep Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.4.4 TensorFlow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.4.5 Keras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.4.6 LeNet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.5 SISTEMA ANDROID . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.5.1 Android Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.5.2 Arquitetura Android . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.5.3 Atividades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.5.4 Android Manifest . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.6 SOCKETS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3 – PROCEDIMENTOS METODOLOGICOS . . . . . . . . . . . . . . . . . . 28
3.1 RASPBERRY PI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.2 CAMERA USB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.3 REDE NEURAL CONVOLUCIONAL . . . . . . . . . . . . . . . . . . . . . 30
3.3.1 Criando um dataset . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.3.2 Modelando a rede neural . . . . . . . . . . . . . . . . . . . . . . . 33
3.3.3 Treinando a rede neural . . . . . . . . . . . . . . . . . . . . . . . . 34
3.4 APLICATIVO ANDROID . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.5 MODELO CLIENTE-SERVIDOR . . . . . . . . . . . . . . . . . . . . . . . 43
3.6 ALGORITMOS E CODIGOS . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.6.1 Implementacao no Raspberry Pi . . . . . . . . . . . . . . . . . . . . 43
3.6.2 Inicializacao do sistema . . . . . . . . . . . . . . . . . . . . . . . . 44
3.6.3 Obtencao do frame da camera e classificacao das imagens . . . . . . 46
3.6.4 Envio de evento e recebimento de notificacao . . . . . . . . . . . . . 48
3.6.5 Transmissao e visualizacao de vıdeo . . . . . . . . . . . . . . . . . . 49
3.6.6 Fluxograma do funcionamento geral do sistema . . . . . . . . . . . . 50
4 – APRESENTACAO E ANALISE DE RESULTADOS . . . . . . . . . . . . . . 51
4.1 ANALISE E RESULTADOS DA REDE NEURAL . . . . . . . . . . . . . . . 51
4.2 ANALISE E RESULTADOS DO SISTEMA EM TEMPO REAL . . . . . . . 54
5 – CONCLUSAO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Referencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Apendices 58
APENDICE A–Codigo para download das imagens do dataset . . . . . . . . 59
APENDICE B–Codigo da arquitetura da rede LeNet . . . . . . . . . . . . . . 61
APENDICE C–Codigo para treinamento da rede neural . . . . . . . . . . . 62
APENDICE D–Codigo para teste da rede neural . . . . . . . . . . . . . . . 65
APENDICE E – Codigo de deteccao de incendio no sistema embarcado . . . . 67
APENDICE F – Codigo das activities do aplicativo Android . . . . . . . . . . 70
APENDICE G–Codigo dos layouts do aplicativo Android . . . . . . . . . . . 76
APENDICE H–Codigo do Android Manifest . . . . . . . . . . . . . . . . . . 79
APENDICE I – Codigo para comunicacao do Raspberry Pi ao aplicativo Android 80
11
1 INTRODUCAO
O homem sempre teve fascınio pelo fogo e durante milhares de anos foi aprimorando
as tecnicas de domınio e controle da ignicao. Esse domınio do fogo permitiu grande avanco da
sociedade: com um melhor preparo de alimentos, protecao contra o frio, iluminacao, rapida
locomocao, etc. No entanto, o risco atrelado ao fogo e alto, e muitos dos incendios marcados
em nossa historia originou grande perda de vidas e propriedades. Alem disso, devido aos
impactos sociais, ambientais e economicos que um incendio pode causar, as seguradoras e os
equipamentos de seguranca impoe um alto custo no mercado.
De acordo com a Secretaria Nacional de Seguranca Publica (Senasp) do Ministerio da
Justica, o Brasil tem uma media anual de 267 mil incendios (incluindo ocorrencias florestais e
residenciais). Outros dados confirmam que em 2011 o Brasil alcancou a posicacao de terceiro
lugar no ranking mundial de mortes por incendio ou exposicao a fumaca. Esta constatacao se
baseou no cruzamento de dados informados pelo Sistema Unico de Saude (SUS) com uma
pesquisa realizada pela Geneva Association (SPRINKLER, 2015).
Esse quadro, ainda existente em nosso paıs, e resultado da falta de informacao e da nao
utilizacao de equipamentos de seguranca. Muitas empresas ainda consideram incendios como
uma questao de sorte ou azar. E poucos sao os que se preparam e se importam com os cinco
princıpios de seguranca basica (prevencao, protecao, combate, meios de escape, gerenciamento).
Recentemente foi possıvel atentar a expressividade de um incendio pelo importuno
acontecimento na cidade de Paradise - California. Situada a nordeste do Vale do Sacramento,
ja e constatado como o maior incendio florestal da historia do estado, estima-se que um total
de 13.000 casas foram destruıdas e os prejuızos das propriedades podem se aproximar de 4
bilhoes de dolares. O que traz a tona a importancia e o cuidado que deve ser levado diante
desses desastres.
Com o objetivo de implementar medidas de protecao e combate ao incendio, este
projeto visa desenvolver uma solucao fidedigna, barata e eficaz. Este documento inicia apontando
o aspecto geral do sistema em questao e salientando os requisitos do projeto. Posteriormente
indica a metodologia adotada, especificando cada ferramenta utilizada no desenvolvimento.
Por fim, informa todo o processo de implementacao de hardware, software, da implantacao do
sistema em detalhes e traz uma analise de resultados juntamente a conclusao do trabalho.
Capıtulo 1. INTRODUCAO 12
1.1 OBJETIVOS
1.1.1 Objetivo geral
O objetivo geral deste projeto e desenvolver um sistema protecional residencial, com
foco na deteccao de incendio atraves de processamento de imagens utilizando uma rede neural
convolucional, uma camera e um aplicativo movel para notificacao e visualizacao do estado de
risco existente.
Para o funcionamento do sistema, exige-se uma placa de desenvolvimento Raspberry
Pi, uma camera USB e um smartphone hospedado com o sistema operacional Android.
1.1.2 Objetivos especıficos
E preciso garantir que os requisitos sejam precisos, comprometendo que as expectativas
de resultado final sejam atendidas. A seguir sao listados todos os objetivos especıficos do
projeto:
• Aprendizagem de maquina: Sera implementado um algoritmo inteligente para treinamento
do sistema. Sera utilizado uma Rede Neural Convolucional (CNN) para identificar fogo
em vıdeos;
• Comunicacao: O aplicativo sera dinamico. Ele ira interagir com o usuario instantaneamente
de acordo com as entradas que recebe. Deve-se utilizar sockets para a comunicacao
cliente-servidor entre o raspberry pi e o smartphone.
• Notificacao: O usuario deve receber notificacoes sempre que um evento acontecer.
Portanto, o aplicativo deve continuar sua execucao em segundo plano, sem sofrer
interrupcoes.
• Visualizacao: O usuario podera acessar o sistema sempre que ligado e com conexao a
internet. A conexao deve permitir a visualizacao da camera em tempo real, util para
averiguar a condicao do sistema.
• Usabilidade: A aplicacao deve ser facil de usar e intuitiva. O aplicativo deve ter uma
interface amigavel, simples e clara.
• Desempenho: O software embarcado no raspberry pi nao pode sobrecarregar o sistema
mesmo que processe uma alta quantidade de dados (vıdeo) em tempo real. O sistema
deve responder rapidamente as solicitacoes do usuario.
• Memoria: O aplicativo nao deve ocupar muito espaco, se adequando aos criterios do
Android.
1.2 JUSTIFICATIVA
Tanto em propriedades comerciais quanto residenciais, a importancia de se ter um
sistema de alarme ou de atuacao e combate a incendios nao pode ser subestimada. Esses
Capıtulo 1. INTRODUCAO 13
sistemas salvam vidas e nao pode haver incentivo maior do que garantir que as pessoas que
entram em um predio, seja comercial ou residencial, estejam totalmente protegidas.
Com a popularidade gradual da instalacao de sistemas de vigilancia visual e sistemas
protecionais nas ultimas decadas, a deteccao incendio tornou-se uma questao muito importante,
pois esta intimamente relacionada a seguranca e a propriedade das pessoas. Atualmente, as
tecnicas de deteccao de chama usadas com mais frequencia sao geralmente baseadas em
amostragem de partıculas, amostragem de temperatura e testes de transparencia de ar, alem
dos tradicionais detectores de chamas ultravioleta e infravermelho (ARRUE; DIOS, 2000).
No entanto, a maioria desses detectores sofre de alguns problemas graves. Eles exigem
uma proximidade com a chama. Alem disso, nem sempre sao confiaveis, porque boa parte deles
nao detectam a propria combustao, ao inves disso, detectam os subprodutos da combustao, que
podem ser produzidos de outras maneiras. Portanto, eles geralmente resultam em uma maior
incidencia de alarmes falsos. No sistema em apreco a deteccao e feita atraves do reconhecimento
visual do fogo, permitindo um tempo de resposta menor e mais fidedigno.
14
2 FUNDAMENTACAO TEORICA
Este capıtulo tem como finalidade explicar os princıpios teoricos e tecnicos que foram
utilizados ao desenvolver o projeto. Para tal, foram julgados como necessarios os seguintes
temas: Sistemas embarcados (Secao 2.1), Cameras de vıdeo (Secao 2.2), Visao computacional
(Secao 2.3), Aprendizagem de maquina (Secao 2.4), Sistema Android (Secao 2.5), Sockets
(Secao 2.6).
2.1 SISTEMAS EMBARCADOS
Um sistema embarcado pode ser definido como um sistema computacional com um
proposito de aplicacao unico, ao contrario de um computador pessoal convencional, o qual
pode ser chamado de sistema computacional de proposito generalizado. O sistema embarcado
normalmente fara parte de outro sistema maior, servindo como uma especie de “cerebro” do
equipamento em questao, atuando como controlador de eventos com sensores e atuadores e
das interfaces com sistemas externos e com usuarios. Exemplos de equipamentos que utilizam
sistemas embarcados: veıculos, equipamentos medicos, equipamentos agrıcolas, equipamentos
militares, etc (RENAUX, 2016). Na figura 1 e possıvel observar um diagrama funcional de um
sistema embarcado.
Figura 1 – Diagrama funcional da utilizacao de um sistema embarcado.
Fonte: Renaux (2016)
Capıtulo 2. FUNDAMENTACAO TEORICA 15
2.2 CAMERAS DE VIDEO
Uma camera de vıdeo digital e um dispositivo que captura informacoes de imagem de
ambientes ao vivo, codificando-as em dados que podem ser decodificados ou transcodificados
em mıdia visual eletronica. Uma camera digital tıpica consiste em uma lente, sensor de imagem,
mıdia de armazenamento e varios outros recursos que tambem podem ser encontrados em
outras cameras (como abertura escalonavel, filtros e flash)(TECHOPEDIA, 2018) .
Uma camera digital usa uma variedade de fotossensores para registrar o padrao de
entrada de luz. Cada sensor retorna uma corrente eletrica quando e atingido pela luz recebida.
Como a quantidade de corrente que e retornada varia com a quantidade de luz, os circuitos
eletronicos da camera digital podem combinar os diferentes nıveis de corrente em um padrao
composto de dados que representa a luz recebida - em outras palavras, uma imagem na forma
de um arquivo binario. A figura 2 ilustra isso.
Figura 2 – Funcionamento basico de uma camera digital.
Fonte: Website Dummies - How Does a Digital Camera Work (2018)
2.3 VISAO COMPUTACIONAL
Utilizamos nossos olhos e cerebro para ver e interpretar visualmente o mundo ao nosso
redor. O objetivo da visao computacional e dar essa capacidade de ver a uma maquina. A
visao computacional extrai e analisa automaticamente informacoes uteis de uma imagem ou
sequencia de imagens. Um computador tambem pode ver coisas que nao podemos, com varios
canais de percepcao, o que significa que as maquinas tem mais recursos visuais do que nos
Capıtulo 2. FUNDAMENTACAO TEORICA 16
(SZELISKI, 2010). Devido a esse poder de ver sobre-humano, existe um grande potencial para
que a visao computacional tenha um impacto profundo em nossas vidas (REED, 2017).
A visao computacional emula a visao humana usando imagens digitais atraves de tres
componentes principais de processamento, executados um apos o outro, vide figura 3:
1. Aquisicao de imagem;
2. Processamento de imagem;
3. Analise e compreensao de imagens;
Como nossa compreensao visual humana do mundo e refletida em nossa capacidade
de tomar decisoes atraves do que vemos, fornecer tal entendimento visual aos computadores e
o princıpal objetivo da visao computacional.
Figura 3 – Esquematico informacao e decisao.
Fonte: Autoria propria (2018)
2.3.1 Aquisicao de imagens
A aquisicao de imagens e o processo de traduzir o mundo analogico ao nosso redor
em dados binarios compostos de zeros e uns, interpretados como imagens digitais. Na maioria
das vezes, os dados brutos adquiridos nessa etapa precisam ser pos-processados para serem
mais eficientes.
2.3.2 Processamento de imagem
O segundo componente da visao computacional e o processamento de imagens de
baixo nıvel. Algoritmos sao aplicados aos dados binarios adquiridos na primeira etapa para inferir
informacoes de baixo nıvel em partes da imagem. Esse tipo de informacao e caracterizado por
bordas de imagem, recursos de ponto ou segmentos, por exemplo. Eles sao todos os elementos
geometricos basicos que constroem objetos em imagens. Essa segunda etapa geralmente envolve
algoritmos e tecnicas avancadas de matematica aplicada (TARTU, 2015).
2.3.3 Analise e compreensao de imagens
A ultima etapa do pipeline de visao computacional e a analise dos dados, que permitira
a tomada de decisao. Algoritmos de alto nıvel sao aplicados, usando os dados da imagem e as
Capıtulo 2. FUNDAMENTACAO TEORICA 17
informacoes de baixo nıvel calculadas nas etapas anteriores.
2.3.4 OpenCV
OpenCV e uma biblioteca open-source multiplataforma que inclui centenas de algorit-
mos de visao computacional, com interfaces para C, C++, Python e Java. A biblioteca possui
uma estrutura modular, contendo modulos especıficos para processamento digital de imagens,
processamento de vıdeos, deteccao de objetos, etc.
2.4 APRENDIZAGEM DE MAQUINA
A aprendizagem de maquina (machine learning) e apenas uma das muitas ramificacoes
do estudo da inteligencia artificial. E um termo generico que se referencia a qualquer algoritmo
que permita identificar padroes em dados fornecidos, construir modelos e fazer predicoes sem
estar explicitamente programado para tal. Essas caracterısticas sao de extrema importancia em
cenarios onde as tarefas a serem executadas nao sao claras ou nao haja uma relacao de entrada
e saıda tao concisa. Algoritmos de aprendizagem de maquina se sobressaem em ambientes que
variam com o tempo e que requerem readaptacao constante. Atualmente o aprendizado de
maquina esta presente em diversas areas e aplicacoes, dentre elas o reconhecimento de voz, a
visao computacional, predicoes financeiras e auxılio nos diagnosticos medicos (BISHOP, 2006).
2.4.1 Metodos de aprendizagem de maquina
Os algoritmos de aprendizado de maquina geralmente sao classificados como supervi-
sionados ou nao supervisionados.
Algoritmos de aprendizado de maquina supervisionados podem aplicar o que foi
aprendido no passado a novos dados usando exemplos rotulados para prever eventos futuros.
A partir da analise de um conjunto de dados de treinamento conhecido, o algoritmo de
aprendizado produz uma funcao inferida para fazer previsoes sobre os valores de saıda. O
sistema e capaz interpretar qualquer nova entrada apos treinamento suficiente. O algoritmo de
aprendizado tambem pode comparar sua saıda com a saıda correta e planejada e encontrar erros
para modificar o modelo de acordo. Em contraste, os algoritmos de aprendizado de maquina
nao supervisionados sao usados quando as informacoes utilizadas para treinamento nao sao
classificadas nem rotuladas. A aprendizagem nao supervisionada estuda como os sistemas
podem inferir uma funcao para descrever uma estrutura oculta a partir de dados nao rotulados.
O sistema nao calcula a saıda correta, mas explora os dados e pode extrair inferencias de
conjuntos de dados para descrever estruturas ocultas de dados nao rotulados.
2.4.2 Redes neurais artificiais
As redes neurais artificiais sao uma das principais ferramentas utilizadas no aprendizado
de maquinas. Como a parte“neural”de seu nome sugere, eles sao sistemas inspirados no cerebro
Capıtulo 2. FUNDAMENTACAO TEORICA 18
que se destinam a replicar a maneira como os humanos aprendem. As redes neurais consistem
em camadas de entrada e saıda, bem como (na maioria dos casos) uma camada oculta que
consiste em unidades que transformam a entrada em algo que a camada de saıda pode usar.
Eles sao excelentes ferramentas para encontrar padroes que sao muito complexos ou numerosos
para um programador humano extrair e ensinar a maquina a reconhecer.
Embora as redes neurais (tambem chamadas “perceptrons”) existam desde os anos
1940, e somente nas ultimas decadas que elas se tornaram uma parte importante da inteligencia
artificial. Isso se deve a chegada de uma tecnica chamada ”retropropagacao”, que permite que
as redes ajustem suas camadas ocultas de neuronios em situacoes em que o resultado nao
corresponde ao que o criador espera - como uma rede projetada para reconhecer caes, que
identifica erroneamente um gato, por exemplo.
Outro avanco importante tem sido a chegada de redes neurais de aprendizagem pro-
funda (deep learning neural networks), nas quais diferentes camadas de uma rede multicamada
extraem diferentes caracterısticas ate que ela possa reconhecer o que esta procurando.
Para uma ideia basica de como uma rede neural de aprendizagem profunda aprende,
imagine uma linha de fabrica. Depois que as materias-primas (o conjunto de dados) sao inseridas,
elas sao passadas pela esteira transportadora, com cada parada ou camada subsequente extraindo
um conjunto diferente de recursos de alto nıvel. Se a rede se destina a reconhecer um objeto, a
primeira camada pode analisar o brilho de seus pixels.
Figura 4 – Representacao entrada e saıda - rede neural artificial.
Fonte: Google imagens (2018)
A proxima camada poderia identificar quaisquer arestas na imagem, com base em
linhas de pixels semelhantes. Depois disso, outra camada pode reconhecer texturas e formas, e
assim por diante. Quando a quarta ou quinta camada for atingida, a rede de aprendizagem
Capıtulo 2. FUNDAMENTACAO TEORICA 19
profunda tera criado detectores de recursos complexos. Ele pode descobrir que certos elementos
da imagem (como um par de olhos, um nariz e uma boca) sao comumente encontrados juntos.
Feito isso, os pesquisadores que treinaram a rede podem fornecer rotulos para a saıda
e, em seguida, usar a retropropagacao para corrigir os erros cometidos. Depois de um tempo, a
rede pode realizar suas proprias tarefas de classificacao sem precisar de humanos para ajudar
todas as vezes.
2.4.3 Deep Learning
O Deep Learning, tambem conhecido como aprendizado hierarquico, e uma das partes
do aprendizado de maquina e tem como objetivo aprender diferentes representacoes dos dados
de forma a facilitar a extracao de informacoes em sistemas classificadores e preditores (BENGIO,
2014). E composto por algoritmos de alto nıvel de abstracao e multiplas transformacoes
nao-lineares.
As redes neurais que aplicam o conceito de Deep Learning sao denominadas Deep Neu-
ral Networks (DNN).A estrutura basica das DNNs e similar as redes tradicionais, diferenciando-se
apenas pelo numero de camadas. Um maior numero de camadas resulta em uma representacao
mais complexa e abstrata dos dados e consequentemente uma “profundidade” maior da rede.
Nao ha um consenso sobre o quao profundo um modelo precisa ser para ser qualificado como
”deep”. Contudo, o Deep Learning pode ser seguramente definido como o estudo de modelos
que envolvem uma grande composicao de funcoes ou conceitos aprendidos comparado ao
aprendizado de maquina tradicional (GOODFELLOW; BENGIO; COURVILLE, 2017).
E tudo sobre escala. A medida que construımos redes neurais maiores e as treinamos
com mais e mais dados, seu desempenho continua a aumentar. Isso geralmente e diferente de
outras tecnicas de aprendizado de maquina que atingem um plato no desempenho.
2.4.4 TensorFlow
TensorFlow e uma biblioteca de software de codigo aberto para computacao numerica
de alto desempenho. Sua arquitetura flexıvel permite a facil implantacao de computacao em
varias plataformas (CPUs, GPUs, TPUs) e de desktops a clusters de servidores para dispositivos
moveis e perifericos. Originalmente desenvolvido por pesquisadores e engenheiros da equipe do
Google Brain na organizacao de IA do Google, ele oferece um forte suporte para aprendizado
de maquina e aprendizado profundo, e o nucleo flexıvel de computacao numerica e usado em
muitos outros domınios cientıficos. O mecanismo de execucao distribuıdo do TensorFlow abstrai
os muitos dispositivos suportados e fornece um nucleo de alto desempenho implementado em
C ++ para a plataforma TensorFlow.
Em alto nıvel, TensorFlow e uma biblioteca Python que permite aos usuarios ex-
pressarem computacao arbitraria como um grafico de fluxos de dados. Os nos neste grafico
representam operacoes matematicas, enquanto as arestas representam dados comunicados de
um no para outro. Os dados no TensorFlow sao representados como tensores, que sao matrizes
Capıtulo 2. FUNDAMENTACAO TEORICA 20
Figura 5 – Pilha de software - TensorFlow.
Fonte: TensorFlow (2018)
multidimensionais. Embora essa estrutura para pensar sobre computacao seja valiosa em muitos
campos diferentes, TensorFlow e usado principalmente para o aprendizado profundo (deep
learning) em pesquisa e desenvolvimento.
2.4.5 Keras
Keras e uma API de redes neurais de alto nıvel, escrita em Python e capaz de rodar
em cima do TensorFlow, CNTK ou Theano. Foi desenvolvida para tornar a implementacao
de modelos de deep learning o mais rapido e facil possıvel para pesquisa e desenvolvimento.
Compatıvel com Python 2.7 ou 3.5, pode ser executada perfeitamente em GPUs e CPUs,
considerando as estruturas subjacentes.
Keras foi desenvolvida por Francois Chollet, um engenheiro do Google, usando quatro
princıpios orientadores:
• Modularidade: Um modelo pode ser entendido como uma sequencia ou um grafico sozinho.
Todas as preocupacoes de um modelo de deep learning sao componentes discretos que
podem ser combinados de maneiras arbitrarias.
• Minimalismo: A biblioteca fornece apenas o suficiente para alcancar um resultado, sem
frescuras e maximizando a legibilidade.
• Extensibilidade: Novos componentes sao intencionalmente faceis de adicionar e usar
dentro da estrutura, destinados a pesquisadores para testar e explorar novas ideias.
• Python: Nenhum arquivo de modelo separado com formatos de arquivo personalizados.
Tudo e nativo em Python.
Capıtulo 2. FUNDAMENTACAO TEORICA 21
2.4.6 LeNet
O LeNet foi uma das primeiras redes neurais convolucionais que ajudaram a impulsionar
o campo do Aprendizado Profundo. Este trabalho pioneiro de Yann LeCun foi denominado
LeNet5 apos muitas iteracoes anteriores bem sucedidas desde o ano de 1988 . Naquela epoca,
a arquitetura LeNet era usada principalmente para tarefas de reconhecimento de caracteres,
como leitura de CEPs, dıgitos, etc.
A arquitetura LeNet e simples e pequena (em termos de memoria ocupada), ela pode
ate mesmo rodar puramente em uma CPU, tornando-a uma otima arquitetura para aplicacoes
envolvendo CNNs e sistemas embarcados (LECUN, 1998).
Camadas esparsas e convolucionais e pool maximo sao o coracao da famılia de modelos
LeNet. Embora os detalhes exatos do modelo variem muito, a figura 6 mostra uma representacao
grafica de um modelo LeNet.
Figura 6 – Representacao de um modelo LeNet.
Fonte: Google imagens (2018)
2.5 SISTEMA ANDROID
O Android e o sistema operacional movel mais popular do mundo, utilizado em bilhoes
de dispositivos, de telefones a relogios, tablets, TVs, veıculos e muito mais. E uma plataforma
completa, de codigo aberto, envolve uma rica interface visual, diversas aplicacoes pre-instaladas
e um ambiente de desenvolvimento poderoso que esta sempre se atualizando.
Foi desenvolvido pela Open Handset Alliance (OHA), por empresas como Google, HTC,
LG, Motorola, Samsung, Sony Ericsson, Toshiba e muitas outras, que tiveram por objetivo
padronizar uma plataforma de codigo aberto e livre para celulares, para atender as necessidades
do mercado atual (LECHETTA, 2010).
2.5.1 Android Studio
O Android Studio e um ambiente de desenvolvimento disponibilizado gratuitamente
pelo Google para desenvolvedores Android. Baseado no IntelliJ IDEA, foi feito para incentivar a
Capıtulo 2. FUNDAMENTACAO TEORICA 22
criacao de aplicativos da mais alta qualidade. Ele oferece ferramentas personalizadas, incluindo
ferramentas avancadas de edicao, depuracao, teste e criacao de perfis de codigo. Com ele
qualquer um pode construir aplicativos para celulares, tablets, smartwatches, etc. A figura 7
apresenta a interface do Android Studio:
Figura 7 – Ambiente de Desenvolvimento Android Studio.
Fonte: Autoria propria (2018)
Uma das peculiaridades mais interessantes do Android Studio e a execucao instantanea.
Quando clicado em “Executar” ou “Depurar”, o recurso envia alteracoes de codigo ao aplicativo
em execucao e as entrega sem reiniciar ou recriar o aplicativo.
Tambem conta com um editor de codigo inteligente que auxilia o desenvolvedor
a escrever um codigo melhor, trabalhar mais rapido e ser mais produtivo. Este, oferece
preenchimento automatico de codigo e analise de erros antes da compilacao.
2.5.2 Arquitetura Android
O Android e uma pilha de software baseada em Linux. A arquitetura e dividida em seis
camadas: nucleo (kernel) Linux, camada de abstracao de hardware (HAL), Android Runtime
(ART), bibliotecas nativas C/C++, framework da API JAVA e a camada de aplicacoes. A
figura 8, a seguir, apresenta os principais componentes para cada camada:
A camada mais baixa da arquitetura, Linux kernel, e responsavel por gerenciar os
processos, threads, arquivos, diretorios e drivers dos dispositivos. E a fundacao da plataforma.
Ela permite que o Android aproveite dos recursos de seguranca existentes em Linux e que os
fabricantes dos dispositivos desenvolvam drivers de hardware para um nucleo ja conhecido.
Capıtulo 2. FUNDAMENTACAO TEORICA 23
Figura 8 – A pilha de software do Android.
Fonte: Android Developers (2018)
A HAL consiste em modulos de biblioteca, que servem de interface para certos
componentes de hardware, como o modulo de camera, modulo bluetooth, o acelerometro, etc.
A HAL tambem fornece interfaces que expoem as capacidades de hardware para a estrutura da
API Java. Quando a API faz uma chamada para acessar o hardware do dispositivo, o sistema
Android carrega o modulo da biblioteca para este componente de hardware.
Toda e qualquer aplicacao em Android roda dentro de seu proprio processo, isto
e, no contexto da sua instancia de maquina virtual, no caso o Android Runtime. O ART e
projetado para que os dispositivos possam suportar multiplas maquinas virtuais eficientemente.
Ele executa arquivos com extensao .dex - um tipo de Java bytecode otimizado para o Android.
Capıtulo 2. FUNDAMENTACAO TEORICA 24
Alguns dos recursos principais de ART sao: Compilacao AOT (Ahead-Of-Time) e JIT
(Just-In-Time), coleta de lixo (Garbage Collector) otimizada, melhor suporte em depuracao e
vasta capacidade de definir watchpoints.
Varios componentes e servicos do sistema Android, como ART e HAL, sao imple-
mentados em codigo nativo e exigem bibliotecas nativas programadas em C e C++. Algumas
dessas bibliotecas sao descritas a seguir:
• Surface manager – gerencia o display
• Media Framework – biblioteca de mıdia para reproducao de audio e vıdeo
• SQLite – fornece suporte a banco de dados
• OpenGL | ES – bibliotecas graficas para graficos 2D e 3D
• FreeType – fornece suporte a operacoes relacionadas a fontes de texto
• SGL – bibliotecas graficas
• WebKit – navegador da Web integrado e seguranca da Internet
• SSL – fornece seguranca na Internet e no navegador da Web
• libc – ssuporte para servicos especıficos do Android, como propriedades do sistema
O Android tambem contem um conjunto de bibliotecas que fornecem a maioria das
funcionalidades da linguagem de programacao Java, inclusive alguns recursos da linguagem
Java 8.
O framework da API JAVA fornece classes empregadas para criar os aplicativos. Ele
tambem fornece uma abstracao generica para acesso ao hardware e gerencia a interface do
usuario e os recursos do aplicativo. A camada de aplicacao e o local dos aplicativos executados
sobre o sistema operacional. Nesta camada esta localizada uma lista de aplicacoes padroes como
cliente de e-mail, programa de SMS, calendario, mapas, navegador, gerenciador de contato e
qualquer aplicativo de terceiros.
2.5.3 Atividades
Atividade ou Activity e um componente de aplicativo que fornece uma tela com a
qual os usuarios podem interagir para fazer algo, como discar um numero no telefone, tirar
uma foto, enviar um e-mail ou ver um mapa. Cada atividade recebe uma janela que exibe a
interface do usuario. Geralmente a janela preenche toda a tela, mas pode ser que seja menor
que a tela e ainda flutuar sobre outras janelas (ANDROID, 2018).
Geralmente um aplicativo e composto por varias atividades que se relacionam. Uma
dessas atividades e especificada como ”principal”(main) e e apresentada ao usuario ao iniciar o
aplicativo. Uma atividade pode inicializar e executar outra atividade para executar diferentes
acoes. Quando isto acontece o sistema conserva a atividade em uma ”pilha de retorno”. Esta
pilha de retorno segue o mecanismo basico de pilhas LIFO (Last In First Out). Assim, quando o
usuario terminar a atividade atual e apertar o botao Voltar, ela saira da pilha (sendo destruıda)
e a atividade anterior sera retomada.
Capıtulo 2. FUNDAMENTACAO TEORICA 25
Figura 9 – Ciclo de vida da atividade.
Fonte: Android Developers (2018)
Quando uma atividade e interrompida devido ao inıcio de uma nova atividade, ela e
notificada acerca dessa alteracao de estado por meio de metodos de retorno de chamada do
ciclo de vida da atividade. Cada retorno de chamada oferece uma oportunidade de executar
trabalhos especıficos adequados a essa alteracao de estado. Por exemplo: quando interrompida,
a atividade deve liberar todos os objetos grandes, como conexoes com a rede ou com um banco
de dados. Quando a atividade for retomada, sera possıvel readquirir os recursos necessarios
e retomar as acoes interrompidas. Essas transicoes de estado sao parte do ciclo de vida da
atividade apresentado na figura 9.
2.5.4 Android Manifest
O AndroidManifest.xml e um arquivo de existencia obrigatoria no qual sao acopladas
as configuracoes gerais da aplicacao e dos componentes utilizados por ela. E neste arquivo que
Capıtulo 2. FUNDAMENTACAO TEORICA 26
sao definidos os nomes das activities, o modo de orientacao da tela, como os componentes
que fazem parte da aplicacao interagem entre si e como eles sao declarados. Este arquivo
lista tambem as permissoes para utilizar recursos como GPS, acelerometro, acesso a internet,
ativamento de notificacoes e, por fim, define a hierarquia das activities.
2.6 SOCKETS
A conexao por sockets tem origem em 1980, quando a ARPA (Advanced Research Pro-
jects Agency, Agencia de Projetos de Pesquisa Avancados), orgao do governo norte americano,
forneceu recursos financeiros para que a Universidade da California Berkeley oferecesse uma
implementacao UNIX do pacote de protocolos TCP/IP. O que foi desenvolvido ficou conhecido
entao como interface de sockets de Berkeley.
Sockets sao estruturas que habilitam que dois ou mais aplicativos do tipo cliente/ser-
vidor, que estao em rede, se conectem entre si. Um computador e chamado servidor (ele abre
um socket e presta atencao as conexoes), o outro computador denomina-se cliente (ele chama
o socket servidor para iniciar a conexao). Vide figura 10:
Figura 10 – Representacao de comunicacao por sockets entre servidor e cliente.
Fonte: Autoria propria (2018)
Utilizar sockets de internet e a maneira mais comum de executar a comunicacao de
rede entre servidor e cliente. Para conseguir fazer uma conexao cliente-servidor, o servidor
tera que conter um socket com uma porta dedicada para receber conexoes. E necessario ter
conhecimento do numero de IP ou HOST do computador e o numero de porta do aplicativo ao
qual se quer realizar a conexao. O endereco IP identifica uma maquina especıfica na Internet e
o numero de porta e uma maneira de diferenciar os processos que estao sendo executados no
mesmo computador. Tipicamente o comportamento do servidor e ficar em um loop aguardando
novas conexoes para atender as solicitacoes de clientes.
Capıtulo 2. FUNDAMENTACAO TEORICA 27
Os segmentos TCP sao encapsulados e enviados em pacotes de dados. Uma forma de
melhor visualizar o funcionamento de socket TCP seria compara-lo a uma ligacao telefonica
onde alguem faz uma ligacao para outra pessoa e quando esta atende, e criado um canal de
comunicacao entre os dois falantes.
28
3 PROCEDIMENTOS METODOLOGICOS
Este capıtulo tem como finalidade descrever a metodologia e os procedimentos ado-
tados na confeccao deste projeto, bem como tambem realizar uma consolidacao de todos os
metodos aqui utilizados e apresentar o funcionamento do sistema como um todo. Para tal, os
procedimentos metodologicos foram divididos da seguinte forma: Raspberry Pi (Secao 3.1);
Camera USB (Secao 3.2); Criando um dataset, treinando e implantando a rede neural no sistema
embarcado (Secao 3.3); Desenvolvimento do aplicativo Android (Secao 3.4); Estabelecendo
modelo cliente e servidor (Secao 3.5); Algoritmos e Codigos (Secao 3.6).
3.1 RASPBERRY PI
O sistema embarcado selecionado para realizar o projeto foi o Raspberry Pi 3, conforme
figura 11. Essa selecao se da por diversos motivos:
• Sistema com alto poder de processamento;
• Boa relacao custo x benefıcio;
• Versatilidade;
• Facilidade de implementacao.
Figura 11 – Raspberry Pi 3.
Fonte: Magpi (2016)
A Raspberry Pi 3 possui 1 microprocessador ARM Cortex A53 de 1,2 GHz com
4 nucleos e um microprocessador de vıdeo no mesmo chip, da fabricante Broadcom, uma
memoria RAM de 1 GB, alem da conectividade 802.11n Wi-Fi. Foi instalado na placa o sistema
operacional Raspbian.
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 29
Por comodidade, todo o acesso da Raspberry no projeto e feito por Secure Shell
(SSH), de forma a possibilitar o acesso remoto a placa e nao necessitando de conexoes fısicas
nela como de um monitor, alem de perifericos como teclado e mouse. Isso torna a utilizacao da
placa muito pratica, pois e possıvel realizar toda a sua programacao atraves da rede. A placa
foi conectada a rede atraves da interface de rede wireless. Um dos softwares desenvolvidos no
projeto para a Raspberry foi programado na linguagem Python e outro em Java.
3.2 CAMERA USB
Uma camera USB consiste em basicamente uma camera de vıdeo digital que transmite
todo seu fluxo de dados de vıdeo atraves de sua interface USB. Este tipo de camera foi escolhida
pela sua facilidade de transmissao de dados para qualquer dispositivo, inclusive para o escolhido
sistema embarcado. Na figura 12 observa-se a camera do projeto.
Figura 12 – Camera USB (Logitech C270) utilizada.
Fonte: Logitech (2018)
A camera, da fabricante Logitech, modelo C270, foi escolhida pelo fato de ja ser
possuıda por um dos membros da equipe. A camera contem conexao USB 2.0 de alta velocidade
e filma em resolucao 1280 x 960 pixels, podendo alcancar um frame rate de ate 30 FPS em
uma configuracao inferior (640 x 480).
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 30
3.3 REDE NEURAL CONVOLUCIONAL
Redes neurais convolucionais (CNNs) sao a atual arquitetura de modelo de ultima
geracao para tarefas de classificacao de imagens. As CNNs aplicam uma serie de filtros aos
dados de pixel brutos de uma imagem para extrair e aprender recursos de nıvel mais alto, que
o modelo pode usar para classificacao. CNNs contem tres componentes:
Camadas convolucionais, que aplicam um numero especificado de filtros de convolucao
a imagem. Para cada sub-regiao, a camada executa um conjunto de operacoes matematicas
para produzir um unico valor no mapa de recursos de saıda. Camadas convolucionais entao
tipicamente aplicam uma funcao de ativacao ReLU na saıda para introduzir nao-linearidades
no modelo.
Agrupamento de camadas, que reduz a resolucao dos dados da imagem extraıdos pelas
camadas convolucionais para reduzir a dimensionalidade do mapa de recursos para diminuir o
tempo de processamento. Um algoritmo de pooling comumente usado e o pool maximo, que
extrai sub-regioes do mapa de recursos (por exemplo, blocos de 2x2 pixels), mantem seu valor
maximo e descarta todos os outros valores.
Camadas densas (totalmente conectadas), que realizam a classificacao nas caracte-
rısticas extraıdas pelas camadas convolucionais e diminuıdas pelas camadas de agrupamento.
Em uma camada densa, todos os nos da camada sao conectados a todos os nos da camada
anterior.
Normalmente, uma CNN e composta de uma pilha de modulos convolucionais que
executam a extracao de recursos. Cada modulo consiste em uma camada convolucional seguida
por uma camada de pooling. O ultimo modulo convolucional e seguido por uma ou mais
camadas densas que executam a classificacao. A camada densa final em uma CNN contem
um unico no para cada classe alvo no modelo (todas as classes possıveis que o modelo pode
prever), com uma funcao de ativacao softmax para gerar um valor entre 0 e 1 para cada no (a
soma de todos esses valores softmax sao iguais a 1). Podemos interpretar os valores softmax
para uma determinada imagem como medidas relativas de como e provavel que a imagem caia
em cada classe alvo.
3.3.1 Criando um dataset
Sem dados de treinamento suficientes, os modelos de machine e deep learning nao
podem aprender os padroes subjacentes e discriminativos necessarios para criar classificacoes
robustas. Algoritmos de deep learning, especialmente Redes Neurais Convolucionais (CNN),
necessitam de uma grande quantidade de dados para se tornarem viaveis.
Para este projeto, foi montado um dataset de 500 imagens contendo fogo, as quais
serviram de exemplo positivo e, outras 500 imagens aleatorias as quais nao continham fogo,
consideradas exemplos negativos, permitindo a rede diferenciar ambientes com fogo de ambientes
sem fogo. Posteriormente ainda utilizamos um dataset contendo outras 100 imagens, com e
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 31
sem fogo, para aferir a acertividade da rede neural.
Para evitar a necessidade de selecionar e realizar o download de imagem por imagem,
utilizou-se o Google Imagens como repositorio, e uma combinacao de JavaScript e Python para
a realizacao do download e verificacao das imagens.
Para encontrar imagens de exemplo positivo inserimos, no Google Imagens, termos
de consulta que arremetem a fogo, tais como “casa em chamas” e “incendio”. Na figura 13
pode-se observar as imagens encontradas ao se inserir o termo de pesquisa “velas queimando”
no Google Imagens.
Figura 13 – Busca google imagens - velas acesas.
Fonte: Google Imagens (2018)
Selecionado os termos de pesquisa, foi utilizado um codigo em JavaScript para reunir
as URLs das imagens exibidas pelo Google Imagens e salva-las em um arquivo texto.
Figura 14 – Codigo para salvar as URLs das imagens exibidas.
Fonte: Autoria propria (2018)
Foi utilizado um programa em Python para o download, a partir das URLs salvas no
arquivo texto, de todas as imagens exibidas pelo Google Imagens apos a insercao dos termos
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 32
de pesquisa citados anteriormente. O codigo foi desenvolvido de maneira a salvar a primeira
imagem com o nome 00000000.jpg e, seguindo este template, incrementar o nome das proximas
imagens. Ter as imagens nomeadas em sequencia simplifica o processo de treinamento da
rede neural. Se algum erro for encontrado durante a execucao, a excecao sera tratada e uma
mensagem sera impressa no terminal.
Figura 15 – Estrutura dos diretorios contendo as imagens do dataset.
Fonte: Autoria propria (2018)
Figura 16 – Codigo Python para download das imagens.
Fonte: Autoria propria (2018)
Nao obstante, ao finalizar o download das imagens, o programa testa cada uma
das imagens com um comando da biblioteca OpenCV. Caso haja alguma falha durante esta
execucao, o programa ira deletar a imagem, de maneira a expurgar imagens corrompidas do
dataset.
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 33
Figura 17 – Codigo responsavel pela verificacao da integridade das imagens baixadas.
Fonte: Autoria propria (2018)
Figura 18 – Download das imagens pelo terminal Anaconda.
Fonte: Autoria propria (2018)
3.3.2 Modelando a rede neural
Para a construcao do nosso modelo de rede neural utilizamos do modelo sequencial
do Keras, visto que a API sequencial permite criar modelos camada por camada para a maioria
dos problemas. E limitado porque nao permite criar modelos que compartilhem camadas ou
tenham varias entradas ou saıdas, porem nao e um fator limitante para este projeto, visto que
nao necessitamos de multiplas saıdas e entradas. Assim, modelamos a rede neural da seguinte
maneira:
• Camada Convolucional # 1: Aplica 20 filtros 5x5 (extraindo sub-regioes de 5x5 pixels),
com funcao de ativacao ReLU.
• Camada de Pooling # 1: Executa o pool maximo com um filtro 2x2 e stride de 2 (o que
especifica que as regioes agrupadas nao se sobrepoem).
• Camada Convolucional # 2: Aplica 50 filtros 5x5, com funcao de ativacao ReLU.
• Camada de Pooling # 2: Novamente, realiza o pool maximo com um filtro 2x2 e um
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 34
passo de 2.
• Camada Densa # 1: 500 neuronios.
• Camada Densa # 2 (Camada de Logits): 2 neuronios, um para cada classe alvo, ‘fogo’ e
‘nao fogo’.
Os metodos utilizados na criacao dos tres tipos de layers necessarios para a nossa rede
neural foram os seguintes:
• conv2d () - Constroi uma camada convolucional bidimensional. Obtem o numero de
filtros, o tamanho do kernel do filtro, o preenchimento e a funcao de ativacao como
argumentos.
• max pooling2d () - Constroi uma camada de pool bidimensional usando o algoritmo de
pool maximo. Leva o tamanho do filtro de pool e stride como argumentos.
• dense() - Constroi uma camada densa. Leva numero de neuronios e funcao de ativacao
como argumentos.
Cada um desses metodos aceita um tensor como entrada e retorna um tensor transfor-
mado como saıda, de maneira que basta pegar a saıda do metodo de criacao de uma camada e
fornece-la como entrada para outra.
Figura 19 – Codigo responsavel pela construcao do classificador de imagens Keras.
Fonte: Autoria propria (2018)
3.3.3 Treinando a rede neural
Keras e uma poderosa biblioteca Python facil de usar para desenvolvimento e avaliacao
de modelos de aprendizagem profunda. Ele envolve a eficiente biblioteca de computacao
numerica TensorFlow e nos permite definir e treinar modelos de redes neurais em algumas
linhas curtas de codigo. E atraves desta combinacao de Keras e TensorFlow que criamos o
arquivo train network.py para carregar, definir, compilar e avaliar nosso modelo de rede neural.
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 35
Figura 20 – Bibliotecas utilizadas no arquivo train network.py.
Fonte: Autoria propria (2018)
Na figura 21 observamos dois argumentos de linha de comando obrigatorios, -dataset
e -model, bem como um caminho opcional para nosso grafico de precisao / perda, -plot.
Figura 21 – Codigo responsavel pela entrada dos argumentos.
Fonte: Autoria propria (2018)
A opcao -dataset deve apontar para o diretorio que contem as imagens nas quais
estaremos treinando nosso classificador de imagens (ou seja, as imagens ”Santa”e ”Nao Santa”)
enquanto a opcao -model controla onde salvaremos nosso classificador de imagem serializado
depois de ter sido treinado.
Na figura 22 definimos algumas variaveis de treinamento, inicializamos listas e reunimos
caminhos para imagens.
Quantidade de epochs, taxa de aprendizagem, tamanho do batch e iteracoes sao
determinadas de acordo com o algoritmo de otimizacao iterativo gradiente descendente. Onde
batch e a quantidade de pacotes de imagens utilizadas no treinamento da rede neural, neste
caso, nosso total de imagens sera divido em 32 batches. Ja a variavel epoch determina quantas
vezes nosso dataset ira passar pela rede neural, ou seja, neste caso, iremos passar todos os
32 batches pela rede neural 25 vezes. A taxa de aprendizado inicial determina a velocidade
com que os pesos do gradiente descendente mudam, tentando eviar uma sobrecorrecao em
cada iteracao da rede neural durante o treinamento. Todos os parametros aqui citados sao
conhecidos como hiper-parametros, portanto seus valores sao definidos atraves de testes e
ajustes finos.
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 36
Figura 22 – Codigo de inicializacao das variaveis de treinamento, listas e diretorios.
Fonte: Autoria propria (2018)
Em seguida, conforme ilustrado na figura 23, realizamos o pre-processamento das
imagens.
Figura 23 – Codigo para pre-processamento das imagens.
Fonte: Autoria propria (2018)
O loop da figura 23 simplesmente carrega e redimensiona cada imagem para 28x28
pixels fixos (as dimensoes espaciais necessarias para o LeNet) e acrescenta o array de imagem
a lista de dados, seguido pela extracao do rotulo de classe do imagePath.
Podemos executar essa extracao de rotulo de classe pois a estrutura de diretorios do
conjunto de dados e organizada da seguinte maneira:
Portanto, de um exemplo de imagePath:
• images/fire/00000042.jpg
Depois de extrair o rotulo, o resultado sera:
• fire
A organizacao de conjuntos de dados de imagens de aprendizado profundo dessa
maneira nos permite organizar eficientemente nosso conjunto de dados e analisar rotulos de
classe sem a necessidade de usar um arquivo de ındice/pesquisa separado.
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 37
Figura 24 – Estrutura do diretorio do dataset.
Fonte: Autoria propria (2018)
Em seguida, nos pre-processamos nossos dados de entrada alterando a escala dos
pontos de dados de [0, 255] (os valores RGB mınimo e maximo da imagem) para o intervalo
[0, 1]. Realizamos uma divisao de treinamento/teste nos dados usando 75% das imagens para
treinamento e 25% para testes. Essa e uma divisao tıpica para essa quantidade de dados.
Tambem convertemos rotulos em vetores usando uma codificacao simples.
Figura 25 – Codigo para alterar escala das imagens e criar splits.
Fonte: Autoria propria (2018)
Posteriormente, executamos alguns aumentos de dados, permitindo gerar dados de
treinamento adicionais e transformando aleatoriamente as imagens de entrada usando os
parametros abaixo.
Keras fornece a classe ImageDataGenerator, a qual define a configuracao para pre-
paracao e aumento de dados de imagem. Em vez de executar as operacoes em todo o seu
conjunto de dados de imagem na memoria, a API foi projetada para ser iterada pelo processo de
ajuste do modelo de aprendizado profundo, criando dados de imagem aumentados just-in-time.
Isso reduz a sobrecarga de memoria, mas adiciona algum custo de tempo adicional durante o
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 38
Figura 26 – Criacao de dados atraves da ImageDataGenerator().
Fonte: Autoria propria (2018)
treinamento do modelo.
Essencialmente, a ImageDataGenerator cria um objeto gerador de imagens que executa
rotacoes aleatorias, espelhamento, inversoes, desvios e variacoes em nosso conjunto de dados
de imagens. Isso nos permite alcancar bons resultados mesmo com um conjunto de dados
menor.
A LeNet foi a arquitetura selecionada, dentre diversos fatores, principalmente por ser
pequena, possibilitando o treinamento da mesma em um computador com uma GPU simples
e em um curto espaco de tempo, ao passo que arquiteturas mais complexas necessitam de
computadores com GPUs de ultima geracao e, ainda sim, levam dias para serem treinadas.
Construımos nosso modelo LeNet com o otimizador Adam. Como esse e um problema
de classificacao de duas classes, optamos pela entropia cruzada binaria como nossa funcao de
perda.
Figura 27 – Codigo para inicializar, treinar e salvar modelo de rede.
Fonte: Autoria propria (2018)
O treinamento da rede e iniciado quando chamamos model.fit generator, fornecendo
nosso objeto de aumento de dados, dados de treinamento, teste e o numero de epochs pelos
quais queremos treinar. Em sequencia, salvamos o modelo em disco, para depois utilizarmos
nosso classificador de imagens sem a necessidade de reconstruir o modelo.
Utilizando-se do terminal de comando Anaconda, executamos o codigo train network.py
afim de inicializar, treinar e compilar nosso modelo de rede neural.
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 39
A rede treinou por 25 epochs e obtivemos 96,45% de precisao nos testes e baixa perda
de treinamento, vide figuras 28 e 29.
Figura 28 – Rede neural com 26 epochs e precisao de 96,45%.
Fonte: Autoria propria (2018)
Figura 29 – Treinamento de redes neurais - precisao e perdas.
Fonte: Autoria propria (2018)
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 40
3.4 APLICATIVO ANDROID
O aplicativo foi desenvolvido nas linguages Java e XML, ambas linguagens oficiais do
ambiente de desenvolvimento Android Studio. Utiliza-se a linguagem XML para construir o
layout da activity, ou seja, a interface do usuario. OJava geralmente e utiliizado para desenvolver
as funcoes da aplicacao, mas detem liberdade e pode ser empregado para alterar os elementos
da interface ja que as linguagens trabalham em conjunto e estao interligadas.
Para o aplicativo existem duas funcoes de grande importancia: avisar o usuario sobre
um possıvel perigo e providenciar acesso direto a visualizacao da camera digital. A visualizacao
da camera e disponibilizada em tempo real para que o usuario possa confirmar a veracidade de
um possıvel incendio ou evento. Para que o usuario interaja com o sistema, receba a notificacao
ou acesse a imagem da camera, e necessario que o celular tenha conectividade com a internet.
As duas grandes funcoes mencionadas acima foram desenvolvidas separadamente em duas
activities:
• MainActivty
• CameraActivity
A MainActivity e responsavel por alertar o usuario sobre qualquer mudanca que
aconteca no estado do sistema. Para este projeto existem tres estados de seguranca (NORMAL,
WARNING, DANGER!) alteraveis a efeito da interpretacao e do resultado obtido pela rede
neural.
Figura 30 – Diferentes estados do aplicativo TCC - Fire Alarm.
Fonte: Autoria propria (2018)
O estado NORMAL e essencialmente o modo ocioso da aplicacao. Resultado de uma
mudanca caso nao haja mais perigo ou risco de fogo, ou aparente na inicializacao do aplicativo
quando, ate o momento, nada foi exposto ao sistema.
Dissemelhante, o estado DANGER! e ativado logo apos o algoritmo de interpretacao
verificar alguma chama ou luz muito forte. Neste caso uma notificacao com prioridade alta e
gerada e enviada ao dispositivo Android. O estado do sistema e alterado imediatamente para
uma cor chamativa, tambem com o intuito de induzir o usuario que um problema real esta em
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 41
questao. O sistema continua notificando o usuario ate que algum contato com o aplicativo
seja realizado. A figura31 representa a mensagem de notificacao deste estado.
Figura 31 – Notificacao gerada pela troca ao estado DANGER!
Fonte: Autoria propria (2018)
De maneira analoga, o estado WARNING, tambem troca a cor e o texto da barra
de ”status” e gera uma notificacao, mas para entrar neste caso a o algoritmo de rede neural
tem que estar indeciso se o que esta sendo interpretado e realmente um incendio. Essa
notificacao, enviada do aplicativo ao smartphone, tem o intuito de criar um acesso rapido a tela
CameraActivity, vide figura 32. Assim, o usuario tem agilidade para verificar se realmente existe
um problema em evidencia ou se uma ma interpretacao do algoritmo ou um alarme falso foi
concebido. Clicar em cima desta notificacao abre diretamente a tela de visualizacao da camera.
Figura 32 – Notificacao gerada pela troca ao estado WARNING.
Fonte: Autoria propria (2018)
Outra maneira de acessar a visualizacao da camera e clicando no botao ”View Camera”,
que, coloca a MainActivity em segundo plano (na pilha de atividades) e impoe a CameraActivity
em evidencia. Esta atividade tem a funcao de apresentar o conteudo da camera digital em
tempo real. Para isso, dispoe de uma logica de acesso a uma pagina internet, onde o conteudo
da camera esta sendo transmitido.
O vıdeo e transmitido do Raspberry Pi. No Android utilizamos a engine WebKit, que
fornece um conjunto de classes com a finalidade de exibir o conteudo de uma pagina na internet.
Basicamente, a classe WebView possibilita re-criar todo o conteudo de um site para o modelo
de visualizacao do aplicativo, vide figura 33.
O fluxograma 34 explica de maneira mais simplificada como a MainActivity e executada,
qual a sua logica de programacao e quais sao os seus principais processos e metodos utilizados.
As notificacoes enviadas para o usuario sao criadas no aplicativo logo apos a solicitacao
do cliente ser interpretada. Isto sera explicado em detalhes no item 3.5.
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 42
Figura 33 – Visualizacao da CameraActivity.
Fonte: Autoria propria (2018)
Figura 34 – Fluxograma simplificado da MainActivity.
Fonte: Autoria propria (2018)
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 43
3.5 MODELO CLIENTE-SERVIDOR
Para a comunicacao entre as duas partes, foi utilizado o modelo cliente-servidor. O
Raspberry Pi executa a aplicacao de cliente, enquanto o aplicativo Android o outro. Para isto
foi utilizado as classes Socket e ServerSocket do pacote java.net.
A classe Socket implementa a parte do cliente e e utilizada para se conectar a um host
remoto. De outra parte, um objeto da classe ServerSocket aguarda a chegada de solicitacoes
pela rede. Na utilizacao destas classes e, de modo que e necessario enviar e receber mensagens
com exatidao, utiliza-se as estruturas de InputStreams e OutputStreams, obtido atraves dos
metodos Socket.getInputStream() e Socket.getOutputStream().
Como a aplicacao de cliente foi desenvolvida em Java e o software de deteccao de fogo
em Pyhton, foi necessario realizar chamadas de sistema que, no caso, invocam uma solicitacao
do Raspberry pi para o servidor sempre que um evento ou perigo e detectado. O servidor esta
hospedado em uma thread que e instanciada no inıcio da atividade principal do aplicativo Fire
Alarm e fica ativa esperando um contato da parte do cliente. Desse modo ocorre a comunicacao
entre as duas partes e como consequencia o estado do sistema e notificado ao usuario.
3.6 ALGORITMOS E CODIGOS
Nesta secao serao explicados com mais detalhes os algoritmos e codigos utilizados
para a construcao totalitaria deste sistema de deteccao e alarme de incendio.
3.6.1 Implementacao no Raspberry Pi
o Raspberry Pi nao e adequado para treinar uma rede neural. No entanto, ele pode
ser usado para implantar uma rede neural depois de ja ter sido treinada, desde que o modelo
possa caber em um espaco de memoria pequeno e compatıvel com o Raspberry Pi.
Ja que nao ha uma distribuicao oficial do TensorFlow para Raspberry Pi, decidimos
utilizar os binarios pre-compilados criados por Sam Abrahams
Figura 35 – Comandos utilizados para instalacao do TensorFlow no Raspberry Pi.
Fonte: Autoria propria (2018)
Uma vez que o TensorFlow se encontra instalado e compilado, instalamos o HDF5 e o
h5py, bibliotecas que nos permitira carregar nosso modelo pre-treinado a partir do cartao SD:
Para finalizar, instalamos o Keras, Imutils e Scipy, necessarias para a executacao deste
projeto:
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 44
Figura 36 – Comandos utilizados para instalacao das bibliotecas HDF5 e h5py no Raspberry Pi.
Fonte: Autoria propria (2018)
Figura 37 – Comandos utilizados para instalacao das bibliotecas HDF5 e h5py no Raspberry Pi.
Fonte: Autoria propria (2018)
Para testar se o ambiente estava corretamente configurado e com todas as bibliotecas
compiladas, executamos os seguintes comandos no Raspberry Pi:
Figura 38 – Comandos utilizados para instalacao das bibliotecas HDF5 e h5py no Raspberry Pi.
Fonte: Autoria propria (2018)
3.6.2 Inicializacao do sistema
Com o sistema configurado, criamos o programa fire detector.py, o qual ira rodar
no Raspberry Pi e sera responsavel por carregar a rede neural (.model) e realizar toda a
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 45
comunicacao com o sistema embarcado, obtendo os frames da camera, alimentando a rede
neural com as imagens obtidas e mantendo o pipeline de comunicacao com o servidor Android
ativo, o informando de eventuais eventos detectados pelo sistema.
Figura 39 – Comandos utilizados para importar as bibliotecas ja compiladas no Raspberry Pi.
Fonte: Autoria propria (2018)
Figura 40 – Declara e importa o modelo de rede neural a ser utilizado pelo Raspberry Pi.
Fonte: Autoria propria (2018)
Tambem inicializamos os parametros usados para deteccao, que incluem TOTAL CONSEC
e TOTAL THRESH. Esses dois valores representam o numero de quadros que contem fogo
e o limite no qual enviaremos uma notificacao de alarme de incendio ao servidor. A ultima
inicializacao, booleana, e FIRE = False. Utilizamos a variavel FIRE posteriormente no script
como um sinalizador de status para ajudar na logica de deteccao.
Figura 41 – Codigo de inicializacao e parametrizacao do sistema de deteccao de incendio.
Fonte: Autoria propria (2018)
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 46
Em sequencia, carregamos o modelo da rede neural no Raspberry e inicializamos a
camera.
Figura 42 – Codigo de carregamento do modelo de rede e inicializacao da camera.
Fonte: Autoria propria (2018)
3.6.3 Obtencao do frame da camera e classificacao das imagens
Realizada a inicializacao da camera atraves da funcao VideoStream da biblioteca
Imutils, utilizamos a funcao vs.read para capturar frame por frame do stream de vıdeo.
Figura 43 – Codigo de captura de frames da stream de vıdeo.
Fonte: Autoria propria (2018)
Pre-processamos cada frame antes de envia-los atraves do nosso modelo de rede neural,
portanto, em seguida, redimensionamos o quadro para width = 400, mantendo a proporcao,
e preparamos a imagem para envio a rede. A partir daı, chamamos model.predict com nossa
imagem como argumento. Isso envia a imagem atraves da rede neural, retornando um tuple
contendo probabilidades de classe, sendo elas Fire e noFire. O sistema e inicializado com o
label No Fire e probalidade noFire, evitando o envio de um alarme falso durante a inicializacao
do sistema.
Em sequencia, o codigo verifica se existe fogo na imagem comparando a probabilidade
de Fire (fogo na imagem) com a probabilidade de noFire (sem sinais de fogo na imagem).
Se a probabilidade de existir fogo for maior que a de nao exisitir fogo no frame, o label e a
probabilidade (proba) sao atualizados para Fire e a variavel TOTAL CONSEC e incrementada
de maneira a nos possibilitar contar quantos frames consecutivos acusaram a existencia de
fogo.
Verificada a existencia de fogo em uma quantidade suficiente de frames consecutivos,
o alarme de incendio e acionado.
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 47
Figura 44 – Codigo para pre-processamento e envio dos frames para a rede neural.
Fonte: Autoria propria (2018)
Figura 45 – Codigo de classificacao das imagens.
Fonte: Autoria propria (2018)
Figura 46 – Codigo de acionamento do alarme.
Fonte: Autoria propria (2018)
Caso contrario, (FIRE e TRUE ou TOTAL THRESH nao e atendido), zeramos
TOTAL CONSEC para zero e FIRE para False.
Figura 47 – Reinicializacao da contagem de frames consecutivos.
Fonte: Autoria propria (2018)
Por fim, exibimos os frames em nossa tela. Utilizando o cv2.putText do OpenCV,
podemos escrever o rotulo na parte superior do quadro antes de exibir a imagem na tela, assim
o valor de probabilidade e anexado ao rotulo contendo ”Fire”ou ”Not Fire”, como exemplificado
na figura 49, em que a rede neural indica a existencia de fogo na lareira com 93,88% de
confianca.
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 48
Figura 48 – Construcao do frame para exibicao na tela.
Fonte: Autoria propria (2018)
Figura 49 – Deteccao de fogo na imagem com 93,88% de confianca.
Fonte: Autoria propria (2018)
3.6.4 Envio de evento e recebimento de notificacao
Toda vez que o sistema identifica uma mudanca de estado, seja esta com um risco
maior ou menor de seguranca o usuario e notificado. Para que o usuario seja notificado, o
Raspberry Pi cria um Socket que e associado ao aplicativo Android pelo IP destino (Ex:
192.168.100.52) e entao envia um fluxo de dados, exibido em detalhes na figura 50.
A MainActivity e responsavel por interpretar essas mensagens e notificar o usuario.
Para isto, uma thread fica ativa com a funcao de servidor esperando qualquer requisicao do
cliente. Quando uma requisicao e interpretada pelo aplciativo Android o estado do layout e
alterado e o sistema entra em atuacao. O aparelho entao comeca a vibrar e bipar com o intuito
de chamar a atencao do usuario. E o sistema so entra em repouso apos outra interacao do
usuario, consentindo que a notificacao foi recebida e que esta ciente da alteracao do estado de
perigo.
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 49
Figura 50 – Codigo responsavel pelo envio de novos eventos.
Fonte: Autoria propria (2018)
3.6.5 Transmissao e visualizacao de vıdeo
Para a transmissao das imagens da camera para o aplicativo Android, em tempo
real, foi utilizado a ferramenta Motion - disponıvel na terceira versao do Raspberry Pi. Esta
ferramenta e uma maneira pratica de criar um servidor Webcam que possa transmitir vıdeo
pela internet.
O comando ’sudo apt-get install motion’ foi empregue para instalar a ferramenta.
Apos a instalacao foi necessario alterar as seguintes configuracoes do arquivo ’motion.conf’,
encontrado em ’/etc/motion/motion.conf’:
• ’Framerate’ 1000
• ’Stream quality’ 100
• ’Strea localhost’ OFF
• ’Stream port’ 8081
• ’width’ & ’height’ 640 x 480
• ’quality’ 100
• ’webcontrol localhost’ OFF
Em seguida, para deixar o servidor Webcam ativo sempre que o Raspberry Pi tambem
estiver, utilizou-se o comando ’sudo motion’. Desse modo qualquer usuario com acesso a pagina
de internet que o vıdeo esta sendo transmitido consegue visualizar a camera em tempo real,
basta um acesso ao IP e ao PORT do servidor.
Para a funcionalidade de acesso e visualizacao desta pagina que transmite as imagens
da camera USB, na internet, foi utilizado as linhas de codigo da figura 51 a seguir:
Assim entende-se que a pagina transmitida pelo Raspberry Pi no IP ’192.168.100.54’
e recriada na interface da CameraActivity, e que ambas as partes precisam ter acesso a internet
para o devido funcionamento do sistema.
Capıtulo 3. PROCEDIMENTOS METODOLOGICOS 50
Figura 51 – Codigo responsavel pela visualizacao do vıdeo.
Fonte: Autoria propria (2018)
3.6.6 Fluxograma do funcionamento geral do sistema
O fluxograma resumido do funcionamento do codigo e mostrado a seguir na figura 52
e os codigos dos processos sao encontrados nos respectivos apendices.
Figura 52 – Fluxograma do funcionamento do codigo.
Fonte: Autoria propria (2018)
51
4 APRESENTACAO E ANALISE DE RESULTADOS
Aqui sera explicado, de modo conciso e objetivo, o processo basico de funcionamento
do sistema em dois testes. O primeiro teste, dinamico, tem como objetivo apurar a capacidade
de deteccao de fogo da rede neural em de maneira isolada, em uma abordagem conhecida
como caixa preta. Ja no segundo teste iremos constatar o funcionamento do sistema completo
e em tempo real.
4.1 ANALISE E RESULTADOS DA REDE NEURAL
Entende-se que em uma operacao em tempo real, devido a limitacoes de hardware, a
capacidade de indentificacao de imagens da rede neural pode sofrer certo declınio. Portanto,
com a intencao de averiguar a capacidade da rede neural de maneira isolada, ou seja, sem o
impacto da capacidade de processamento do Raspberry Pi, realizamos testes em um computador
muito mais robusto que o sistema embarcado mencionado.
Neste teste, atraves de um script em Python, alimentamos a rede neural com uma
unica imagem e observamos os resultados em sua saıda. A classificacao da imagem, seja ela de
“Fire” para imagens contendo fogo, ou “No Fire” para imagens que nao contem fogo, seguidas
do grau de confianca com o qual a rede neural classificou a imagem, estao destacadas em
verde no canto superior esquerdo das imagens.
Por se tratar de um teste em que podemos escolher imagens ate mesmo da internet, fez-
se possıvel a averiguacao da capacidade do classificador em situacoes as quais nao conseguiriamos
replicar em nossas residencias.
Assim, no primeiro teste utilizamos um vıdeo do National Institute of Standards and
Technology (https://www.nist.gov/topics/fire), no qual e demonstrado uma arvore de natal
pegando fogo em questao de segundos.
Figura 53 – Captura de tela durante teste da rede neural.
Fonte: Autoria propria (2018)
Capıtulo 4. APRESENTACAO E ANALISE DE RESULTADOS 52
A sequencia a seguir possuı 7 frames capturados entre os segundos 0 e 2,79 do vıdeo
em questao.
Figura 54 – Captura de tela durante teste da rede neural.
Fonte: Autoria propria (2018)
E interessante notar que a medida em que a chama aumentava entre os segundos 0 e
2,29, exibidos nas imagens 53 e 54, o classificador ainda nao tinha detectado a chama, porem
ja indicava uma incerteza da nao existencia de fogo ao reduzir a confianca na classificacao “No
Fire” de 98,85% para 66,38% entre esse tempo.
Em contraste, entre o segundo 2,29 exibido na imagem 54 e 2,45 da imagem 55, a
classificacao se inverteu, passando de 66,38% de confianca em nao existencia de fogo para
63,14% de confianca na existencia de fogo.
Por fim, capturamos um frame do segundo 2,79, onde a confianca da rede neural na
existencia de fogo ja era de 91,67%, ou seja, um aumento de 28,53% na confianca da rede
neural em apontar a existencia de fogo na imagem em somente 0,34 segundos de diferenca
entre um frame e outro.
Figura 55 – Captura de tela durante teste da rede neural.
Fonte: Autoria propria (2018)
Capıtulo 4. APRESENTACAO E ANALISE DE RESULTADOS 53
Em sequencia, realizamos um teste onde o objetivo foi gerar um falso positivo. O
falso positivo em questao pode acontecer por diversos motivos, tais como a existencia de uma
predisposicao da rede neural em realizar certas classificacoes devido ao dataset de treinamento
ou ate mesmo da ma calibracao dos hiperparametros utilizados para configuracao da arquitetura.
O dataset utilizado para gerar o nosso modelo de rede neural foi montado pensando-se
em um sistema para deteccao de incendio residencial, portanto as imagens de exemplo“positivas”
eram de ambientes internos com presenca de fogo e as “negativas” as de ambientes internos
sem a presenca de fogo. Isso garante uma otima performance em ambientes internos para os
quais ele foi treinado, porem essa predisposicao faz com que a rede neural gere falsos positivos
caso o sistema seja utilizado em um ambiente diferente. Um exemplo disso e a imagem 56,
onde a rede entende que as luzes dos postes sao na verdade chamas, o que a levou a indicar,
erronamente, a existencia de fogo na imagem.
Figura 56 – Teste em luminosidade, luz - antes do treinamento.
Fonte: Autoria propria (2018)
Uma maneira de se reduzir falsos positivos e a realizacao de um ajuste fino no dataset
de treinamento da rede. Para o exemplo em questao, realizamos um segundo treinamento da
rede, so que desta vez inserimos diversas imagens de postes acesos no dataset de exemplos
”negativos”, a fim de indicar a rede neural que esses casos devem ser ignorados. Alimentamos
esse novo modelo de rede com a mesma imagem e dessa vez os resultados foram diferentes,
onde a classificacao passou de 73% de certeza de fogo para 95,35% de certeza da nao existencia
de fogo na imagem, vide figura 57.
Capıtulo 4. APRESENTACAO E ANALISE DE RESULTADOS 54
Figura 57 – Teste em luminosidade, luz - apos devido treinamento.
Fonte: Autoria propria (2018)
4.2 ANALISE E RESULTADOS DO SISTEMA EM TEMPO REAL
Para o teste do sistema embarcado em tempo real, utilizamos de alguns artifıcios a fim
de forcar o acionamento da deteccao de fogo pela rede neural, neste caso, pelo posicionamento
da chama de um esqueiro em grande proximidade a camera. Isso se deu devido ao fato de que
uma simulacao de incendio real se mostrou muito perigosa e de pouca valia para esse teste,
dado que ja haviamos nos certificado da capacidade da rede em detectar incendios atraves dos
testes realizados em um ambiente de simulacao computacional, vide secao 4.1.
Na figura 58 pode ser osbervado um dos membros do projeto posicionado em frente a
camera, onde a classificacao da imagem (lado esquerdo) e de 98,17% de nao existencia de fogo.
Ja no segundo frame, exibido na mesma figura (lado direito), identificamos a chama oriunda
de um esqueiro e o sistema interpretando a imagem contendo fogo com 94,69% de certeza.
Como ja mencionado em secoes anteriores, apos a identificacao de fogo na imagem
em 20 ou mais frames consecutivos, o sistema entende que existe a possibilidade de incendio
no ambiente e notifica o usuario pelo envio de uma notificacao ao dispositivo Android.
Ao clicar na barra de notificacoes em seu dispositivo Android o usuario tem acesso
direto ao aplicativo de monitoramento de status do sistema. Neste caso, devido a identificacao
da chama do esqueiro, o sistema entra em estado de alarme, indicado pela figura 59, o que e o
resultado esperado e demonstra a capacidade do sistema em responder corretamente.
Capıtulo 4. APRESENTACAO E ANALISE DE RESULTADOS 55
Figura 58 – Captura de tela durante teste de tempo real.
Fonte: Autoria propria (2018)
Figura 59 – Captura de tela do aplicativo apos recebimento de notificacao.
Fonte: Autoria propria (2018)
56
5 CONCLUSAO
Na elaboracao deste trabalho foram utilizados muitos dos conhecimentos compreendi-
dos e desenvolvidos durante o decorrer do curso e em nossas experiencias em estagios e, ou
empregos. Aprendizagem de maquina, engenharia de software, desenvolvimento de aplicativos,
sistemas embarcados, redes de computadores, visao computacional, processamento de imagem,
e outros mais. Alem disso, por colocar todos esses conceitos em pratica, muitas dessas tecnicas
foram aperfeicoadas e entao consideradas como um benefıcio evidente para nossas vida.
A intencao deste projeto foi elaborar um sistema de alarme de incendio mais conve-
niente e vantajoso em comparacao com os produtos convencionais. Os objetivos e requisitos
mencionados na introducao foram todos alcancados com sucesso, mesmo apos certas dificul-
dades nao previstas no inıcio do projeto. O envio de notificacao equivalente a um alarme, a
possibilidade de visualizacao da camera em tempo real e o baixıssimo consumo de memoria
que o aplicativo oferece foram todos requisitos cumpridos com excelencia.
De acordo com alguns testes instrumentais e funcionais aplicados a interface do
aplicativo foi entendido que a simplicidade das duas telas permite muito comprazimento e
eficiencia. Dessa forma, se adequando as necessidades do usuario. Um fator a ser questionado
seria uma futura implementacao do aplicativo para iPhone (iOS), utilizando para isso uma
plataforma de desenvolvimento cruzado por exemplo. Um posicionamento que nao pode ser
descartado, mas que tem como atual justificativa a relacao entre sistemas Android e iOS no
mundo inteiro, 84% x 14% respectivamente. O que para este trabalho de conclusao de curso
seria visto como excesso de trabalho atrelado a pouca recompensa.
Para a deteccao de eventos e a identificacao da causa foi necessario realizar alguns
ajustes devido ao nosso hardware escolhido. O Raspberry Pi, por ser compacto, apresenta
certos limitantes como poder de processamento e memoria moderada. Uma outra opcao seria
desenvolver um hardware customizado em cima da mesma arquitetura para providenciar maior
capacidade de rendimento e robustez. Ou ate, utilizar de algum servidor (Ex: Amazon AWS)e
manter todo processamento da rede neural em nuvem.
Conclui-se tambem que a distancia da camera ao agente tem grande influencia na
objetividade do reconhecimento. No entanto nao e o unico fator visto que um ambiente com
luminosidade alta, uma camera com a lente suja ou qualidade baixa e ate o local e angulo de
posicionamento intervem nos resultados esperados. Consequentemente, nao seria uma analise
justa do ponto de vista de desempenho do projeto.
Foi verificado que esta aplicacao e a utilizacao da rede neural e bastante soluvel
para o escopo em pauta. Porem, acaba sendo um pouco insidiosa uma vez que problemas
diferentes vao surgindo para cada teste feito. E um sistema que precisa de contınuas adaptacoes,
implementando varios classificadores diferentes ate que atinja uma versao estavel.
57
Referencias
ANDROID, D. Atividades. 2018. Disponıvel em: <https://developer.android.com/guide/components/activities?hl=pt-br>. Acesso em: 09 de outubro de 2018. Citado na pagina 24.
ARRUE, A. O. B. C.; DIOS, J. R. M. de. Intelligent System for False Alarm Reduc-tion in Infrared Forest-Fire Detection. 2000. Disponıvel em: <https://ieeexplore.ieee.org/document/846287/>. Acesso em: 23 de maio de 2018. Citado na pagina 13.
BENGIO, Y. Representation Learning: A Review and New Perspectives. 2014. Disponıvelem: <https://arxiv.org/abs/1206.5538>. Acesso em: 26 de maio de 2018. Citado na pagina19.
BISHOP, C. M. Pattern Recognition and Machine Learning. 1. ed. Cidade: Springer, 2006.Citado na pagina 17.
GOODFELLOW, I.; BENGIO, Y.; COURVILLE, A. Deep Learning. 2017. Disponıvel em:<https://github.com/janishar/mit-deep-learning-book-pdf>. Acesso em: 16 de abril de 2018.Citado na pagina 19.
LECUN, Y. Gradient-Based Learning Applied to Document Recognition. 1998. Dispo-nıvel em: <http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf>. Acesso em: 22 de julho de2018. Citado na pagina 21.
MAGPI, M. RASPBERRY PI 3 IS OUT NOW! SPECS, BENCHMARKS AND MORE.2016. Disponıvel em: <https://www.raspberrypi.org/magpi/raspberry-pi-3-specs-benchmarks/>. Acesso em: 07 de abril de 2018. Citado na pagina 28.
REED, K. 8 Ways Technology Is Improving Your Health. 2017. Disponıvel em: <https://www.positivehealthwellness.com/fitness/8-ways-technology-improving-health/>. Acesso em:13 de julho de 2018. Citado na pagina 16.
RENAUX, D. Notas de aula de Sistemas Embarcados. 2016. Disponıvel em: <http://www.dainf.ct.utfpr.edu.br/˜douglas/index.htm>. Acesso em: 7 de maio de 2018. Citado napagina 14.
SPRINKLER, I. Brasil e o 3o paıs com o maior numero de mortespor incendio. 2015. Disponıvel em: <https://www.sprinklerbrasil.org.br/imprensa/brasil-e-o-3o-pais-com-o-maior-numero-de-mortes-por-incendio-newsletter-no-5/>. Acessoem: 10 de novembro de 2018. Citado na pagina 11.
SZELISKI, R. Computer Vision: Algorithms and Applications. 1. ed. Cidade: Springer,2010. Citado na pagina 16.
TARTU, U. of. Digital Image Processing. 2015. Disponıvel em: <https://sisu.ut.ee/imageprocessing/book/1>. Acesso em: 20 de julho de 2018. Citado na pagina 16.
TECHOPEDIA. Definition - What does Digital Video Camera (DVCAM) mean? 2018.Disponıvel em: <https://www.techopedia.com/definition/10556/digital-video-camera-dvcam>.Acesso em: 05 de maio de 2018. Citado na pagina 15.
Apendices
59
APENDICE A – Codigo para download das imagens do dataset
# USAGE
# python download images . py −−u r l s u r l s . t x t −−output images / f i r e
# i m p o r t t he n e c e s s a r y packages
from i m u t i l s i m p o r t p a t h s
i m p o r t a r g p a r s e
i m p o r t r e q u e s t s
i m p o r t cv2
i m p o r t os
# c o n s t r u c t the argument p a r s e and p a r s e the arguments
ap = a r g p a r s e . ArgumentParser ( )
ap . add argument ( ”−u ” , ”−−u r l s ” , r e q u i r e d=True ,
h e l p=”path to f i l e c o n t a i n i n g image URLs ”)
ap . add argument ( ”−o ” , ”−−output ” , r e q u i r e d=True ,
h e l p=”path to output d i r e c t o r y o f images ”)
a r g s = v a r s ( ap . p a r s e a r g s ( ) )
# grab t he l i s t o f URLs from t he i n p u t f i l e , then i n i t i a l i z e the
# t o t a l number o f images downloaded t h u s f a r
rows = open ( a r g s [ ” u r l s ” ] ) . r e a d ( ) . s t r i p ( ) . s p l i t ( ”\n ”)
t o t a l = 0
# l o o p p e l a s URLs
f o r u r l i n rows :
t r y :
# t e n t a b a i x a r a imagem
r = r e q u e s t s . g e t ( u r l , t i m e o u t =60)
# s a l v a a imagem
p = os . path . sep . j o i n ( [ a r g s [ ”output ”] , ”{} . j p g ”. fo rmat (
s t r ( t o t a l ) . z f i l l ( 8 ) ) ] )
f = open ( p , ”wb ”)
f . w r i t e ( r . c o n t e n t )
f . c l o s e ( )
# i n c r e m e n t a o c o n t a d o r
p r i n t ( ”[ INFO ] downloaded : {} ”. fo rmat ( p ) )
t o t a l += 1
# c u i d a das e x c e c o e s no download
e x c e p t :
p r i n t ( ”[ INFO ] e r r o r download ing { } . . . s k i p p i n g ”. fo rmat ( p ) )
APENDICE A. Codigo para download das imagens do dataset 60
# l o o p p e l a s imagens
f o r imagePath i n p a t h s . l i s t i m a g e s ( a r g s [ ”output ” ] ) :
# f l a g para d e l e t a r a imagem
d e l e t e = F a l s e
# t e n t a a b r i r a imagem na openCV
t r y :
image = cv2 . imread ( imagePath )
# s e image = None , a imagem e s t a corrompida , p o r t a n t o d e l e t a r = t r u e
i f image i s None :
p r i n t ( ”None ”)
d e l e t e = True
# em caso de excecao , a imagem e s t a corrompida , p o r t a n t o d e l e t a r = t r u e
e x c e p t :
p r i n t ( ”Except ”)
d e l e t e = True
# d e l e t a r imagens f l a g a d a s a n t e r i o r m e n t e
i f d e l e t e :
p r i n t ( ”[ INFO ] d e l e t i n g {} ”. fo rmat ( imagePath ) )
os . remove ( imagePath )
61
APENDICE B – Codigo da arquitetura da rede LeNet
# i m p o r t t he n e c e s s a r y packages
from k e r a s . models i m p o r t S e q u e n t i a l
from k e r a s . l a y e r s . c o n v o l u t i o n a l i m p o r t Conv2D
from k e r a s . l a y e r s . c o n v o l u t i o n a l i m p o r t MaxPooling2D
from k e r a s . l a y e r s . c o r e i m p o r t A c t i v a t i o n
from k e r a s . l a y e r s . c o r e i m p o r t F l a t t e n
from k e r a s . l a y e r s . c o r e i m p o r t Dense
from k e r a s i m p o r t backend as K
c l a s s LeNet :
@ s t a t i c m e t h o d
d e f b u i l d ( width , h e i g h t , depth , c l a s s e s ) :
# i n i t i a l i z e t he model
model = S e q u e n t i a l ( )
i n p u t S h a p e = ( h e i g h t , width , depth )
# i f we a r e u s i n g ”c h a n n e l s f i r s t ” , update the i n p u t shape
i f K. i m a g e d a t a f o r m a t ( ) == ” c h a n n e l s f i r s t ” :
i n p u t S h a p e = ( depth , h e i g h t , w idth )
# f i r s t s e t o f CONV => RELU => POOL l a y e r s
model . add ( Conv2D ( 2 0 , ( 5 , 5) , padd ing=”same ” ,
i n p u t s h a p e=i n p u t S h a p e ) )
model . add ( A c t i v a t i o n ( ” r e l u ”) )
model . add ( MaxPooling2D ( p o o l s i z e =(2 , 2) , s t r i d e s =(2 , 2) ) )
# second s e t o f CONV => RELU => POOL l a y e r s
model . add ( Conv2D ( 5 0 , ( 5 , 5) , padd ing=”same ”) )
model . add ( A c t i v a t i o n ( ” r e l u ”) )
model . add ( MaxPooling2D ( p o o l s i z e =(2 , 2) , s t r i d e s =(2 , 2) ) )
# f i r s t ( and o n l y ) s e t o f FC => RELU l a y e r s
model . add ( F l a t t e n ( ) )
model . add ( Dense ( 5 0 0 ) )
model . add ( A c t i v a t i o n ( ” r e l u ”) )
# softmax c l a s s i f i e r
model . add ( Dense ( c l a s s e s ) )
model . add ( A c t i v a t i o n ( ”sof tmax ”) )
# r e t u r n the c o n s t r u c t e d network a r c h i t e c t u r e
r e t u r n model
62
APENDICE C – Codigo para treinamento da rede neural
# USAGE
# python t r a i n n e t w o r k . py −−d a t a s e t images −−model f i r e n o f i r e . model
# s e t t he m a t p l o t l i b backend so f i g u r e s can be sav ed i n t he background
i m p o r t m a t p l o t l i b
m a t p l o t l i b . use ( ”Agg ”)
# i m p o r t t he n e c e s s a r y packages
from k e r a s . p r e p r o c e s s i n g . image i m p o r t ImageDataGenerator
from k e r a s . o p t i m i z e r s i m p o r t Adam
from s k l e a r n . m o d e l s e l e c t i o n i m p o r t t r a i n t e s t s p l i t
from k e r a s . p r e p r o c e s s i n g . image i m p o r t i m g t o a r r a y
from k e r a s . u t i l s i m p o r t t o c a t e g o r i c a l
from p y i m a g e s e a r c h . l e n e t i m p o r t LeNet
from i m u t i l s i m p o r t p a t h s
i m p o r t m a t p l o t l i b . p y p l o t as p l t
i m p o r t numpy as np
i m p o r t a r g p a r s e
i m p o r t random
i m p o r t cv2
i m p o r t os
# c o n s t r u c t the argument p a r s e and p a r s e the arguments
ap = a r g p a r s e . ArgumentParser ( )
ap . add argument ( ”−d ” , ”−−d a t a s e t ” , r e q u i r e d=True ,
h e l p=”path to i n p u t d a t a s e t ”)
ap . add argument ( ”−m” , ”−−model ” , r e q u i r e d=True ,
h e l p=”path to output model ”)
ap . add argument ( ”−p ” , ”−−p l o t ” , t y p e=s t r , d e f a u l t=”p l o t . png ” ,
h e l p=”path to output l o s s / a c c u r a c y p l o t ”)
a r g s = v a r s ( ap . p a r s e a r g s ( ) )
# i n i t i a l i z e t he number o f epochs to t r a i n f o r , i n i t i a l e a r n i n g r a t e ,
# and batch s i z e
EPOCHS = 25
INIT LR = 1e−3
BS = 32
# i n i t i a l i z e t he data and l a b e l s
p r i n t ( ”[ INFO ] l o a d i n g images . . . ”)
data = [ ]
l a b e l s = [ ]
APENDICE C. Codigo para treinamento da rede neural 63
# grab t he image p a t h s and randomly s h u f f l e them
imagePaths = s o r t e d ( l i s t ( p a t h s . l i s t i m a g e s ( a r g s [ ”d a t a s e t ” ] ) ) )
random . s e e d ( 4 2 )
random . s h u f f l e ( imagePaths )
# l o o p o v e r t he i n p u t images
f o r imagePath i n imagePaths :
# l o a d th e image , pre−p r o c e s s i t , and s t o r e i t i n the data l i s t
image = cv2 . imread ( imagePath )
image = cv2 . r e s i z e ( image , ( 2 8 , 28) )
image = i m g t o a r r a y ( image )
data . append ( image )
# e x t r a c t the c l a s s l a b e l from t he image path and update t he
# l a b e l s l i s t
l a b e l = imagePath . s p l i t ( os . path . sep ) [−2]
l a b e l = 1 i f l a b e l == ” f i r e ” e l s e 0
l a b e l s . append ( l a b e l )
# s c a l e t he raw p i x e l i n t e n s i t i e s to t he rang e [ 0 , 1 ]
data = np . a r r a y ( data , dtype=” f l o a t ”) / 2 5 5 . 0
l a b e l s = np . a r r a y ( l a b e l s )
# p a r t i t i o n t he data i n t o t r a i n i n g and t e s t i n g s p l i t s u s i n g 75% o f
# t he data f o r t r a i n i n g and t he r e m a i n i n g 25% f o r t e s t i n g
( t r a i n X , testX , t r a i n Y , t e s t Y ) = t r a i n t e s t s p l i t ( data ,
l a b e l s , t e s t s i z e =0.25 , r a n d o m s t a t e =42)
# c o n v e r t the l a b e l s from i n t e g e r s to v e c t o r s
t r a i n Y = t o c a t e g o r i c a l ( t r a i n Y , n u m c l a s s e s =2)
t e s t Y = t o c a t e g o r i c a l ( testY , n u m c l a s s e s =2)
# c o n s t r u c t the image g e n e r a t o r f o r data augmentat ion
aug = ImageDataGenerator ( r o t a t i o n r a n g e =30, w i d t h s h i f t r a n g e =0.1 ,
h e i g h t s h i f t r a n g e =0.1 , s h e a r r a n g e =0.2 , zoom range =0.2 ,
h o r i z o n t a l f l i p=True , f i l l m o d e=”n e a r e s t ”)
# i n i t i a l i z e t he model
p r i n t ( ”[ INFO ] c o m p i l i n g model . . . ”)
model = LeNet . b u i l d ( width =28, h e i g h t =28, depth =3, c l a s s e s =2)
opt = Adam( l r=INIT LR , decay=INIT LR / EPOCHS)
model . c o m p i l e ( l o s s=”b i n a r y c r o s s e n t r o p y ” , o p t i m i z e r=opt ,
m e t r i c s =[ ”a c c u r a c y ” ] )
# t r a i n t he network
p r i n t ( ”[ INFO ] t r a i n i n g network . . . ”)
H = model . f i t g e n e r a t o r ( aug . f l o w ( t r a i n X , t r a i n Y , b a t c h s i z e=BS) ,
APENDICE C. Codigo para treinamento da rede neural 64
v a l i d a t i o n d a t a =( testX , t e s t Y ) , s t e p s p e r e p o c h=l e n ( t r a i n X ) // BS ,
epochs=EPOCHS, v e r b o s e =1)
# s a v e the model to d i s k
p r i n t ( ”[ INFO ] s e r i a l i z i n g network . . . ”)
model . s a v e ( a r g s [ ”model ” ] )
# p l o t t he t r a i n i n g l o s s and a c c u r a c y
p l t . s t y l e . use ( ”g g p l o t ”)
p l t . f i g u r e ( )
N = EPOCHS
p l t . p l o t ( np . a rang e ( 0 , N) , H. h i s t o r y [ ” l o s s ”] , l a b e l=” t r a i n l o s s ”)
p l t . p l o t ( np . a rang e ( 0 , N) , H. h i s t o r y [ ” v a l l o s s ”] , l a b e l=” v a l l o s s ”)
p l t . p l o t ( np . a rang e ( 0 , N) , H. h i s t o r y [ ”acc ”] , l a b e l=” t r a i n a c c ”)
p l t . p l o t ( np . a rang e ( 0 , N) , H. h i s t o r y [ ”v a l a c c ”] , l a b e l=”v a l a c c ”)
p l t . t i t l e ( ”T r a i n i n g Loss and Accuracy on F i r e /No F i r e ”)
p l t . x l a b e l ( ”Epoch #”)
p l t . y l a b e l ( ”Loss / Accuracy ”)
p l t . l e g e n d ( l o c=”l o w e r l e f t ”)
p l t . s a v e f i g ( a r g s [ ”p l o t ” ] )
65
APENDICE D – Codigo para teste da rede neural
# USAGE
# python t e s t n e t w o r k . py −−model f i r e n o t f i r e . model −−image images /
examples / . . .
# i m p o r t t he n e c e s s a r y packages
from k e r a s . p r e p r o c e s s i n g . image i m p o r t i m g t o a r r a y
from k e r a s . models i m p o r t l o a d m o d e l
i m p o r t numpy as np
i m p o r t a r g p a r s e
i m p o r t i m u t i l s
i m p o r t cv2
# c o n s t r u c t the argument p a r s e and p a r s e the arguments
ap = a r g p a r s e . ArgumentParser ( )
ap . add argument ( ”−m” , ”−−model ” , r e q u i r e d=True ,
h e l p=”path to t r a i n e d model model ”)
ap . add argument ( ”− i ” , ”−−image ” , r e q u i r e d=True ,
h e l p=”path to i n p u t image ”)
a r g s = v a r s ( ap . p a r s e a r g s ( ) )
# l o a d th e image
image = cv2 . imread ( a r g s [ ”image ” ] )
o r i g = image . copy ( )
# pre−p r o c e s s t he image f o r c l a s s i f i c a t i o n
image = cv2 . r e s i z e ( image , ( 2 8 , 28) )
image = image . a s t y p e ( ” f l o a t ”) / 2 5 5 . 0
image = i m g t o a r r a y ( image )
image = np . expand dims ( image , a x i s =0)
# l o a d th e t r a i n e d c o n v o l u t i o n a l n e u r a l network
p r i n t ( ”[ INFO ] l o a d i n g network . . . ”)
model = l o a d m o d e l ( a r g s [ ”model ” ] )
# c l a s s i f y t he i n p u t image
( n o f i r e , f i r e ) = model . p r e d i c t ( image ) [ 0 ]
# b u i l d t he l a b e l
l a b e l = ”F i r e ” i f f i r e > n o f i r e e l s e ”No F i r e ”
proba = f i r e i f f i r e > n o f i r e e l s e n o f i r e
l a b e l = ”{} : { : . 2 f}%”. format ( l a b e l , proba ∗ 100)
# draw the l a b e l on t he image
APENDICE D. Codigo para teste da rede neural 66
output = i m u t i l s . r e s i z e ( o r i g , w idth =400)
cv2 . putText ( output , l a b e l , ( 1 0 , 25) , cv2 . FONT HERSHEY SIMPLEX ,
0 . 7 , ( 0 , 255 , 0) , 2)
# show the output image
cv2 . imshow ( ”Output ” , output )
cv2 . waitKey ( 0 )
67
APENDICE E – Codigo de deteccao de incendio no sistema embarcado
# USAGE
# python f i r e d e t e c t o r . py
# i m p o r t t he n e c e s s a r y packages
from k e r a s . p r e p r o c e s s i n g . image i m p o r t i m g t o a r r a y
from k e r a s . models i m p o r t l o a d m o d e l
from i m u t i l s . v i d e o i m p o r t VideoStream
from t h r e a d i n g i m p o r t Thread
i m p o r t numpy as np
i m p o r t i m u t i l s
i m p o r t t ime
i m p o r t cv2
i m p o r t os
# d e f i n e t he p a t h s to the F i r e D e t e c t i o n Keras deep l e a r n i n g model and
# a u d i o f i l e
MODEL PATH = ” f i r e n o f i r e . model ”
# i n i t i a l i z e t he t o t a l number o f f r a m e s t h a t ∗ c o n s e c u t i v e l y ∗ c o n t a i n
# f i r e a l o n g w i t h t h r e s h o l d r e q u i r e d to t r i g g e r t he f i r e a larm
TOTAL CONSEC = 0
TOTAL THRESH = 20
# i n i t i a l i z e i s t he f i r e a larm has been t r i g g e r e d
FIRE = F a l s e
# l o a d th e model
p r i n t ( ”[ INFO ] l o a d i n g model . . . ”)
model = l o a d m o d e l (MODEL PATH)
# i n i t i a l i z e t he v i d e o st ream and a l l o w the camera s e n s o r to warm up
p r i n t ( ”[ INFO ] s t a r t i n g v i d e o st ream . . . ”)
#vs = VideoStream ( s r c =0) . s t a r t ( )
vs = VideoStream ( usePiCamera=True ) . s t a r t ( )
t ime . s l e e p ( 2 . 0 )
# l o o p o v e r t he f r a m e s from t he v i d e o st ream
w h i l e True :
# grab t he frame from the t h r e a d e d v i d e o st ream and r e s i z e i t
# to have a maximum width o f 400 p i x e l s
f rame = vs . r e a d ( )
frame = i m u t i l s . r e s i z e ( frame , width =400)
APENDICE E. Codigo de deteccao de incendio no sistema embarcado 68
# p r e p a r e t he image to be c l a s s i f i e d by our deep l e a r n i n g network
image = cv2 . r e s i z e ( frame , ( 2 8 , 28) )
image = image . a s t y p e ( ” f l o a t ”) / 2 5 5 . 0
image = i m g t o a r r a y ( image )
image = np . expand dims ( image , a x i s =0)
# c l a s s i f y t he i n p u t image and i n i t i a l i z e the l a b e l and
# p r o b a b i l i t y o f t he p r e d i c t i o n
( n o F i r e , f i r e ) = model . p r e d i c t ( image ) [ 0 ]
l a b e l = ”No F i r e ”
proba = n o F i r e
# check to s e e i f F i r e was d e t e c t e d u s i n g our c o n v o l u t i o n a l
# n e u r a l network
i f f i r e > n o F i r e :
# update t he l a b e l and p r e d i c t i o n p r o b a b i l i t y
l a b e l = ”F i r e ”
proba = f i r e
#i n c r e m e n t t he t o t a l number o f c o n s e c u t i v e f r a m e s t h a t
#c o n t a i n f i r e
TOTAL CONSEC += 1
# check to s e e i f we s h o u l d r a i s e t he f i r e a larm
i f not FIRE and TOTAL CONSEC >= TOTAL THRESH :
i n d i c a t e t h a t f i r e has been found
FIRE = True
# o t h e r w i s e , r e s e t the t o t a l number o f c o n s e c u t i v e f r a m e s and t he
# f i r e a larm
e l s e :
TOTAL CONSEC = 0
FIRE = F a l s e
# b u i l d t he l a b e l and draw i t on the frame
l a b e l = ”{} : { : . 2 f}%”. format ( l a b e l , proba ∗ 100)
frame = cv2 . putText ( frame , l a b e l , ( 1 0 , 25) ,
cv2 . FONT HERSHEY SIMPLEX , 0 . 7 , ( 0 , 255 , 0) , 2)
# show the output frame
cv2 . imshow ( ”Frame ” , f rame )
key = cv2 . waitKey ( 1 ) & 0xFF
# i f the ‘ q ‘ key was p r e s s e d , b r e a k from t he l o o p
i f key == ord ( ”q ”) :
b r e a k
APENDICE E. Codigo de deteccao de incendio no sistema embarcado 69
# do a b i t o f c l e a n u p
p r i n t ( ”[ INFO ] c l e a n i n g up . . . ”)
cv2 . d e s t r o y A l l W i n d o w s ( )
vs . s t o p ( )
70
APENDICE F – Codigo das activities do aplicativo Android
package edu . u t f p r . a n d r e d i e g o t c c . t e s t e ;
i m p o r t a n d r o i d . a n n o t a t i o n . TargetAp i ;
i m p o r t a n d r o i d . app . N o t i f i c a t i o n M a n a g e r ;
i m p o r t a n d r o i d . app . P e n d i n g I n t e n t ;
i m p o r t a n d r o i d . c o n t e n t . I n t e n t ;
i m p o r t a n d r o i d . g r a p h i c s . B i tmapFactory ;
i m p o r t a n d r o i d . g r a p h i c s . C o l o r ;
i m p o r t a n d r o i d . media . RingtoneManager ;
i m p o r t a n d r o i d . net . U r i ;
i m p o r t a n d r o i d . os . B u i l d ;
i m p o r t a n d r o i d . os . H and le r ;
i m p o r t a n d r o i d . s u p p o r t . a n n o t a t i o n . R e q u i r e s A p i ;
i m p o r t a n d r o i d . s u p p o r t . v4 . app . N o t i f i c a t i o n C o m p a t ;
i m p o r t a n d r o i d . s u p p o r t . v7 . app . AppCompatAct iv i ty ;
i m p o r t a n d r o i d . os . Bundle ;
i m p o r t a n d r o i d . v iew . G r a v i t y ;
i m p o r t a n d r o i d . v iew . Menu ;
i m p o r t a n d r o i d . v iew . MenuItem ;
i m p o r t a n d r o i d . v iew . View ;
i m p o r t a n d r o i d . s u p p o r t . v7 . app . Act ionBar ;
i m p o r t a n d r o i d . w i d g e t . TextView ;
i m p o r t a n d r o i d . w i d g e t . Toast ;
i m p o r t j a v a . i o . B u f f e r e d R e a d e r ;
i m p o r t j a v a . i o . I O E x c e p t i o n ;
i m p o r t j a v a . i o . I np u t S t r e a m Re ad e r ;
i m p o r t j a v a . net . S e r v e r S o c k e t ;
i m p o r t j a v a . net . Socket ;
i m p o r t j a v a . u t i l . O b j e c t s ;
p u b l i c c l a s s M a i n A c t i v i t y e x t e n d s AppCompatAct iv i ty {
p r i v a t e TextView s t a t u s T e x t ;
N o t i f i c a t i o n C o m p a t . B u i l d e r n o t i f i c a t i o n ;
p r i v a t e s t a t i c f i n a l i n t un ique ID = 201612;
@ O v e r r i d e
p r o t e c t e d v o i d o nCreat e ( Bundle s a v e d I n s t a n c e S t a t e ) {s u p e r . onCreate ( s a v e d I n s t a n c e S t a t e ) ;
s e t C o n t e n t V i e w (R . l a y o u t . a c t i v i t y m a i n ) ;
Act ionBar a c t i o n B a r = g e t S u p p o r t A c t i o n B a r ( ) ;
APENDICE F. Codigo das activities do aplicativo Android 71
g e t S u p p o r t A c t i o n B a r ( ) . s e t D i s p l a y O p t i o n s ( Act ionBar .
DISPLAY SHOW CUSTOM) ;
g e t S u p p o r t A c t i o n B a r ( ) . setCustomView (R . l a y o u t . a b s l a y o u t ) ;
a c t i o n B a r . setDisp layShowHomeEnabled ( t r u e ) ;
a c t i o n B a r . s e t I c o n (R . mipmap . n e w i c l a u n c h e r ) ;
a c t i o n B a r . s e t T i t l e (R . s t r i n g . app name ) ;
s t a t u s T e x t = ( TextView ) f i n d V i e w B y I d (R . i d . t e x t v i e w s t a t u s ) ;
n o t i f i c a t i o n = new N o t i f i c a t i o n C o m p a t . B u i l d e r ( t h i s ) ;
n o t i f i c a t i o n . s e t A u t o C a n c e l ( t r u e ) ;
Thread myThread = new Thread ( new MyServerThread ( ) ) ;
myThread . s t a r t ( ) ;
}
c l a s s MyServerThread implements Runnable
{Socket s ;
S e r v e r S o c k e t s s ;
I n pu t St r e a m R e a de r i s r ;
B u f f e r e d R e a d e r br ;
S t r i n g msg ;
Hand le r h = new Hand le r ( ) ;
@ O v e r r i d e
p u b l i c v o i d run ( ) {t r y {
s s = new S e r v e r S o c k e t (8080) ;
w h i l e ( t r u e )
{s = s s . a c c e p t ( ) ;
i s r = new I np u t S t r e a m Re ad e r ( s . g e t I n p u t S t r e a m ( ) ) ;
br = new B u f f e r e d R e a d e r ( i s r ) ;
msg = br . r e a d L i n e ( ) ;
h . p o s t ( new Runnable ( ) {@andro id . s u p p o r t . a n n o t a t i o n . R e q u i r e s A p i ( a p i = B u i l d
. VERSION CODES . KITKAT)
@ O v e r r i d e
p u b l i c v o i d run ( ) {c a l l N o t i f i c a t i o n T e s t ( msg ) ;
i f ( O b j e c t s . e q u a l s ( msg , ”on ”) ) {s t a t u s T e x t . s e t T e x t ( ”DANGER! ”) ;
APENDICE F. Codigo das activities do aplicativo Android 72
s t a t u s T e x t . s e t T e x t C o l o r ( g e t R e s o u r c e s ( ) .
g e t C o l o r (R . c o l o r . d a n g e r S t a t u s ) ) ;
} e l s e i f ( O b j e c t s . e q u a l s ( msg , ” o f f ”) ) {s t a t u s T e x t . s e t T e x t ( ”NORMAL”) ;
s t a t u s T e x t . s e t T e x t C o l o r ( g e t R e s o u r c e s ( ) .
g e t C o l o r (R . c o l o r . n o r m a l S t a t u s ) ) ;
} e l s e i f ( ( ! msg . e q u a l s ( ”om”) ) && ( ! msg . e q u a l s
( ” o f f ”) ) ) {s t a t u s T e x t . s e t T e x t ( ”WARNING”) ;
s t a t u s T e x t . s e t T e x t C o l o r ( g e t R e s o u r c e s ( ) .
g e t C o l o r (R . c o l o r . w a r n i n g S t a t u s ) ) ;
}}
}) ;
}} c a t c h ( I O E x c e p t i o n e ) {
e . p r i n t S t a c k T r a c e ( ) ;
}}
}
@ O v e r r i d e
p u b l i c b o o l e a n onCreateOptionsMenu (Menu menu ) {g e t M e n u I n f l a t e r ( ) . i n f l a t e (R . menu . mymenu , menu ) ;
r e t u r n s u p e r . onCreateOptionsMenu ( menu ) ;
}
@ O v e r r i d e
p u b l i c b o o l e a n o n O p t i o n s I t e m S e l e c t e d ( MenuItem item ) {i n t i d = item . g e t I t e m I d ( ) ;
i f ( i d == R . i d . i n f o b u t t o n ) { }r e t u r n s u p e r . o n O p t i o n s I t e m S e l e c t e d ( i tem ) ;
}
p u b l i c v o i d i n f o B u t t o n C l i c k e d ( MenuItem item ) {Toast t o a s t = Toast . makeText ( t h i s , ”Th i s App Was Deve loped By : Andre
B e r t o n i and Diego Feder . ” , Toast . LENGTH LONG) ;
t o a s t . s e t G r a v i t y ( G r a v i t y .BOTTOM, 0 , 50) ;
t o a s t . show ( ) ;
}
p u b l i c v o i d c a l l C a m e r a A c t i v i t y ( View v iew ) {I n t e n t myIntent = new I n t e n t ( M a i n A c t i v i t y . t h i s , C a m e r a A c t i v i t y .
c l a s s ) ;
M a i n A c t i v i t y . t h i s . s t a r t A c t i v i t y ( myIntent ) ;
}
APENDICE F. Codigo das activities do aplicativo Android 73
@TargetApi ( B u i l d . VERSION CODES . KITKAT)
@ R e q u i r e s A p i ( a p i = B u i l d . VERSION CODES . KITKAT)
p u b l i c v o i d c a l l N o t i f i c a t i o n T e s t ( S t r i n g msg ) {l o n g [ ] l o n g p a t t e r n = {5 0 0 , 5 0 0 , 5 0 0 , 5 0 0 , 5 0 0 , 5 0 0 , 5 0 0 , 5 0 0 , 5 0 0} ;
l o n g [ ] s h o r t p a t t e r n = {1000 , 1000 , 1 0 0 0 ,} ;
U r i a la rmsound ;
n o t i f i c a t i o n . setWhen ( System . c u r r e n t T i m e M i l l i s ( ) ) ;
n o t i f i c a t i o n . s e t P r i o r i t y ( N o t i f i c a t i o n C o m p a t . PRIORITY HIGH ) ;
n o t i f i c a t i o n . s e t V i s i b i l i t y ( N o t i f i c a t i o n C o m p a t . VISIBILITY PUBLIC ) ;
i f ( O b j e c t s . e q u a l s ( msg , ”on ”) ) {n o t i f i c a t i o n . s e t S m a l l I c o n (R . d r a w a b l e . i c b a s e l i n e w a r n i n g 2 4 p x ) ;
n o t i f i c a t i o n . s e t L a r g e I c o n ( BitmapFactory . d e c o d e R e s o u r c e (
g e t R e s o u r c e s ( ) , R . d r a w a b l e . i c b a s e l i n e w a r n i n g 2 4 p x ) ) ; // . bmp
n o t i f i c a t i o n . s e t V i b r a t e ( l o n g p a t t e r n ) ;
n o t i f i c a t i o n . s e t L i g h t s ( C o l o r . RED, 30000 , 3000) ;
a larmsound = RingtoneManager . g e t D e f a u l t U r i ( RingtoneManager .
TYPE ALARM) ;
n o t i f i c a t i o n . setSound ( a larmsound ) ;
n o t i f i c a t i o n . s e t T i c k e r ( ”WARNING”) ;
n o t i f i c a t i o n . s e t C o n t e n t T i t l e ( ”DANGER! ”) ;
msg = ”THE FIRE ALARM HAS BEEN ACTIVATED ! ”;
} e l s e i f ( O b j e c t s . e q u a l s ( msg , ” o f f ”) ) {n o t i f i c a t i o n . s e t S m a l l I c o n (R . d r a w a b l e .
i c b a s e l i n e e r r o r o u t l i n e 2 4 p x ) ;
n o t i f i c a t i o n . s e t L a r g e I c o n ( BitmapFactory . d e c o d e R e s o u r c e (
g e t R e s o u r c e s ( ) , R . d r a w a b l e . i c b a s e l i n e e r r o r o u t l i n e 2 4 p x ) ) ; // . bmp
n o t i f i c a t i o n . s e t V i b r a t e ( l o n g p a t t e r n ) ;
n o t i f i c a t i o n . s e t L i g h t s ( C o l o r . GREEN, 30000 , 3000) ;
a larmsound = RingtoneManager . g e t D e f a u l t U r i ( RingtoneManager .
TYPE NOTIFICATION ) ;
n o t i f i c a t i o n . setSound ( a larmsound ) ;
n o t i f i c a t i o n . s e t T i c k e r ( ”NOTIFICATION ”) ;
n o t i f i c a t i o n . s e t C o n t e n t T i t l e ( ”ALERT . . . ”) ;
msg = ”The F i r e Has Been Put Out . ” ;
} e l s e i f ( ( ! msg . e q u a l s ( ”om”) ) && ( ! msg . e q u a l s ( ” o f f ”) ) ) {n o t i f i c a t i o n . s e t S m a l l I c o n (R . d r a w a b l e .
i c b a s e l i n e l i n k e d c a m e r a 2 4 p x ) ;
n o t i f i c a t i o n . s e t L a r g e I c o n ( BitmapFactory . d e c o d e R e s o u r c e (
g e t R e s o u r c e s ( ) , R . d r a w a b l e . i c b a s e l i n e l i n k e d c a m e r a 2 4 p x ) ) ; // . bmp
n o t i f i c a t i o n . s e t V i b r a t e ( s h o r t p a t t e r n ) ;
n o t i f i c a t i o n . s e t L i g h t s ( C o l o r . WHITE, 30000 , 3000) ;
APENDICE F. Codigo das activities do aplicativo Android 74
a larmsound = RingtoneManager . g e t D e f a u l t U r i ( RingtoneManager .
TYPE NOTIFICATION ) ;
n o t i f i c a t i o n . setSound ( a larmsound ) ;
n o t i f i c a t i o n . s e t T i c k e r ( ”NOTIFICATION ”) ;
n o t i f i c a t i o n . s e t C o n t e n t T i t l e ( ”S t a t u s Update ”) ;
msg = ”C l i c k Here To View Camera . ” ;
}
n o t i f i c a t i o n . s e t C o n t e n t T e x t ( msg ) ;
I n t e n t i n t e n t = new I n t e n t ( t h i s , C a m e r a A c t i v i t y . c l a s s ) ;
i n t e n t . s e t F l a g s ( I n t e n t . FLAG ACTIVITY REORDER TO FRONT) ;
P e n d i n g I n t e n t p e n d i n g i n t e n t = P e n d i n g I n t e n t . g e t A c t i v i t i e s ( t h i s , 0 ,
new I n t e n t [ ] { i n t e n t } , P e n d i n g I n t e n t . FLAG CANCEL CURRENT) ;
n o t i f i c a t i o n . s e t C o n t e n t I n t e n t ( p e n d i n g i n t e n t ) ;
N o t i f i c a t i o n M a n a g e r nm = ( N o t i f i c a t i o n M a n a g e r ) g e t S y s t e m S e r v i c e (
NOTIFICATION SERVICE ) ;
nm . n o t i f y ( uniqueID , n o t i f i c a t i o n . b u i l d ( ) ) ;
}}
package edu . u t f p r . a n d r e d i e g o t c c . t e s t e ;
i m p o r t a n d r o i d . s u p p o r t . v7 . app . Act ionBar ;
i m p o r t a n d r o i d . s u p p o r t . v7 . app . AppCompatAct iv i ty ;
i m p o r t a n d r o i d . os . Bundle ;
i m p o r t a n d r o i d . w e b k i t . WebSett ings ;
i m p o r t a n d r o i d . w e b k i t . WebView ;
p u b l i c c l a s s C a m e r a A c t i v i t y e x t e n d s AppCompatAct iv i ty {
p r i v a t e WebView myWebView ;
@ O v e r r i d e
p r o t e c t e d v o i d o nCreat e ( Bundle s a v e d I n s t a n c e S t a t e ) {s u p e r . onCreate ( s a v e d I n s t a n c e S t a t e ) ;
s e t C o n t e n t V i e w (R . l a y o u t . a c t i v i t y c a m e r a ) ;
Act ionBar a c t i o n B a r = g e t S u p p o r t A c t i o n B a r ( ) ;
g e t S u p p o r t A c t i o n B a r ( ) . setDisp layHomeAsUpEnabled ( t r u e ) ;
a c t i o n B a r . setDisp layShowHomeEnabled ( t r u e ) ;
APENDICE F. Codigo das activities do aplicativo Android 75
a c t i o n B a r . s e t T i t l e (R . s t r i n g . c a m e r a a c t i v i t y ) ;
myWebView = ( WebView ) f i n d V i e w B y I d (R . i d . webView ) ;
WebSett ings w e b S e t t i n g s = myWebView . g e t S e t t i n g s ( ) ;
w e b S e t t i n g s . s e t J a v a S c r i p t E n a b l e d ( t r u e ) ;
myWebView . l o a d U r l ( ”h t t p : / / 1 9 2 . 1 6 8 . 1 0 0 . 5 4 : 8 0 8 1 / ”) ;
}}
76
APENDICE G – Codigo dos layouts do aplicativo Android
<? xml v e r s i o n=”1 . 0 ” e n c o d i n g=”u t f−8 ”?>
<L i n e a r L a y o u t x m l n s : a n d r o i d=”h t t p : // schemas . a n d r o i d . com/ apk / r e s / a n d r o i d ”
x m l n s : a p p=”h t t p : // schemas . a n d r o i d . com/ apk / r e s−auto ”
x m l n s : t o o l s=”h t t p : // schemas . a n d r o i d . com/ t o o l s ”
a n d r o i d : l a y o u t w i d t h=”match parent ”
a n d r o i d : l a y o u t h e i g h t=”match parent ”
a n d r o i d : b a c k g r o u n d=”@drawable / g r a d i e n t ”
t o o l s : c o n t e x t=”. M a i n A c t i v i t y ”
a n d r o i d : o r i e n t a t i o n=” v e r t i c a l ”>
<Space
a n d r o i d : l a y o u t w i d t h=”match parent ”
a n d r o i d : l a y o u t h e i g h t=”25 dp ” />
<TextView
a n d r o i d : l a y o u t w i d t h=”match parent ”
a n d r o i d : l a y o u t h e i g h t=”w r a p c o n t e n t ”
a n d r o i d : g r a v i t y=”c e n t e r ”
a n d r o i d : t e x t C o l o r=”@ c o l o r / t e x t C o l o r 1 ”
a n d r o i d : t e x t S t y l e=”b o l d ”
a n d r o i d : t e x t=”STATUS: ”
a n d r o i d : t e x t S i z e=”40 dp ” />
<R e l a t i v e L a y o u t
a n d r o i d : l a y o u t w i d t h=”w r a p c o n t e n t ”
a n d r o i d : l a y o u t h e i g h t=”w r a p c o n t e n t ”>
<ImageView
a n d r o i d : l a y o u t w i d t h=”match parent ”
a n d r o i d : l a y o u t h e i g h t=”200 dp ”
a n d r o i d : b a c k g r o u n d=”@drawable / imagev iew draw ”
a n d r o i d : l a y o u t m a r g i n H o r i z o n t a l=”50 dp ”
a n d r o i d : l a y o u t m a r g i n T o p=”15 dp ” />
<TextView
a n d r o i d : i d=”@+i d / t e x t v i e w s t a t u s ”
a n d r o i d : l a y o u t w i d t h=”match parent ”
a n d r o i d : l a y o u t h e i g h t=”w r a p c o n t e n t ”
a n d r o i d : l a y o u t m a r g i n T o p=”75 dp ”
a n d r o i d : t e x t S t y l e=”b o l d ”
APENDICE G. Codigo dos layouts do aplicativo Android 77
a n d r o i d : g r a v i t y=”c e n t e r ”
a n d r o i d : t e x t=”@ s t r i n g / s t a t u s T e x t ”
a n d r o i d : f o n t F a m i l y=”sans−s e r i f −s m a l l c a p s ”
a n d r o i d : t e x t S i z e=”55 dp ”
a n d r o i d : t e x t A l i g n m e n t=”c e n t e r ”
a n d r o i d : t e x t C o l o r=”@ c o l o r / n o r m a l S t a t u s ” />
</ R e l a t i v e L a y o u t>
<Space
a n d r o i d : l a y o u t w i d t h=”match parent ”
a n d r o i d : l a y o u t h e i g h t=”40 dp ” />
<Button
a n d r o i d : i d=”@+i d / my button1 ”
a n d r o i d : l a y o u t w i d t h=”match parent ”
a n d r o i d : l a y o u t h e i g h t=”80 dp ”
a n d r o i d : l a y o u t m a r g i n H o r i z o n t a l=”50 dp ”
a n d r o i d : b a c k g r o u n d=”@drawable / my button ”
a n d r o i d : t e x t=”@ s t r i n g / c a l l C a m e r a A c t i v i t y ”
a n d r o i d : g r a v i t y=”c e n t e r ”
a n d r o i d : t e x t A l l C a p s=”t r u e ”
a n d r o i d : t e x t C o l o r=”@ c o l o r / t e x t C o l o r 1 ”
a n d r o i d : t e x t S i z e=”24 dp ”
a n d r o i d : o n C l i c k=”c a l l C a m e r a A c t i v i t y ”/>
<Space
a n d r o i d : l a y o u t w i d t h=”match parent ”
a n d r o i d : l a y o u t h e i g h t=”25 dp ” />
<Button
a n d r o i d : i d=”@+i d / my button2 ”
a n d r o i d : l a y o u t w i d t h=”match parent ”
a n d r o i d : l a y o u t h e i g h t=”40 dp ”
a n d r o i d : l a y o u t m a r g i n H o r i z o n t a l=”50 dp ”
a n d r o i d : b a c k g r o u n d=”@drawable / my button ”
a n d r o i d : t e x t=”@ s t r i n g / n o t i f i c a t i o n T e s t ”
a n d r o i d : t e x t A l l C a p s=”t r u e ”
a n d r o i d : t e x t C o l o r=”@ c o l o r / t e x t C o l o r 1 ”
a n d r o i d : t e x t S i z e=”24 dp ”
a n d r o i d : v i s i b i l i t y =” i n v i s i b l e ” />
<!−−a n d r o i d : o n C l i c k=” c a l l N o t i f i c a t i o n T e s t ”−−>
APENDICE G. Codigo dos layouts do aplicativo Android 78
</ L i n e a r L a y o u t>
<? xml v e r s i o n=”1 . 0 ” e n c o d i n g=”u t f−8 ”?>
<a n d r o i d . s u p p o r t . c o n s t r a i n t . C o n s t r a i n t L a y o u t x m l n s : a n d r o i d=”h t t p : // schemas .
a n d r o i d . com/ apk / r e s / a n d r o i d ”
x m l n s : a p p=”h t t p : // schemas . a n d r o i d . com/ apk / r e s−auto ”
x m l n s : t o o l s=”h t t p : // schemas . a n d r o i d . com/ t o o l s ”
a n d r o i d : l a y o u t w i d t h=”match parent ”
a n d r o i d : l a y o u t h e i g h t=”match parent ”
t o o l s : c o n t e x t=”. C a m e r a A c t i v i t y ”>
<WebView
a n d r o i d : l a y o u t w i d t h=”match parent ”
a n d r o i d : l a y o u t h e i g h t=”match parent ”
t o o l s : l a y o u t e d i t o r a b s o l u t e X=”8dp ”
t o o l s : l a y o u t e d i t o r a b s o l u t e Y=”8dp ”
a n d r o i d : i d=”@+i d /webView ”/>
</ a n d r o i d . s u p p o r t . c o n s t r a i n t . C o n s t r a i n t L a y o u t>
79
APENDICE H – Codigo do Android Manifest
<? xml v e r s i o n=”1 . 0 ” e n c o d i n g=”u t f−8 ”?>
<m a n i f e s t x m l n s : a n d r o i d=”h t t p : // schemas . a n d r o i d . com/ apk / r e s / a n d r o i d ”
package=”edu . u t f p r . a n d r e d i e g o t c c . t e s t e ”>
<uses−p e r m i s s i o n a n d r o i d : n a m e=”a n d r o i d . p e r m i s s i o n . INTERNET ” />
<uses−p e r m i s s i o n a n d r o i d : n a m e=”a n d r o i d . p e r m i s s i o n . VIBRATE ” />
<a p p l i c a t i o n
a n d r o i d : a l l o w B a c k u p=”t r u e ”
a n d r o i d : i c o n=”@mipmap/ n e w i c l a u n c h e r ”
a n d r o i d : l a b e l=”@ s t r i n g / app name ”
a n d r o i d : r o u n d I c o n=”@mipmap/ n e w i c l a u n c h e r r o u n d ”
a n d r o i d : s u p p o r t s R t l=”t r u e ”
a n d r o i d : t h e m e=”@ s t y l e /AppTheme ”>
<a c t i v i t y
a n d r o i d : n a m e=”. M a i n A c t i v i t y ”
a n d r o i d : l a u n c h M o d e=”s i n g l e T a s k ”>
< i n t e n t− f i l t e r>
<a c t i o n a n d r o i d : n a m e=”a n d r o i d . i n t e n t . a c t i o n . MAIN ” />
<c a t e g o r y a n d r o i d : n a m e=”a n d r o i d . i n t e n t . c a t e g o r y .LAUNCHER” /
>
</ i n t e n t− f i l t e r>
</ a c t i v i t y>
<a c t i v i t y
a n d r o i d : n a m e=”. C a m e r a A c t i v i t y ”
a n d r o i d : p a r e n t A c t i v i t y N a m e=”. M a i n A c t i v i t y ”
a n d r o i d : l a u n c h M o d e=”s i n g l e T a s k ”>
</ a c t i v i t y>
</ a p p l i c a t i o n>
</ m a n i f e s t>
80
APENDICE I – Codigo para comunicacao do Raspberry Pi ao aplicativo Android
i m p o r t j a v a . net . Socket ;
i m p o r t j a v a . net . S e r v e r S o c k e t ;
i m p o r t j a v a . i o . P r i n t W r i t e r ;
i m p o r t j a v a . i o . I O E x c e p t i o n ;
p u b l i c c l a s s comunic
{p u b l i c comunic ( )
{
}
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s )
{t r y {
S t r i n g one = a r g s [ 0 ] ;
Socket s = new Socket ( ”1 9 2 . 1 6 8 . 1 0 0 . 5 2 ” , 8080) ;
P r i n t W r i t e r pw = new P r i n t W r i t e r ( s . getOutputStream ( ) ) ;
pw . w r i t e ( one ) ;
pw . f l u s h ( ) ;
pw . c l o s e ( ) ;
s . c l o s e ( ) ;
} c a t c h ( I O E x c e p t i o n e ) {e . p r i n t S t a c k T r a c e ( ) ;
}}
}