REDE NEURAL CONVOLUCIONAL APLICADA A VIS AO...

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


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


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


_____________________________________

Prof. Me. Luiz Fernando Copetti


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


berry Pi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44


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


(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


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


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


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


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.


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


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.


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.


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.


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.


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


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.


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.


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).


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


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.


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


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.


Figura 16 – Codigo Python para download das imagens.


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.


Figura 17 – Codigo responsavel pela verificacao da integridade das imagens baixadas.


Figura 18 – Download das imagens pelo terminal Anaconda.


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


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.


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.


Figura 20 – Bibliotecas utilizadas no arquivo train network.py.


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.


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.


Figura 22 – Codigo de inicializacao das variaveis de treinamento, listas e diretorios.


Em seguida, conforme ilustrado na figura 23, realizamos o pre-processamento das

imagens.

Figura 23 – Codigo para pre-processamento das imagens.


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.


Figura 24 – Estrutura do diretorio do dataset.


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.


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


Figura 26 – Criacao de dados atraves da ImageDataGenerator().


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.


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.


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%.


Figura 29 – Treinamento de redes neurais - precisao e perdas.



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.


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


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!


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.


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.


Figura 33 – Visualizacao da CameraActivity.


Figura 34 – Fluxograma simplificado da MainActivity.



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.


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:


Figura 36 – Comandos utilizados para instalacao das bibliotecas HDF5 e h5py no Raspberry Pi.




Para testar se o ambiente estava corretamente configurado e com todas as bibliotecas

compiladas, executamos os seguintes comandos no Raspberry Pi:



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


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.


Figura 40 – Declara e importa o modelo de rede neural a ser utilizado pelo Raspberry Pi.


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.



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.


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.


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.


Figura 44 – Codigo para pre-processamento e envio dos frames para a rede neural.


Figura 45 – Codigo de classificacao das imagens.


Figura 46 – Codigo de acionamento do alarme.


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.


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.


Figura 48 – Construcao do frame para exibicao na tela.


Figura 49 – Deteccao de fogo na imagem com 93,88% de confianca.


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.


Figura 50 – Codigo responsavel pelo envio de novos eventos.


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.


Figura 51 – Codigo responsavel pela visualizacao do vıdeo.


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.


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.


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.



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.




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.


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.


Figura 57 – Teste em luminosidade, luz - apos devido treinamento.


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.


Figura 58 – Captura de tela durante teste de tempo real.


Figura 59 – Captura de tela do aplicativo apos recebimento de notificacao.


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.

https://developer.android.com/guide/components/activities?hl=pt-br

https://developer.android.com/guide/components/activities?hl=pt-br

https://ieeexplore.ieee.org/document/846287/

https://ieeexplore.ieee.org/document/846287/

https://arxiv.org/abs/1206.5538

https://github.com/janishar/mit-deep-learning-book-pdf

http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf

https://www.raspberrypi.org/magpi/raspberry-pi-3-specs-benchmarks/

https://www.raspberrypi.org/magpi/raspberry-pi-3-specs-benchmarks/

https://www.positivehealthwellness.com/fitness/8-ways-technology-improving-health/

https://www.positivehealthwellness.com/fitness/8-ways-technology-improving-health/

http://www.dainf.ct.utfpr.edu.br/~douglas/index.htm

http://www.dainf.ct.utfpr.edu.br/~douglas/index.htm

https://www.sprinklerbrasil.org.br/imprensa/brasil-e-o-3o-pais-com-o-maior-numero-de-mortes-por-incendio-newsletter-no-5/

https://www.sprinklerbrasil.org.br/imprensa/brasil-e-o-3o-pais-com-o-maior-numero-de-mortes-por-incendio-newsletter-no-5/

https://sisu.ut.ee/imageprocessing/book/1

https://sisu.ut.ee/imageprocessing/book/1

https://www.techopedia.com/definition/10556/digital-video-camera-dvcam

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


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 ( 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 ) )


# 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 ”)


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 random

i m p o r t cv2

i m p o r t os



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 ”)


# 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 / . . .



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 i m u t i l s

i m p o r t cv2



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 ”)


# 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 = 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



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 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 = 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! ”) ;


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”) ;


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”) ;


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 ) ;

}


@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 ) ;


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) ;


TYPE NOTIFICATION ) ;


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 ) ;


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) ;



TYPE NOTIFICATION ) ;


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 ) ;


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 h e i g h t=”25 dp ” />

<TextView


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 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 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 : 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



<Button

a n d r o i d : i d=”@+i d / my button1 ”




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 : t e x t A l l C a p s=”t r u e ”



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



<Button

a n d r o i d : i d=”@+i d / my button2 ”




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 : 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>


<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 ”



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



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


<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 ( ) ;

}}

}

REDE NEURAL CONVOLUCIONAL APLICADA A VIS AO...

Documents

Transcript of REDE NEURAL CONVOLUCIONAL APLICADA A VIS AO...