INSTITUTO FEDERAL DO ESPÍRITO SANTO
PÓS-GRADUAÇÃO LATO SENSU EM ENGENHARIA ELÉTRICA COM ÊNFASE
EM SISTEMAS INTELIGENTES APLICADOS À AUTOMAÇÃO
FREDERICO LUIS DE AZEVEDO
DETECÇÃO DA MATURAÇÃO DE FRUTOS DE CAFÉ UTILIZANDO UMA
SOLUÇÃO EMBARCADA
VITÓRIA
2015
FREDERICO LUIS DE AZEVEDO
DETECÇÃO DA MATURAÇÃO DE FRUTOS DE CAFÉ UTILIZANDO UMA
SOLUÇÃO EMBARCADA
Monografia apresentada ao Curso de PósGraduação Lato Sensu em Engenharia Elétrica
com Ênfase em Sistemas Inteligentes Aplicados à
Automação do Instituto Federal do Espírito Santo
como requisito parcial para obtenção do
certificado
de
Especialista
em
Sistemas
Inteligentes Aplicados à Automação.
Orientador: Prof. Msc. Marcelo Brunoro
VITÓRIA
2015
FREDERICO LUIS DE AZEVEDO
DETECÇÃO DO GRAU DE MATURAÇÃO DE CAFÉ ATRAVÉS DE UMA
SOLUÇÃO EMBARCADA
Monografia apresentada ao Curso de PósGraduação Lato Sensu em Engenharia Elétrica
com Ênfase em Sistemas Inteligentes Aplicados à
Automação do Instituto Federal do Espírito Santo
como requisito parcial para obtenção do
certificado
de
Especialista
em
Sistemas
Inteligentes Aplicados à Automação.
Aprovado em 17 de Março de 2015
COMISSÃO EXAMINADORA
________________________________ Prof. Me. Marcelo Brunoro
Instituto Federal do Espírito Santo
Orientador
________________________________ Prof. Me. Alexandre Secchin de Melo
Instituto Federal do Espírito Santo
________________________________ Prof. Me. Douglas Almonfrey
Instituto Federal do Espírito Santo
DECLARAÇÃO DO AUTOR
Declaro, para fins de pesquisa acadêmica, didática e técnico-científica, que este
Trabalho de Conclusão de Curso pode ser parcialmente utilizado, desde que se faça
referência à fonte e ao autor.
Vitória, 17 de Março de 2015.
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Frederico Luis de Azevedo
DEDICATÓRIA
Dedicado a Ana Claudia Stefanelli, que esteve ao meu lado durante todo o
desenvolvimento deste trabalho, por ter tido paciência e cedido seu tempo para me
ajudar.
AGRADECIMENTOS
Agradeço a Deus por ter chegado até aqui.
Agradeço a minha família e todos da família Stefanelli pelo o apoio e base
necessária para o entendimento do problema.
Agradeço aos meus amigos que, de alguma forma, contribuíram para a realização
deste trabalho.
Agradeço ao meu orientador pela paciência e atenção dadas durante os meses de
desenvolvimento do trabalho.
RESUMO
Sendo uma das principais atividades agropecuárias no Brasil, o plantio de café tem
se tornado alvo de diversos estudos de melhorias em seu processo, visto que o
mercado demanda por um produto de melhor qualidade. Um dos fatores que
determinam a qualidade do café é estimar o momento certo de sua colheita, que
deve ser feita quando a maioria dos frutos estiverem maduros. Quanto maior a
quantidade de frutos maduros de uma colheita, maior será a quantidade de grãos de
qualidade que chegam ao consumidor no final do processo. Normalmente esta
quantidade é uma estimativa feita de forma manual pelo próprio agricultor ao
observar a uniformidade de maturação dos frutos quando ainda estão na planta.
Neste trabalho será desenvolvido um sistema embarcado que determina o grau de
maturação dos frutos de uma colheita através de visão computacional, coletando
imagens de amostras e realizando cálculos estimativos. Adicionalmente, o sistema
também será capaz de armazenar os resultados obtidos gerando um histórico que
pode ser utilizado para medir a maturação de diferentes colheitas em épocas
distintas.
Palavras Chave: Qualidade do Café. Maturação de frutos. Visão Computacional.
Sistemas Embarcados.
ABSTRACT
As one of the main agricultural activities in Brazil, the coffee plating has become the
focus of many studies of improvements of its process, as the market demands for a
better quality product. One of the factors that determine the quality of the coffee is to
estimate the timing of their harvest that should be done when most of the fruits are
ripe. The greater the amount of ripe fruit of a crop, the greater the amount of quality
grains that will reach the consumer at the end of the process. Usually this amount is
an estimate done manually by the farmer himself when observing the uniformity of
fruit ripening when they are still in the plant. This work will develop an embedded
system that determines the degree of fruit maturation of a harvest through computer
vision, collecting samples of images and performing estimative calculations.
Additionally, the system will also be capable of storing the results by generating a
history that can be used to measure the ripening of different samples during distinct
periods.
Keywords: Coffee Quality. Fruit Maturation. Computer Vision. Embedded Systems.
LISTA DE FIGURAS
Figura 1 - Planta de café com frutos em diferentes estágios de maturação .............. 11
Figura 2 - Espaço de cores RGB............................................................................... 15
Figura 3 - Espaço de cores HSV ............................................................................... 15
Figura 4 - Exemplo de limiarização binária................................................................ 16
Figura 5 - Imagem antes (a) e depois de um processo de dilatação (b) ................... 17
Figura 6 - Imagem antes (a) e depois de processo de erosão (b) ............................. 18
Figura 7 - Imagem antes (a) e depois do processo de abertura (b) .......................... 18
Figura 8 - Imagem antes (a) e depois do processo de fechamento (b) ..................... 19
Figura 9 - Fluxograma da metodologia do trabalho ................................................... 26
Figura 10 - Amostra de imagem de frutos que atende aos pré-requisitos ................. 29
Figura 11 - Representação do hue em sistemas de visão computacional ................ 31
Figura 12 - Original (a) e resultante (b) da limiarização dos pixels da classe cereja . 32
Figura 13 - Original (a) e resultante (b) da limiarização dos pixels da classe verde.. 32
Figura 14 - Original (a) e resultante (b) da limiarização dos pixels da classe seco ... 33
Figura 15 - Original (a) e resultante (b) da união das imagens binarizadas .............. 34
Figura 16 - Imagem binarizada original (a) e resultante do tratamento (b) ................ 35
Figura 17 - Frutos com pixels pertencentes a mais de uma classe ........................... 35
Figura 18 - Diagrama do display de 7 segmentos e dos botões físicos .................... 39
Figura 19 - Desenho esquemático dos materiais do protótipo .................................. 40
Figura 20 - Fluxograma do algoritmo ........................................................................ 46
Figura 21 - Gráfico dos graus de maturação das coletas .......................................... 51
LISTA DE TABELAS
Tabela 1 - Valores críticos associados ao grau de confiança.................................... 20
Tabela 2 - Valores de limiares das classes de frutos ................................................ 31
Tabela 3 - Detalhes de cada captura realizada pelo o protótipo ............................... 48
Tabela 4 - Detalhes da análise visual das coletas..................................................... 50
SUMÁRIO
1 INTRODUÇÃO ................................................................................................................................ 10 1.1 CONTEXTUALIZAÇÃO .............................................................................................................. 10 1.2 PROBLEMA .................................................................................................................................. 12 1.3 OBJETIVOS .................................................................................................................................. 12 1.4 ORGANIZAÇÃO DO TRABALHO ............................................................................................. 13 2 REFERENCIAL TEÓRICO ............................................................................................................ 14 2.1 ESPAÇO DE CORES ................................................................................................................. 14 2.2 SEGMENTAÇÃO DE IMAGEM ................................................................................................. 16 2.3 TRANSFORMAÇÕES DE IMAGEM ......................................................................................... 17 2.3.1 Dilatação e Erosão ................................................................................................................. 17 2.3.2 Abertura e Fechamento Morfológico ................................................................................ 18 2.4 CÁLCULO AMOSTRAL .............................................................................................................. 19 2.5 CÁLCULO DA INCERTEZA ....................................................................................................... 21 2.6 ESTADO DA ARTE ..................................................................................................................... 22 3 METODOLOGIA ............................................................................................................................. 26 3.1 O PROCESSO DE CAPTURA .................................................................................................. 27 3.1.1 Pré-requisitos .......................................................................................................................... 28 3.2 PROCESSAMENTO ................................................................................................................... 30 3.2.1 Transformação para HSV ..................................................................................................... 30 3.2.2 Detecção dos Frutos ............................................................................................................. 30 3.2.3 Tratamento da Imagem ......................................................................................................... 34 3.2.4 Cálculo do Grau de Maturação ........................................................................................... 35 3.3 ARMAZENAMENTO DOS RESULTADOS .............................................................................. 36 4 IMPLEMENTAÇÃO E RESULTADOS ........................................................................................ 38 4.1 MATERIAIS UTILIZADOS NO PROTÓTIPO .......................................................................... 38 4.2 DESENVOLVIMENTO DO PROGRAMA ................................................................................. 40 4.3 EXPERIMENTOS REALIZADOS .............................................................................................. 46 4.4 RESULTADOS ............................................................................................................................. 47 5 CONCLUSÃO .................................................................................................................................. 52 APÊNDICE A ...................................................................................................................................... 55 APÊNDICE B ...................................................................................................................................... 57 10 1 INTRODUÇÃO
1.1 CONTEXTUALIZAÇÃO
A produção e cultivo de café é uma atividade agropecuária que representa um
importante papel econômico no Brasil, tendo servido de influência no processo de
industrialização da economia e sendo responsável pela geração de emprego e renda
para produtores do campo (CARVALHO, 2002).
No país, o café é um dos mais tradicionais produtos da agricultura com as primeiras
lavouras tendo sido formadas há quase 200 anos e, ao longo desse período,
houveram mudanças em termos de tecnologias de produção e métodos diversos de
colheita e pós-colheita (CARVALHO, 2002, p. 17).
O Brasil também se destaca por ser o segundo maior mercado consumidor de café
do mundo, estando atrás apenas dos Estados Unidos (Instituto Observatório Social,
2002, p.16). Nos últimos anos tem crescido a demanda por cafés de maior
qualidade, e se o produtor tiver acesso a mercados que valorizem esta qualidade,
torna-se interessante investir na produção. É uma oportunidade de agregar valor ao
produto, cujo preço varia de acordo com a qualidade do grão e da bebida. (GIOMO,
2002, p. 13).
A maturação dos frutos é um dos principais fatores que determinam a qualidade do
café, por isso existe tanta preocupação com o estado de maturação e com a
uniformidade de maturação no momento da colheita (GIOMO, 2002, p. 14).
O café, por apresentar mais de uma floração, proporciona em uma mesma planta,
frutos em diferentes fases de maturação (PIMENTA, 1995, p. 3). De acordo com
Pimenta (1995) e Giomo (2002), as fases de maturação dos frutos de café podem
ser classificadas como “Verde” - para frutos imaturos - “Cereja” - para frutos no
estado de maturação ideal - e “Seco” - para frutos em estado tardio de maturação.
A Figura 1 ilustra uma planta com um ramo contendo cafés nos três estágios de
maturação citados anteriormente.
11 Figura 1 - Planta de café com frutos em diferentes estágios de maturação
Fonte: http://emater.go.gov.br, acessado em Set 2014
A máxima qualidade do café é obtida no auge da maturação dos frutos, no estado
Cereja e, à medida que se afasta desse ponto ótimo ocorre perda de qualidade
(GIOMO, 2002, p. 14).
A colheita do café deve ser feita quando a maioria dos frutos se encontrarem em seu
ponto ótimo de maturação (Cereja), sendo que, quando colhido verde ou seco na
planta, pode proporcionar grande incidência de grãos verdes ou pretos que são
considerados os piores defeitos com ação detrimental a qualidade do café.
(PIMENTA, 1995, p. 2).
A colheita de frutos em diferentes estados de maturação interfere negativamente na
qualidade do café, tanto pelo efeito direto na composição química dos grãos, como
pelo efeito indireto da ação de microrganismos no período em que o café permanece
exposto às condições climáticas adversas até o início do processamento (GIOMO,
2002, p. 14).
Cabe ao produtor fazer as análises necessárias e definir o melhor momento para
iniciar a colheita tendo em vista a qualidade almejada. Geralmente opta-se por
realizar a colheita com uma alta porcentagem de frutos imaturos, em torno de 20%
(GIOMO, 2002, p. 15). A escolha da melhor época para efetuar a colheita mostra-se
importante para obtenção de um café com composição química adequada, menores
12 modificações químicas indesejáveis e prejudiciais à qualidade da bebida (PIMENTA,
1995, p. 2).
1.2 PROBLEMA
Visto que cabe ao produtor determinar o momento do início da colheita, não há um
método eficiente para mensurar o grau de maturação dos frutos que serão colhidos.
Normalmente a medição do grau de uniformidade de maturação dos frutos é
realizada manualmente pelo produtor, por meio de sua visão, no momento em que
os frutos são colocados para secagem nos locais apropriados, conhecidos como
terreiros. O método de análise manual é pouco confiável e dependente diretamente
da própria experiência de quem trabalha na área.
Outro problema encontrado é a não existência de registro histórico do grau de
maturação dos frutos de diferentes colheitas e épocas, não sendo possível gerar
uma base de comparação para análises que podem gerar uma melhora contínua no
processo de colheita.
1.3 OBJETIVOS
A solução proposta por este trabalho é detectar o grau de maturação de frutos recém
colhidos de café por meio de técnicas de processamento digital de imagens.
Este trabalho tem como objetivo a construção do protótipo de um sistema de
segregação de cores de imagens de amostras de café no período da pós-colheita,
realizando cálculos preditivos sobre o grau de maturação dos frutos e armazenando
os resultados ao final do processo.
Os cálculos visam classificar os frutos de café em verdes, cerejas e secos por meio
das cores da imagem. O armazenamento dos resultados é feito para manter uma
base histórica de diferentes épocas de colheitas. O software deste trabalho será
desenvolvido para ser executado em uma plataforma embarcada.
13 1.4 ORGANIZAÇÃO DO TRABALHO
Este trabalho possui a seguinte organização:
O segundo capítulo apresenta o referencial teórico utilizado como base para o
desenvolvimento deste trabalho, enquanto o terceiro capítulo aborda a metodologia
do trabalho, apresentando e explicando o passo a passo do fluxograma da
aplicação. Este capítulo também explica como é feito o processo de captura das
imagens e suas regras.
Os detalhes da implementação do protótipo e da aplicação são apresentados no
quarto capítulo, bem como a descrição dos experimentos realizados e os resultados
obtidos.
Por fim, o quinto capítulo apresenta as conclusões resultantes do estudo realizado e
as propostas de melhorias e trabalhos futuros.
14 2 REFERENCIAL TEÓRICO
Neste capítulo serão apresentados os fundamentos teóricos utilizados na
metodologia e na implementação do trabalho. Primeiro serão abordados os aspectos
do processamento digital de imagens, como os espaços de cores que foram
utilizados e a técnica para separar uma região de interesse do fundo de uma
imagem. Também serão mostrados os tratamentos realizados nas imagens, com o
objetivo de eliminar ruídos que interferem na análise e extração de informações.
Em seguida, será abordado o cálculo da quantidade de amostras necessárias para
estimar uma média populacional, considerando que o tamanho da população seja
previamente conhecido. Na sequência será apresentado o método de cálculo da
incerteza do experimento devido à margem de erro do cálculo amostral e ao
aumento de área dos frutos resultante do tratamento da imagem.
Finalmente, este capítulo irá apresentar outros trabalhos semelhantes sobre
classificação de frutos que combinam alguns fundamentos que foram discutidos.
2.1 ESPAÇO DE CORES
Por se tratar de um estudo com um sistema de visão computacional, é importante
definir os espaços de cores que serão utilizados ao longo do trabalho.
O espaço de cores mais encontrado em dispositivos de captura e exibição de
imagens é o RGB, abreviatura para o sistema formado pelas cores Vermelha (Red),
Verde (Green) e Azul (Blue). As misturas de tonalidades destas três cores primárias
são utilizadas para gerar outras cores (GONZALES; WOODS, 2002, p. 290),
conforme ilustrado pela Figura 2:
15 Figura 2 - Espaço de cores RGB
Fonte: http://stackoverflow.com, acessado em Jan 2015
O espaço de cor escolhido para o tratamento das imagens das amostras do trabalho
é o HSV, abreviação do sistema de cores formado pelos componentes de Matiz
(Hue), Saturação (Saturation) e Valor ou Brilho (Value), ilustrado pela Figura 3:
Figura 3 - Espaço de cores HSV
Fonte: http://stackoverflow.com, acessado em Jan 2015
Diferente do RGB, o modelo HSV separa a informação da intensidade (brilho) de
uma imagem da informação de cor (matiz e saturação). Espaços de cores que
possuem estes componentes em separado são ideais para o desenvolvimento de
algoritmos de processamento de imagens (GONZALEZ; WOODS, 2002, p. 295).
16 Por serem modelos derivados, imagens em RGB podem ser convertidas para HSV e
vice-versa através de uma equação de transformação entre espaços de cores
(GONZALEZ; WOODS, 2007, p. 432).
2.2 SEGMENTAÇÃO DE IMAGEM
A segmentação é um processo que separa regiões em uma imagem de acordo com
alguma característica. Um exemplo é a segmentação através das cores da imagem
utilizando o modelo HSV citado anteriormente, que é o mais adequado para este
propósito, por possuir os componentes de cor e brilho separadas (GONZALEZ;
WOODS, 2007, p. 429).
A técnica de segmentação conhecida como Limiarização (ou Thresholding) consiste
em separar as regiões de uma imagem de acordo com o valor de um ou mais
limiares conforme a quantidade de regiões que se deseja identificar. A forma mais
simples de limiarização consiste na bipartição, também conhecida como limiarização
binária, onde os pixels da imagem que estão dentro de um limiar previamente
definido são convertidos para branco e os demais convertidos para preto
(MARQUES FILHO, VIEIRA NETO, 1999, p. 71), conforme ilustrado pela Figura 4:
Figura 4 - Exemplo de limiarização binária
Fonte: http://docs.opencv.org, acessado em Fev. 2015
Uma das dificuldades deste processo reside na determinação do valor mais
adequado de limiarização, ou seja, do ponto de separação dos pixels da imagem
(QUEIROZ, GOMES, 2001, p. 25).
17 2.3 TRANSFORMAÇÕES DE IMAGEM
2.3.1 Dilatação e Erosão
A erosão e dilatação são operações matemáticas da morfologia digital1 aplicadas em
imagens tendo como base um elemento estruturante, que são imagens menores
utilizadas como operadores nas transformações (QUEIROZ, GOMES, 2001, p. 2224).
A dilatação, em geral, faz com que objetos cresçam em tamanho, eliminando
buracos na imagem que são menores do que o elemento estruturante (QUEIROZ,
GOMES, 2001, p.24). Esta é uma técnica utilizada para preencher espaços vazios
no interior de elementos resultantes do processo de segmentação. A Figura 5 ilustra
o processo de dilatação em uma imagem:
Figura 5 - Imagem antes (a) e depois de um processo de dilatação (b)
(a)
(b)
Fonte: Elaborado pelo autor, 2015.
A erosão reduz o tamanho de objetos da imagem, eliminando quaisquer elementos
que sejam menores do que o elemento estruturante (QUEIROZ, GOMES, 2001,
p.24). Esta técnica é utilizada para remover ruídos ou pequenos pixels desconexos
que tenham restado do processo de segmentação. A Figura 6 ilustra o processo de
erosão em uma imagem:
1
Morfologia Digital: Modelagem destinada à descrição ou análise da forma de um objeto digital. O
princípio de morfologia digital se embasa no fato de que a imagem é um conjunto de pontos
elementares que formam subconjuntos elementares bi ou tridimensionais (QUEIROZ, GOMES, 2001,
p.22).
18 Figura 6 - Imagem antes (a) e depois de processo de erosão (b)
(a)
(b)
Fonte: Elaborado pelo autor, 2015.
2.3.2 Abertura e Fechamento Morfológico
As técnicas de abertura e fechamento morfológico de uma imagem são utilizados
para reduzir os efeitos das distorções em objetos causadas pela erosão e dilatação,
explicadas anteriormente.
A abertura morfológica é composta pelo processo de erosão seguida de dilatação,
utilizada para remover objetos muito pequenos e ruídos da imagem e, neste caso,
sem alterar de forma significante o tamanho dos objetos resultantes (GONZALEZ;
WOODS, 2007, p. 657-658). Um exemplo do processo de abertura é ilustrado pela
Figura 7:
Figura 7 - Imagem antes (a) e depois do processo de abertura (b)
(a)
Fonte: Elaborado pelo autor, 2015.
(b)
19 O fechamento morfológico é composto de dilatação seguida de erosão, utilizado
para preencher os espaços vazios no interior dos objetos e, como a técnica anterior,
não altera de forma significativa as dimensões dos objetos da imagem (GONZALEZ;
WOODS, 2007, p. 657-658), conforme ilustrado pela Figura 8:
Figura 8 - Imagem antes (a) e depois do processo de fechamento (b)
(a)
(b)
Fonte: Elaborado pelo autor, 2015.
2.4 CÁLCULO AMOSTRAL
Define-se como Amostra um subconjunto de elementos extraídos de uma
População, que é a coleção completa dos elementos que fazem parte do estudo
(TRIOLA, 1999, p. 3).
Determinar o tamanho de uma amostra que será utilizada como base para
inferências sobre uma população é um fator importante, porque amostras grandes
acarretam em desperdício de tempo e dinheiro e amostras pequenas levam a
resultados não confiáveis (TRIOLA, 1999, p. 149).
De acordo com Triola (1999), o tamanho de uma amostra de estudo de estimativa de
média populacional para uma população finita pode ser definido pela Equação 1:
.
.
Onde:
/
.
²
/
².
²
1
1
20 - Tamanho da amostra
- Tamanho da população
- Desvio padrão populacional da variável do estudo
/ - Valor crítico do grau de confiança desejado - Margem de erro Triola (1995) define que caso o desvio padrão populacional não seja conhecido, o
mesmo pode ser aproximado através da amplitude dos dados (diferença entre o
valor típico do máximo e do mínimo) conforme a Equação 2:
2
4
Quando se trata do grau de maturação de frutos de café recém colhidos, Giomo
(2012) define que os valores mais comuns variam entre 80% e 95%. Neste caso, o
desvio padrão populacional pode ser definido conforme a Equação 3:
95
80
4
15
4
3,75 3
Os graus de confiança mais comuns juntamente com seus valores críticos estão
relacionados na Tabela 1.
Tabela 1 - Valores críticos associados ao grau de confiança
Grau de confiança Valor crítico (
90% 1,645 95% 1,96 99% 2,575 Fonte: TRIOLA, 1999.
/2 ) 21 Caso o tamanho da amostra não retorne um número inteiro após a aplicação da
fórmula, o resultado deve ser arredondado para o próximo inteiro maior (TRIOLA,
1999, p. 149).
2.5 CÁLCULO DA INCERTEZA
Com a existência de várias fontes de incertezas, é necessário que estas
componentes sejam combinadas considerando a mesma base de um desvio-padrão.
Antes de realizar a combinação, seus valores precisam ser divididos por fatores de
acordo com a distribuição de probabilidade. As normalizações para uma distribuição
retangular (
) e para uma distribuição normal (
) estão apresentadas na
Equação 4 (INMETRO, 2012):
√3
2
4
Onde:
- Incerteza-padrão relacionada a uma distribuição retangular
- Limite superior da distribuição retangular
- Limite inferior da distribuição retangular
- Incerteza-padrão relacionada a uma distribuição normal
- Valor médio para ma distribuição normal A incerteza combinada (
) é obtida através da equação euclidiana conforme a
Expressão 5 (INMETRO, 2012):
5
22 Para atender a requisitos de aplicações comerciais (INMETRO, 2012, p. 23), é
preciso ainda calcular a incerteza combinada expandida ( ), que é obtida
multiplicando a incerteza combinada (
) com um fator de abrangência ( ) como
mostra a Equação 6 (INMETRO, 2012). A incerteza combinada expandida será a
incerteza final do resultado do experimento.
∗
6
O valor do fator de abrangência ( ) é tabelado e varia de acordo com a quantidade
de graus de liberdade efetivos (
), calculado através da Equação 7 (INMETRO,
2012):
7
∑
Onde:
- Componente de incerteza-padrão
- Graus de liberdade correspondente a cada componente de incerteza 2.6 ESTADO DA ARTE
Foram pesquisados diversos trabalhos semelhantes na área de visão computacional
relacionados a identificação e processamento de padrões em frutas. Não foram
encontrados trabalhos nesta área voltados diretamente para a classificação de frutos
de café.
De acordo com Oyama et al. (2012) o processo de inspeção manual e visual de
análise de amostras de café é lento e muitas vezes incapaz de satisfazer a demanda
da indústria. Os autores realizaram a construção de uma máquina de visão
23 computacional capaz de classificar os grãos bons – maduros - dos grãos com algum
tipo de defeito como verdes, pretos, entre outros, utilizando uma rede neural para a
classificação. A máquina se situa em um ambiente controlado com uma bandeja de
vidro e duas câmeras de vídeo acima e abaixo da bandeja, permitindo a análise de
toda a superfície dos grãos. A rede neural utilizada é do tipo Perceptron
multicamadas com o algoritmo de retropropagação, sendo esta previamente treinada
utilizando amostras de grãos de café. O algoritmo de Watershed é executado para
rotular cada grão da imagem individualmente. Os valores médios de R, G e B de
cada um dos pixels de cada grão são submetidos à rede neural, e esta os classifica
de acordo com uma classe. A rede neural também classifica e rotula quaisquer
sujeiras que estiverem presentes na imagem.
Para Tezuka (2008) os parâmetros de classificação de frutas são baseados nos
aspectos de textura, cor e área de superfície, sendo que o controle de qualidade
requer um método que seja seguro e confiável para garantir a qualidade do produto.
O trabalho da autora classifica frutas com base na análise de textura abordando o
modelo estatístico, classificação de cor baseado no modelo HSI e cálculo da área de
superfície. As imagens são adquiridas através de uma câmera fotográfica em um
ambiente de iluminação controlada. Estas imagens passam por uma etapa de préprocessamento visando a eliminação de ruídos e a melhoria de contraste, utilizando
a técnica de filtragem de mediana e equalização de histograma. A imagem é
segmentada para a definição da área de interesse onde os cálculos serão
realizados, retirando áreas não necessárias. O modelo da autora analisa a textura
para identificar propriedades físicas do produto, a cor para identificação de injúrias e
estágio de maturação e a área de superfície para analisar qual é a fruta em questão.
Simões e Costa (2003) abordam um modelo de classificação de laranjas baseado
em padrões visuais com ênfase para o tratamento do padrão de cor, de acordo com
a classificação brasileira segundo o centro de qualidade em horticultura que define
as diferentes classes da laranja. A abordagem dos autores utiliza redes neurais
artificiais para classificação de pixels, algoritmo de crescimento de região para
segmentação de imagens, a técnica de contagem simples para a extração de
padrões e o método de agrupamento em células de Voronoi para classificação dos
padrões. A rede neural utilizada para a classificação dos pixels é do tipo Perceptron
24 multicamadas com algoritmo de retropropagação, sendo que os componentes R, G e
B da imagem são submetidos à entrada da rede neural e esta as classifica em
classes: VE (verde-escuro), VC (verde-claro), A (amarelo), LC (laranja-claro) ou LE
(laranja-escuro). A segmentação é feita utilizando o algoritmo de crescimento da
região que mapeia pixels individuais a conjuntos de pixels denominados regiões, ou
seja, áreas conectadas de pixels classificados como uma das cores importantes do
domínio (VE, VC, A, LC, LE). Uma vez identificadas as laranjas da imagem, o
processo de extração de padrões é iniciado utilizando o vetor de cores de cada
laranja, isto é, a quantidade de pixels pertencentes a cada uma das classes de
cores. O processo de classificação dos padrões é feito supondo-se que se conheça
o vetor típico de cada uma das classes de laranjas, e realizando a aproximação de
vetores tendo como base o vetor de cores obtido no passo anterior. Os autores
treinaram a rede neural com 25 exemplos de cada uma das cores importantes do
domínio em um ambiente com diferentes condições de iluminação. Os testes do
sistema foram feitos com 120 imagens de laranjas diferentes igualmente divididas
em cada uma das classes brasileiras.
Yang e colaboradores (2007) estudaram um método de detecção e reconhecimento
de tomates em uma plantação para o processo de colheita automática. Em seu
trabalho foi utilizado uma câmera de visão estérea do tipo BumbleBee2 para criar um
ambiente 3D utilizado na análise dos dados. Os autores utilizaram o método CLG
(Color Layer Growing) para segmentação das imagens das frutas maduras
separando ruídos como folhas e caules. O grupo alvo pode ser localizado através da
segmentação por profundidade. No pré-processamento é aplicado um filtro de passa
baixa para suavizar as imagens visando retificá-las. A retificação também é feita
visando corrigir as imagens de entrada por conta da distorção das lentes. O método
de detecção de bordas é aplicado para permitir a mesma correspondência de pixels
quando há mudanças de brilho, pois o ganho automático das duas câmeras pode
levar a diferentes valores de brilho absolutos para um mesmo pixel. A segmentação
de cores através do CLG segmenta a imagem conectando suas regiões
homogêneas dividindo as regiões pela semelhança de cor. A segmentação por
profundidade é feita utilizando uma combinação de segmentação por cor e
reconstrução 3D. O reconhecimento baseado no formato é feito utilizando a
25 representação do histograma de profundidade classificando, assim, os frutos de
tomate.
26 3 METODOLOGIA
A metodologia utilizada neste trabalho se divide em quatro etapas. A primeira delas
é o processo de aquisição das imagens, que deve ser feito de acordo com um
conjunto de regras estabelecidas, conforme descrito na Seção 3.1.1, de forma a
estar dentro dos padrões necessários de qualidade e quantidade para a análise.
A segunda etapa consiste em fazer o processamento das imagens, segmentando e
detectando cada classe de fruto (Cerejas, Verdes e Secos). A terceira etapa realiza
tratamentos na imagem para eliminar ruídos que possam existir devido ao processo
de segmentação.
A quarta e última etapa faz o cálculo do grau de maturação dos frutos da imagem
recém-tratada e armazena os resultados em um relatório. A Figura 9 ilustra o
fluxograma completo da metodologia descrita.
Figura 9 - Fluxograma da metodologia do trabalho
Fonte: Elaborado pelo autor, 2014.
27 3.1 O PROCESSO DE CAPTURA
A captura de imagens é feita através do protótipo e deve ser realizada em um
terreiro que atenda aos pré-requisitos, citados na próxima seção, onde estão
espalhados os frutos recém colhidos de café. Neste momento inicial, é importante
definir a quantidade de capturas que serão realizadas para estimar os dados de toda
a população, uma vez que o estudo será feito utilizando amostras de café pois,
conforme ressaltado no capítulo anterior, realizar o estudo com grandes populações
gera mais custo e trabalho para o avaliador.
Através da Equação 1 definida na seção 2.4, a quantidade de amostras de imagens
a serem coletadas pode ser estimada a partir da quantidade total de imagens
(população total), do desvio padrão da população, da margem de erro e do valor
crítico do grau de confiança:
.
.
/
.
²
/
².
²
1
8 No caso deste estudo, como o desvio padrão pode sofrer mudança conforme o grau
de maturação dos frutos recém-colhidos, não haveria uma maneira de saber seu
valor sem, de fato, calcular o grau de maturação de toda a população. Desta forma,
o valor do desvio padrão será com base na amplitude dos valores típicos dos graus
de maturação, conforme explicado na Seção 2.4.
3,75 9
Este estudo será feito considerando uma margem de erro de 2 pontos percentuais e
grau de confiança de 95%. Utilizando os dados da Tabela 1, temos que:
/
2 10
1,96 11
28 Substituindo (9), (10) e (11) na equação (8), temos que a quantidade de amostras é
expressa por:
. 3,75 . 1,96 ²
3,75 . 1,96 ² 2 ².
1
12
A quantidade total de imagens ( ) pode ser estimada com base na área total de
ocupação dos frutos no terreiro. Considerando que área de uma imagem capturada
pelo protótipo possui cerca de 192cm² (16cm x 12cm), o total de imagens que
precisam ser feitas em um terreiro em função de seu tamanho em m² pode ser
expresso da seguinte forma:
. 10000 13
192
Onde:
- Quantidade total de imagens a serem capturadas - Área de ocupação dos frutos em m² Caso a Equação 10 não resulte em um valor inteiro, ( ) deve ser arredondado para
o próximo inteiro maior seguindo a mesma regra da equação definida na Seção 2.4.
3.1.1 Pré-requisitos
Os pré-requisitos a seguir abaixo devem ser atendidos para que não haja problemas
no processo de captura e no processamento de modo a comprometer o resultado
final do trabalho.
As capturas das imagens devem ser feitas no momento da pós-colheita quando os
frutos são deixados para secagem. Este é o momento em que os frutos apresentam
a mesma tonalidade de cor de quando foram retirados da planta. Visto que durante o
processo de secagem os frutos perdem sua cor natural, realizar a captura das
imagens em um momento tardio acarreta em perda de informação sobre a real
condição dos frutos no momento da colheita comprometendo, assim, toda a análise.
29 Os frutos recém colhidos precisam estar dispostos de forma aplanada, ou seja, onde
um não sobreponha o outro. Como a câmera possui o eixo do foco perpendicular ao
solo, a eventual sobreposição dos frutos causaria em uma perda importante de
informação. A sobreposição pode ser desfeita manualmente no momento da captura
para aplanar os frutos.
O fundo onde os frutos estão situados, normalmente em cimento ou lona de plástico,
não deve possuir nenhuma tonalidade que está sendo capturada, ou seja, sem tons
de vermelho, verde e preto. Não obedecer a este pré-requisito afeta diretamente o
processo de segmentação de cores levando a resultados inválidos.
Qualquer ruído na imagem deve ser removido, como folhas, galhos ou pequenos
insetos. Estes ruídos causam dois problemas citados anteriormente: eles podem
sobrepor os frutos de café causando perda de informação ou ter a mesma cor dos
frutos dificultando o processo de segregação e gerando informações inválidas.
A Figura 10 mostra um exemplo de amostra de imagem que atende aos prérequisitos citados anteriormente.
Figura 10 - Amostra de imagem de frutos que atende aos pré-requisitos
Fonte: Elaborado pelo autor, 2014.
30 3.2 PROCESSAMENTO
Para cada imagem coletada pelo protótipo, são executados os seguintes
processamentos para estimar o grau de maturação dos frutos da amostra.
3.2.1 Transformação para HSV
Este trabalho utilizará dois espaços de cores diferentes durante a etapa de
manipulação das imagens: O RGB e o HSV.
A imagem dos frutos é coletada no padrão RGB pela câmera, e em seguida é
transformada para o espaço de cores HSV para ser utilizada no processo de
segmentação por cores. A transformação é feita de forma direta, não havendo perda
de qualidade ou de informação da imagem durante este processo.
3.2.2 Detecção dos Frutos
A imagem no formato HSV é submetida a três processos de segmentação, um para
a detecção de cada classe de fruto: Verde, Cereja e Seco. Apesar do alvo principal
ser identificar os pixels correspondentes aos frutos maduros, da classe Cereja, a
identificação de pixels dos frutos Verdes e Secos se faz necessária para saber o
total de pixels que correspondem aos frutos da imagem. Este valor será utilizado no
cálculo do grau de maturação, explicado na próxima seção.
A limarização binária através da cor das três classes foi o procedimento adotado
para separar os pixels de frutos do fundo da imagem. Os valores dos limiares
(mínimos e máximos) dos componentes de H, S e V para cada uma das classes está
definido na Tabela 2. Estes valores foram obtidos através de vários testes com
imagens de amostras de café coletadas como exemplo.
A classe Cereja necessita de dois limiares diferentes para a segmentação pelo fato
da cor vermelha estar nos limites do componente Hue em sistemas de visão
computacional, como mostra a Figura 11.
31 Figura 11 - Representação do Hue em sistemas de visão computacional
Fonte: Elaborado pelo autor, 2015.
Tabela 2 - Valores de limiares das classes de frutos
H (min)
H (máx)
S (min)
S (máx)
V (min)
V (máx)
Cereja (1)
0
14
Cereja (2)
123
179
0
255
0
255
Verde
15
85
15
255
0
255
Seco
0
179
0
122
0
170
Fonte: Elaborado pelo autor, 2014.
Os limiares para a segmentação de frutos Cerejas e Verdes não se sobrepõem, ou
seja, um pixel nunca será classificado como Cereja e Verde ao mesmo tempo.
Todas as três segmentações são feitas sobre a imagem colorida e geram como
saída uma imagem em tons de cinza. A primeira delas é para identificar os pixels da
classe Cereja, que quando identificados são convertidos para a cor Branca, como
mostra a Figura 12.
32 Figura 12 - Original (a) e resultante (b) da limiarização dos pixels da classe Cereja
(a)
(b)
Fonte: Elaborado pelo autor, 2014.
A segunda visa detectar os pixels da classe Verde. Ao serem identificados, estes
são convertidos para a cor Cinza, como mostra a Figura 13.
Figura 13 - Original (a) e resultante (b) da limiarização dos pixels da classe Verde
(a)
(b)
Fonte: Elaborado pelo autor, 2014.
A última segmentação classifica os pixels que pertencem a classe Seco, que ao
serem identificados são convertidos para a cor Cinza Escuro, como mostra a Figura
14:
33 Figura 14 - Original (a) e resultante (b) da limiarização dos pixels da classe Seco
(a)
(b)
Fonte: Elaborado pelo autor, 2014.
Ao final, as três imagens binarizadas são unidas formando uma única imagem com
as cores Preto (o fundo), Branco (pixels da classe Cereja), Cinza (pixels da classe
Verde) e Cinza Escuro (pixels da classe Seco), ilustrado pela Figura 15.
Os frutos da classe Seco, por possuírem tonalidades mais escuras, estão mais
ligados aos componentes de saturação e brilho para serem segmentados, sendo
assim seus limares abrangem todos os valores possíveis de Hue, as cores. Caso
algum pixel seja classificado ao mesmo tempo como “Seco e Cereja” ou “Seco e
Verde”, a classe Seco sempre terá menor precedência e prevalecerá a de maior
importância (Cereja ou Verde).
34 Figura 15 - Original (a) e resultante (b) da união das imagens binarizadas
(a)
(b)
Fonte: Elaborado pelo autor, 2014.
3.2.3 Tratamento da Imagem
Visando eliminar os ruídos provenientes da segmentação, a imagem resultante do
passo anterior contendo as três classes de frutos é submetida ao processo de
abertura morfológica. Este tratamento é necessário pois pixels muito pequenos e
que não representam um fruto podem interferir no cálculo total.
Em seguida, a imagem resultante da abertura é submetida ao processo de
fechamento morfológico visando preencher quaisquer buracos que possam haver no
interior dos frutos. Por conta da grande diferença de tonalidades, é comum que
alguns pixels não tenham sido detectados pela segmentação. Realizar o fechamento
morfológica é um processo importante visto que os frutos de café são sólidos e não
possuem buracos em seu interior.
A imagem resultante dos tratamentos apresenta uma suavização melhor e uma
representação mais homogênea das classes de frutos, como pode ser visto na
Figura 16.
35 Figura 16 - Imagem binarizada original (a) e resultante do tratamento (b)
(a)
(b)
Fonte: Elaborado pelo autor, 2014.
3.2.4 Cálculo do Grau de Maturação
O cálculo do grau de maturação da coleta será feito com base no total de pixels que
foram classificados como Cereja, e não no total de frutos da classe Cereja.
O principal motivo para o resultado ser calculado pelos pixels e não pela quantidade
de frutos maduros é o fato de um único fruto poder ter mais de uma tonalidade
durante o seu amadurecimento, não sendo possível segmentá-lo em uma apenas
uma classe específica. A Figura 17 mostra exemplos de frutos nesta condição.
Figura 17 - Frutos com pixels pertencentes a mais de uma classe
Fonte: Elaborado pelo autor, 2015.
Primeiro, a imagem resultante da Seção 3.2.2 é utilizada para calcular a quantidade
de pixels que possuem a cor diferente de Preto para saber o total de pixels que
correspondem aos frutos. Em seguida é calculado a quantidade de pixels que
36 possuem a cor Branca, que correspondem às tonalidades Cereja que foram
segmentadas.
O grau de maturação em nível percentual é calculado através da quantidade de
pixels Brancos em relação à quantidade total de pixels de frutos presentes na
imagem binarizada resultante dos tratamentos, citada na Seção 3.2.3.
∗ 100
14 Onde:
- Grau de maturação da captura em percentual - Quantidade de pixels Brancos
- Quantidade total de pixels diferentes de preto À medida que outras capturas de imagens vão sendo realizadas, os graus de
maturação vão sendo armazenados para, ao final do processo, ser calculado o
percentual do grau de maturação total a partir da média aritmética dos graus de
maturação de cada captura.
⋯
15 Onde:
- Grau de maturação total em percentual - Grau de maturação da captura
- Quantidade de capturas feitas pelo avaliador 3.3 ARMAZENAMENTO DOS RESULTADOS
Para cada captura de imagem realizada, os valores percentuais calculados do grau
de maturação das amostras são armazenados para que possam ser acessados
posteriormente pelo avaliador.
37 Também são armazenadas, para cada captura, a quantidade total de pixels de frutos
detectados e a quantidade de quantos foram segmentados como Cerejas, Verdes e
Secos. O arquivo também armazena o grau de maturação total relativo a todas as
capturas.
38 4 IMPLEMENTAÇÃO E RESULTADOS
4.1 MATERIAIS UTILIZADOS NO PROTÓTIPO
Para a construção do protótipo foi utilizada uma caixa de plástico revestida
totalmente em papel laminado para que fique imune à incidência de luz exterior. A
caixa é aberta na parte de baixo, sendo que para realizar a captura das imagens ela
é posicionada de boca para baixo, conforme a Figura 19.
A iluminação no interior da caixa é feita por uma luz branca de LED que está afixada
em sua lateral, com o foco direcionado para lateral oposta. Sendo o interior
laminado, a luz é refletida por todo o interior da caixa gerando uma iluminação
difusa. A iluminação direta não deve ser incidente sobre os frutos de café pois isto
poderia gerar sombras ou saturações que dificultariam o processo de segregação da
imagem.
A abordagem de utilizar uma caixa sem nenhuma interferência de luz externa
permite que as imagens das amostras fiquem sempre com a mesma tonalidade,
independente das condições de iluminação do ambiente onde estão situados os
frutos de café.
A captura das imagens é feita com uma câmera USB Logitech c920 posicionada no
topo interior da caixa, direcionada para obter imagens a um ângulo de 90º do solo
onde estão os frutos de café.
Todo o processamento embarcado é feito por uma BeagleBone White situada no
topo exterior da caixa e conectada à câmera USB. A placa é responsável pelo
processamento da imagem, exibição do resultado e armazenamento do histórico.
A entrada e saída dos comandos do protótipo são feitos pela Breadboard Cape, que
situa-se encaixada sobre a BeagleBone. Esta dispõe de dois botões físicos: Um
deles responsável por dar início ao processo de captura e o outro responsável por
exibir para o operador a média dos graus de maturação de capturas já realizadas.
39 Sobre a área de prototipagem da BreadBoard Cape está instalado um display de 7
segmentos com 4 dígitos, responsável por exibir o percentual de maturação de uma
captura que acabou de ser feita ou o percentual médio baseado no histórico. O
diagrama do circuito do display de 7 segmentos e dos botões físicos está ilustrado
pela Figura 18.
Figura 18 - Diagrama do display de 7 segmentos e dos botões físicos
Fonte: Elaborado pelo autor, 2015
A alimentação dos componentes é feita por uma bateria USB posicionada também
no topo da caixa, dando a autonomia necessária para o projeto embarcado. A Figura
19 ilustra o esquemático com todos os materiais citados do protótipo.
40 Figura 19 - Desenho esquemático dos materiais do protótipo
Fonte: Elaborado pelo autor, 2015
4.2 DESENVOLVIMENTO DO PROGRAMA
O programa embarcado e executado pela BeagleBone foi desenvolvido nas
linguagens Shell Script para a manipulação das entradas e saídas e armazenamento
do histórico, e em C++ para as rotinas responsáveis pelo processamento de
imagens. Este trabalho utiliza a biblioteca de visão computacional OpenCV 2 que
possui diversas funções para a manipulação e tratamento de imagens digitais.
O algoritmo é iniciado a partir de um Shell Script desenvolvido em Bash. Esta
linguagem foi escolhida para ser o ponto de partida do programa por ter integrações
nativas com as entradas e saídas da BeagleBone White dependendo, assim, de
pouco processamento para manipular os botões físicos e o display integrado. Ele
também é responsável pelo armazenamento dos dados das coletas no arquivo texto.
As primeiras funções do script inicializam as portas de E/S da placa, conhecidas
como GPIO – Abreviação de General Purpose Input/Output. Ao todo são utilizadas
quatorze GPIO’s: doze delas para a manipulação do display de 7 segmentos e duas
para os botões físicos.
41 Um dos parâmetros também definidos pelo script são as configurações de captura
da câmera, feitas através da biblioteca V4L2 – Abreviação de Video For Linux
Version Two. A câmera é configurada para não utilizar foco automático, e ter uma
distância focal de 25 (os valores de foco vão de 0 à 250 em passos de 5), garantindo
que todas as imagens terão a mesma qualidade focal. Estes comandos são
executados somente uma vez para todo o ciclo de vida do programa:
v4l2-ctl --set-ctrl=focus_auto=0
v4l2-ctl --set-ctrl=focus_absolute=25
Em seguida, o script inicializa o arquivo de texto onde serão armazenados os
resultados de cada captura. O arquivo recebe as informações da data e hora em que
foi criado e da versão do sistema. A partir deste ponto, o protótipo fica pronto para
uso. Neste momento, o script fica em loop aguardando a interação do operador, feita
pelos botões físicos da BreadBoard Cape.
Ao pressionar o botão responsável por realizar a captura, o script chama o programa
em C++, já compilado, para dar início ao processo de aquisição, tratamento e
manipulação da imagem. Os valores de limiares das classes de frutos apresentados
na Tabela 2 utilizados para a segmentação estão armazenados neste programa.
O objeto VideoCapture do OpenCV é o responsável por inicializar e manipular a
câmera USB. O tamanho da captura é definido em 640 x 480 pixels através do
método set(). Um frame da câmera é lido através do método read() e seu conteúdo é
armazenado como uma imagem no formato RGB no objeto passado como
parâmetro. A conexão com a câmera é desligada pelo método release(). Em
seguida, a imagem capturada é convertida para o formato HSV através do método
cvtColor().
VideoCapture cap(0);
cap.set(CV_CAP_PROP_FRAME_WIDTH, 640);
cap.set(CV_CAP_PROP_FRAME_HEIGHT, 480);
cap.read(imgOriginal);
42 cap.release();
cvtColor(imgOriginal, imgHSV, COLOR_BGR2HSV);
A segmentação por limiarização binária dos frutos das classes Cereja, Verde e
Secos é feita, nesta ordem, através da função inRange(). Esta função recebe como
parâmetros os valores mínimos e máximos dos componentes H, S e V e cria uma
imagem segmentada como resultado, sem alterar a imagem original. A imagem
segmentada resultante é binária: Ela possui as cores Preta e Branca para indicar as
regiões que estavam fora e dentro do limiar, respectivamente.
Apesar de ter somente duas cores, as imagens retornadas pelo método inRange()
são em tons de cinza, ou seja, seus pixels podem assumir valores que vão de 0
(preto) até 255 (branco).
São feitas duas segmentações com limiares diferentes para a classe Cereja
conforme explicado na seção 3.2.2. É feito a união das duas imagens binárias
resultantes gerando uma terceira imagem binária que, esta sim, será utilizada ao
longo do processamento como sendo o resultado da segmentação da classe Cereja.
//Segmentação da classe Cereja (2 segmentações)
inRange(imgHSV, Scalar(0, 0, 0), Scalar(14, 255, 255),
imgThresholdedCereja1);
inRange(imgHSV, Scalar(123, 0, 0), Scalar(179, 255, 255),
imgThresholdedCereja2);
imgThresholdedCereja3=imgThresholdedCereja1+imgThresholdedCereja2;
As imagens resultantes da segmentação das classes Verde e Seco são submetidas
à função subtract(), que subtrai um determinado valor de todos os pixels de uma
imagem passada como parâmetro. Isto é feito para que as imagens binárias destas
classes fiquem com cores diferentes para identificar os pixels segmentados, já que a
cor Branca (255) foi definida como sendo frutos da classe Cereja.
Os pixels da imagem binária dos frutos Verdes são subtraídos em 100px para criar
uma tonalidade Cinza Claro (155) sobre os pixels que antes eram Brancos. Da
43 imagem binária dos frutos Secos é subtraído o valor de 200px para criar uma
tonalidade Cinza Escuro (55) onde antes existiam pixels Brancos.
//Segmentação da classe Verde
inRange(imgHSV, Scalar(15, 15, 0), Scalar(85, 255, 255),
imgThresholdedVerde);
subtract(imgThresholdedVerde, 100, imgThresholdedVerde);
//Segmentação da classe Seco
inRange(imgHSV, Scalar(0, 0, 0), Scalar(179, 122, 170),
imgThresholdedSeco);
subtract(imgThresholdedSeco, 200, imgThresholdedSeco);
A união das três imagens binárias de cada classe de fruto é feita da seguinte forma:
primeiro são unidas as imagens binárias de Cerejas e Verdes, já que seus pixels
limiarizados não se sobrepõem, criando uma imagem temporária. Em seguida, a
imagem binária dos frutos Secos é subtraída da imagem temporária para que os
pixels Secos que foram classificados em outra segmentação como Cereja ou Verde
sejam removidos da imagem, conforme explicado na seção 3.2.2, criando uma
segunda imagem temporária. Finalmente é feita a união da primeira imagem
temporária (Cerejas e Verdes) com a segunda imagem temporária resultante do
processo de subtração, gerando a imagem da união das três classes de frutos.
imgThresholdedTemp1 = imgThresholdedCereja3 + imgThresholdedVerde;
imgThresholdedTemp2 = imgThresholdedSeco – imgThresholdedTemp1;
imgThresholdedFinal = imgThresholdedTemp1 + imgThresholdedTemp2;
A imagem com as três classes de frutos é submetida ao processo de abertura
morfológica visando retirar pixels muito pequenos e sua resultante é submetida ao
fechamento morfológico visando fechar espaços vazios resultantes da segmentação.
São criados dois elementos estruturantes em forma de elipse através da função
getStructuringElement(), um para cada operação morfológica.
Mat elipseAbertura = getStructuringElement(MORPH_ELLIPSE, Size(2,
44 2));
Mat elipseFechamento = getStructuringElement(MORPH_ELLIPSE, Size(6,
6));
Os efeitos de abertura o fechamento são alcançados utilizando as funções erode()
para fazer a erosão da imagem e dilate() para fazer a dilatação da imagem. Ambas
as funções recebem o elemento estruturante definido anteriormente como
parâmetro.
//Abertura morfológica (remove pequenos objetos da imagem)
erode(imgThresholdedFinal, imgThresholdedFinalAdj, elipseAbertura);
dilate(imgThresholdedFinalAdj, imgThresholdedFinalAdj,
elipseAbertura);
//Fechamento morfológico (remove pequenos buracos da imagem)
dilate(imgThresholdedFinalAdj, imgThresholdedFinalAdj,
elipseFechamento);
erode(imgThresholdedFinalAdj, imgThresholdedFinalAdj,
elipseFechamento);
Após o tratamento, a imagem resultante é utilizada para o cálculo do grau de
maturação das amostras. O processo é feito contando quantos pixels de cada classe
– Cerejas, Verdes e Secos – existem na imagem e, para isto, será necessário
separar cada classe da imagem, gerando três novas imagens. A função inRange() é
utilizada novamente para a segmentação, desta vez com os limiares com o nível de
cor correspondente de cada classe: Branco (255) para Cerejas, Cinza Claro (155)
para Verdes e Cinza Escuro (55) para Secos.
inRange(imgThresholdedFinalAdj, 255, 255, imgCerejas);
inRange(imgThresholdedFinalAdj, 155, 155, imgVerdes);
inRange(imgThresholdedFinalAdj, 55, 55, imgSecos);
A contagem dos pixels é feita utilizando a função countNonZero(), que calcula
quantos pixels são diferentes de zero (cor Preta) em uma imagem. Em seguida, o
45 grau de maturação em níveis percentuais é calculado a partir da quantidade de
pixels da classe Cereja e do total de pixels de todas as classes.
pixelsCerejas = countNonZero(imgCerejas);
pixelsVerdes = countNonZero(imgVerdes);
pixelsSecos = countNonZero(imgSecos);
totalPixels = pixelsCerejas + pixelsVerdes + pixelsSecos;
percent = (pixelsCerejas * 100.0 / totalPixels);
Os valores do grau de maturação da captura e da quantidade de pixels de cada
classe é retornado para o script e o programa em C++ é finalizado. O script exibe
para o operador o grau de maturação no display de 7 segmentos e armazena os
resultados da coleta no arquivo texto. Adicionalmente, ele acumula o valor do grau
de maturação, incrementa seu contador de quantidade de capturas realizadas e fica
pronto para outra execução.
Ao pressionar o botão de exibir a média dos graus de captura, o script calcula a
média aritmética com base no valor acumulado dos graus de maturação e da
quantidade de capturas realizadas. A conta é feita com o auxílio da calculadora de
linha de comando bc, responsável por realizar cálculos matemáticos em ambientes
Unix.
mediaParcial=`echo "scale = 1; $totalPercent / $quantCapturas" |
bc`
Após calculada, a média é exibida ao operador no display de 7 segmentos e o script
fica pronto para outra execução.
O código desenvolvido pode ser verificado no Apêndice B.
O fluxograma do algoritmo está representado na Figura 20. As operações de cor
Azul são executadas pelo Shell Script, e as de cor Laranja pela rotina em C++.
46 Figura 20 - Fluxograma do algoritmo
Fonte: Elaborado pelo autor, 2015
Alguns trechos do programa imprimem mensagens sobre a ação que está sendo
executada e que podem ser utilizadas para depuração. É possível visualizar estas
mensagens caso a BeagleBone esteja sendo acessada de algum terminal Linux.
4.3 EXPERIMENTOS REALIZADOS
A coleta de dados foi realizada com o protótipo em um sítio em zona rural, utilizando
frutos de café Arábica recém colhidos. As capturas foram feitas de forma aleatória,
ou seja, não houve seleção manual dos frutos que iriam ser analisados.
Para todas as capturas os frutos tiveram que ser aplanados, pois a maneira com que
foram colocados para secagem acarretaria no problema de sobreposição. Restos de
47 folhas secas, que poderiam gerar ruídos na imagem, tiveram que ser removidos
manualmente antes de iniciar o processo. Eles estavam sobre uma lona de cor Azul
ocupando uma área de aproximadamente 2 m².
Pelo tamanho da área ocupada pelos frutos espalhados, estima-se que seria
necessário capturar 105 imagens para cobrir todo o terreiro (Expressão 16). Logo,
para este tamanho de população são necessárias 13 capturas aleatórias de imagens
a serem feitas pelo protótipo (Expressão 17) para realizar o cálculo do grau de
maturação amostral.
. 10000 16
192
2. 10000 192
3,75
20000
192
∗ 3,75
∗ 1,96
104,16
∗ 1,96 ²
2 ∗
105 ∗ 3,75 ∗ 1,96 ²
2 ∗ 105
3,75 ∗ 1,96
105
17
1
1
12,06
Arredondando para o próximo inteiro maior:
13
4.4 RESULTADOS
Os detalhes do grau de maturação de cada captura e da quantidade de pixels
segmentados para cada classe de fruto estão descritos na Tabela 3.
48 Tabela 3 - Detalhes de cada captura realizada pelo o protótipo
Captura Maturação (%)
Pixels Cerejas Pixels Verdes Pixels Secos
Total
1
40,3
107.380
140.419
18.125
265.924
2
40,0
106.503
137.935
21.810
266.248
3
37,5
96.437
147.294
13.397
257.128
4
42,9
113.575
136.517
14.470
264.562
5
43,8
107.485
118.363
19.027
244.875
6
37,3
80.112
119.368
15.101
214.581
7
42,6
107.905
131.024
13.849
252.778
8
38,2
91.720
133.488
14.319
239.527
9
44,1
106.556
119.630
15.354
241.540
10
44,3
125.108
133.624
23.302
282.034
11
47,0
122.596
120.620
17.353
260.569
12
43,8
118.842
135.227
16.732
270.801
13
38,2
104.017
147.030
20.550
271.597
Fonte: Elaborado pelo autor, 2015.
Para os dados coletados, temos que o grau de maturação total das amostras,
calculado a partir da média aritmética do grau individual de cada captura, é de
41,5%.
Para estimar a imprecisão do aumento da área dos frutos, foi feita uma simulação
utilizando uma circunferência de 2.541 pixels – valor médio da quantidade de pixels
de um fruto maduro. Esta circunferência foi repetida 116 vezes em uma imagem de
teste, que foi a quantidade média do total de frutos que uma imagem do protótipo
conseguiu capturar.
Esta imagem de teste foi submetida aos mesmos tratamentos utilizados no protótipo
e o valor da quantidade de pixels das circunferências existentes antes e depois dos
tratamentos foram comparados, resultando em um aumento de pixels de 3,54%.
Neste momento é necessário calcular a incerteza relacionada à margem de erro do
cálculo amostral, a incerteza relacionada ao aumento médio das áreas e a incerteza
combinada (Expressões 18, 19 e 20 respectivamente).
49 √3
2
2
√3
3,54
2
1,15 18
1,77 19
20
1,15
1,77 2,11
Conforme explicado na Seção 2.5, para mensurar o valor da incerteza relacionada
ao resultado do protótipo, é necessário calcular a incerteza combinada expandida.
Para isto, é necessário obter o valor do fator de abrangência ( ) que é tabelado de
acordo com a quantidade de graus de liberdade efetivos (
), calculado a seguir
(Expressão 21):
21
∑
1
2,11
1,77
12
19,95
0,8179
24
Para este valor de grau de liberdade efetivo, obtêm-se um fator de abrangência de
2,11 conforme a tabela definida por INMETRO (2012, p. 78). Por fim, é calculado a
incerteza combinada expandida (Expressão 22) conforme a equação também
definida na Seção 2.5:
∗
22
2,11 ∗ 2,11
4,5
50 Sendo assim, o resultado do grau de maturação das amostras coletadas pelo
protótipo é de (41,5 ± 4,5)%.
Para efeitos de comparação, as mesmas imagens foram submetidas a um teste
manual feito por um avaliador sem conhecimento prévio dos resultados gerados pelo
programa. Este teste prevê como seria o resultado do grau de maturação total se os
frutos fossem avaliados através das amostras de capturas sem o apoio
computacional, feito somente através de análise visual. Este teste foi feito para
verificar se as segmentações e os cálculos feitos pelo algoritmo estão sendo efetivos
ou não.
Cada imagem foi verificada individualmente e sua quantidade de frutos da classe
Cereja e o total de frutos foram registrados para que se pudesse gerar o grau de
maturação percentual. Os resultados estão apresentados na Tabela 4.
Tabela 4 - Detalhes da análise visual das coletas
Captura Maturação (%) 1 38,2 2 31,7 3 35,8 4 38,7 5 35,7 6 33,0 7 35,7 8 34,3 9 36,4 10 42,9 11 43,2 12 42,1 13 33,9 Cerejas 47 39 43 48 40 33 40 37 40 51 51 51 41 Total 123 123 120 124 112 100 112 108 110 119 118 121 121 Fonte: Elaborado pelo autor, 2015.
Através destes resultados, temos que o grau de maturação total das amostras
analisadas manualmente é de 37,0%. Os graus de maturação calculados pelo
protótipo e manualmente foram colocados em um gráfico, ilustrado pela Figura 21,
para que se possa visualizar melhor os seus comportamentos.
51 Figura 21 - Gráfico dos graus de maturação das coletas
55,0
50,0
45,0
Protótipo
Manual
40,0
35,0
30,0
1
2
3
4
5
6
7
8
9
10
11
12
13
Fonte: Elaborado pelo autor, 2015.
Verifica-se que, mesmo com a margem de erro, alguns graus de maturação
calculados pelo protótipo divergem daqueles calculados manualmente. Esta
diferença pode estar relacionada com a análise visual que se baseia na segregação
dos frutos por classes, gerando imprecisão por conta do problema de frutos que não
estão completamente maduros ou secos e, por conta disso, não podem pertencer a
apenas uma classe. Nestes casos o avaliador determina a qual classe eles
pertencem baseado em experiências próprias, ou seja, a imprecisão pode variar
dependendo de quem está avaliando. Como o programa do protótipo faz a
segregação através das cores dos pixels, este tipo de imprecisão não ocorre.
As imagens capturadas pelo protótipo estão disponíveis no Apêndice A.
De um modo geral, a implementação obteve resultados próximos aos valores dos
graus de maturação obtidos manualmente. Sendo possível constatar que o grau de
maturação total obtido das amostras analisadas manualmente (37,0%) está dentro
da faixa determinada pelo protótipo (41,5 ± 4,5)%.
52 5 CONCLUSÃO
Neste trabalho foi desenvolvido o protótipo de um sistema capaz de segregar cores
de imagens de amostras de café em seu período de pós-colheita, de modo a
detectar o grau de maturação dos frutos. Foi calculado que para um terreno de 2 m²
eram necessárias 13 capturas e, atendendo aos seus pré-requisitos, todas as
imagens foram obtidas com o mínimo de ruído e perda de dados e com o mesmo
padrão de foco. Para cada imagem, o processo de limiarização binária segregou
seus pixels em três classes – Cerejas, Verdes e Secos – separando corretamente o
fundo da região de interesse, ou seja, os pixels de frutos. Em seguida, uniu as três
imagens binárias de cada classe formando uma imagem única, respeitando a ordem
de importância caso algum pixel tenha sido classificado ao mesmo tempo como
“Seco” e “Verde” ou “Cereja”. Os processos de abertura e fechamento morfológico
foram aplicados removendo pequenos pixels e preenchendo espaços vazios que
poderiam ter sido causados pela limiarização binária, tornando a imagem mais
completa.
Os cálculos do grau de maturação foram feitos em seguida gerando o percentual de
maturação da captura baseado na quantidade de pixels Cereja em relação ao total
de pixels de todas as classes. Ao longo de cada captura, todos os valores de grau
de maturação calculados foram exibidos no display e guardados no arquivo texto de
histórico para posterior consulta e análise, incluindo a média do grau de maturação
total que tinha seu cálculo refeito a cada nova captura.
Apesar do resultado do trabalho ser positivo, é necessário considerar que ainda há
imprecisão no resultado do valor da média amostral causada pelo desvio padrão do
grau de maturação da população, visto que seu valor foi estimado utilizando a
amplitude típica dos dados e não o valor real.
Para trabalhos futuros, uma melhoria a ser feita seria adicionar três potenciômetros
na BreadBoard Cape que serviriam para ajustar os limiares de segregação dos
componentes H, S e V, de modo que o avaliador poderia calibrar os valores
conforme o nível de qualidade que deseja obter, por exemplo, e podendo ser até
utilizado para segregar diferentes tipos de café.
53 Ainda como melhoria, o arquivo de histórico poderia ser ajustado para um formato
que aceitasse a união com outros arquivos para que dois ou mais protótipos
diferentes pudessem ser utilizados em uma mesma colheita, aumentando o número
de capturas e ganhando mais precisão ao resultado final.
Com dois ou mais protótipos capturando imagens simultaneamente, outra melhoria a
ser realizada seria reduzir a incerteza do resultado do protótipo, realizando mais
simulações do aumento médio de área causado pelas operações morfológicas e
reduzindo a margem de erro do cálculo do tamanho amostral, consequentemente
resultando em obter mais capturas de imagem.
54 REFERÊNCIAS
CARVALHO, Glauco Rodrigues. Avaliação de sistemas de produção de café na
região sul de Minas Gerais: Um modelo de análise de decisão, 2002.
GIOMO, Gerson Silva. Café: Uma boa pós colheita é segredo da qualidade. A
Lavoura (Rio de Janeiro), Rio de Janeiro, p. 12 - 20, 10 fev. 2012.
GONZALES, Rafael C. WOODS, Richard E. Digital Image Processing, 2ª edição,
2002.
GONZALES, Rafael C. WOODS, Richard E. Digital Image Processing, 3ª edição,
2007.
Instituto Nacional de Metrologia, Qualidade e Tecnologia - INMETRO. Guia para a
expressão de incerteza de medição – GUM 2008, 1ª edição, Rio de Janeiro, 2012.
Instituto Observatório Social. Café do Brazil: O sabor Amargo da Crise, 2002.
L. Yang, J. Dickinson, Q. M. J. Wu, S. Lang. A Fruit Recognition Method for
Automatic Harvesting, IEEE, 2007.
MARQUES FILHO, O. VIEIRA NETO, H. Processamento Digital de Imagens. Rio
de Janeiro, 1999.
OYAMA, P.I. ; JORGE, Lucio Andre de Castro ; RODRIGUES, E. L. L. ; GOMES, C.
C. Sistema para classificação automática de café em grãos por cor e forma
através de imagens digitais. Em: Luiz Antônio Pereira Neves; Hugo Vieira Neto;
Adilson Gonzaga. (Org.). Avanços em Visão Computacional. 1ªed.Curitiba. :
Omnipax. 2012.p. 1-406.
PIMENTA, Carlos José. Qualidade do café (Coffea arabica L.) originado de
frutos colhidos em quatro estádios de maturação, 1995.
QUEIROZ, José E. R. GOMES, Herman M. Introdução ao Processamento Digital
de Imagens. Revista de Informática Teórica e Aplicada, Volume VIII, 2001.
SIMÕES, A. S., COSTA, A. H. R.Classificação de laranjas baseada em padrões
visuais, Anais do 6º Simpósio Brasileiro de Automação Inteligente, Bauru, São
Paulo, Brasil, 2003.
TEZUCA, E. S., CRUVINEL, P. E., HERRMANN Junior, P. S. P. Desenvolvimento
de um Modelo de Visão Computacional para Inferência da Qualidade de Frutas,
Anais do XI Encontro de Modelagem Computacional, 2008.
TRIOLA, Mario F. Introdução a estatística. Rio de Janeiro,1999.
55 APÊNDICE A
Imagens capturadas pelo protótipo
56 57 APÊNDICE B
Código em Shell Script (Bash)
O programa em C++ é chamado através do comando ./Projeto
Nome do arquivo: projeto.sh
#!/bin/bash
function printNum {
#NUMEROS
#0 LIGA
#1 DESLIGA
case $1 in
" ")
echo
echo
echo
echo
echo
echo
echo
1
1
1
1
1
1
1
>
>
>
>
>
>
>
/sys/class/gpio/gpio31/value
/sys/class/gpio/gpio50/value
/sys/class/gpio/gpio51/value
/sys/class/gpio/gpio14/value
/sys/class/gpio/gpio117/value
/sys/class/gpio/gpio2/value
/sys/class/gpio/gpio49/value;;
echo
echo
echo
echo
echo
echo
echo
0
0
0
1
0
0
0
>
>
>
>
>
>
>
/sys/class/gpio/gpio31/value
/sys/class/gpio/gpio50/value
/sys/class/gpio/gpio51/value
/sys/class/gpio/gpio14/value
/sys/class/gpio/gpio117/value
/sys/class/gpio/gpio2/value
/sys/class/gpio/gpio49/value;;
echo
echo
echo
echo
echo
echo
echo
1
1
0
1
0
1
1
>
>
>
>
>
>
>
/sys/class/gpio/gpio31/value
/sys/class/gpio/gpio50/value
/sys/class/gpio/gpio51/value
/sys/class/gpio/gpio14/value
/sys/class/gpio/gpio117/value
/sys/class/gpio/gpio2/value
/sys/class/gpio/gpio49/value;;
echo
echo
echo
echo
echo
echo
echo
0
0
1
0
0
1
0
>
>
>
>
>
>
>
/sys/class/gpio/gpio31/value
/sys/class/gpio/gpio50/value
/sys/class/gpio/gpio51/value
/sys/class/gpio/gpio14/value
/sys/class/gpio/gpio117/value
/sys/class/gpio/gpio2/value
/sys/class/gpio/gpio49/value;;
"0")
"1")
"2")
"3")
echo 1 > /sys/class/gpio/gpio31/value
echo 0 > /sys/class/gpio/gpio50/value
echo 0 > /sys/class/gpio/gpio51/value
58 echo
echo
echo
echo
0
0
1
0
>
>
>
>
/sys/class/gpio/gpio14/value
/sys/class/gpio/gpio117/value
/sys/class/gpio/gpio2/value
/sys/class/gpio/gpio49/value;;
echo
echo
echo
echo
echo
echo
echo
1
1
0
0
0
0
1
>
>
>
>
>
>
>
/sys/class/gpio/gpio31/value
/sys/class/gpio/gpio50/value
/sys/class/gpio/gpio51/value
/sys/class/gpio/gpio14/value
/sys/class/gpio/gpio117/value
/sys/class/gpio/gpio2/value
/sys/class/gpio/gpio49/value;;
echo
echo
echo
echo
echo
echo
echo
1
0
0
0
1
0
0
>
>
>
>
>
>
>
/sys/class/gpio/gpio31/value
/sys/class/gpio/gpio50/value
/sys/class/gpio/gpio51/value
/sys/class/gpio/gpio14/value
/sys/class/gpio/gpio117/value
/sys/class/gpio/gpio2/value
/sys/class/gpio/gpio49/value;;
echo
echo
echo
echo
echo
echo
echo
0
0
0
0
1
0
0
>
>
>
>
>
>
>
/sys/class/gpio/gpio31/value
/sys/class/gpio/gpio50/value
/sys/class/gpio/gpio51/value
/sys/class/gpio/gpio14/value
/sys/class/gpio/gpio117/value
/sys/class/gpio/gpio2/value
/sys/class/gpio/gpio49/value;;
echo
echo
echo
echo
echo
echo
echo
1
1
0
1
0
1
0
>
>
>
>
>
>
>
/sys/class/gpio/gpio31/value
/sys/class/gpio/gpio50/value
/sys/class/gpio/gpio51/value
/sys/class/gpio/gpio14/value
/sys/class/gpio/gpio117/value
/sys/class/gpio/gpio2/value
/sys/class/gpio/gpio49/value;;
echo
echo
echo
echo
echo
echo
echo
0
0
0
0
0
0
0
>
>
>
>
>
>
>
/sys/class/gpio/gpio31/value
/sys/class/gpio/gpio50/value
/sys/class/gpio/gpio51/value
/sys/class/gpio/gpio14/value
/sys/class/gpio/gpio117/value
/sys/class/gpio/gpio2/value
/sys/class/gpio/gpio49/value;;
echo
echo
echo
echo
echo
echo
echo
1
0
0
0
0
0
0
>
>
>
>
>
>
>
/sys/class/gpio/gpio31/value
/sys/class/gpio/gpio50/value
/sys/class/gpio/gpio51/value
/sys/class/gpio/gpio14/value
/sys/class/gpio/gpio117/value
/sys/class/gpio/gpio2/value
/sys/class/gpio/gpio49/value;;
"4")
"5")
"6")
"7")
"8")
"9")
*)
echo 0 > /sys/class/gpio/gpio31/value
echo 0 > /sys/class/gpio/gpio50/value
echo 1 > /sys/class/gpio/gpio51/value
59 echo
echo
echo
echo
0
1
0
0
>
>
>
>
/sys/class/gpio/gpio14/value
/sys/class/gpio/gpio117/value
/sys/class/gpio/gpio2/value
/sys/class/gpio/gpio49/value
esac
}
function displayOff {
echo
echo
echo
echo
echo
echo
echo
echo
1
1
1
1
1
1
1
1
>
>
>
>
>
>
>
>
/sys/class/gpio/gpio48/value #PONTO
/sys/class/gpio/gpio31/value
/sys/class/gpio/gpio50/value
/sys/class/gpio/gpio51/value
/sys/class/gpio/gpio14/value
/sys/class/gpio/gpio117/value
/sys/class/gpio/gpio2/value
/sys/class/gpio/gpio49/value
}
#variaveis do LED
if [ ! -d /sys/class/gpio/gpio31 ]; then
echo 31 > /sys/class/gpio/export
fi
if [ ! -d /sys/class/gpio/gpio50 ]; then
echo 50 > /sys/class/gpio/export
fi
if [ ! -d /sys/class/gpio/gpio48 ]; then
echo 48 > /sys/class/gpio/export
fi
if [ ! -d /sys/class/gpio/gpio51 ]; then
echo 51 > /sys/class/gpio/export
fi
if [ ! -d /sys/class/gpio/gpio14 ]; then
echo 14 > /sys/class/gpio/export
fi
if [ ! -d /sys/class/gpio/gpio113 ]; then
echo 113 > /sys/class/gpio/export
fi
if [ ! -d /sys/class/gpio/gpio117 ]; then
echo 117 > /sys/class/gpio/export
fi
if [ ! -d /sys/class/gpio/gpio115 ]; then
echo 115 > /sys/class/gpio/export
fi
if [ ! -d /sys/class/gpio/gpio3 ]; then
echo 3 > /sys/class/gpio/export
fi
if [ ! -d /sys/class/gpio/gpio2 ]; then
echo 2 > /sys/class/gpio/export
fi
if [ ! -d /sys/class/gpio/gpio49 ]; then
echo 49 > /sys/class/gpio/export
fi
if [ ! -d /sys/class/gpio/gpio15 ]; then
echo 15 > /sys/class/gpio/export
60 fi
echo
echo
echo
echo
echo
echo
echo
echo
echo
echo
echo
echo
out
out
out
out
out
out
out
out
out
out
out
out
if [ !
echo
fi
if [ !
echo
fi
>
>
>
>
>
>
>
>
>
>
>
>
/sys/class/gpio/gpio31/direction
/sys/class/gpio/gpio50/direction
/sys/class/gpio/gpio48/direction
/sys/class/gpio/gpio51/direction
/sys/class/gpio/gpio14/direction
/sys/class/gpio/gpio113/direction
/sys/class/gpio/gpio117/direction
/sys/class/gpio/gpio115/direction
/sys/class/gpio/gpio3/direction
/sys/class/gpio/gpio2/direction
/sys/class/gpio/gpio49/direction
/sys/class/gpio/gpio15/direction
-d /sys/class/gpio/gpio30 ]; then
30 > /sys/class/gpio/export
-d /sys/class/gpio/gpio60 ]; then
60 > /sys/class/gpio/export
echo in > /sys/class/gpio/gpio30/direction
echo in > /sys/class/gpio/gpio60/direction
v4l2-ctl --set-ctrl=focus_auto=0
v4l2-ctl --set-ctrl=focus_absolute=25
echo "Iniciando programa"
declare -i quantImagens=0
totalPercent=0
retornoPercent=0
mediaParcial=0
mediaParcialTemp=0
tabulacao='\t'
dataAtual=`date +"%d/%m/%Y %r"`
arqHistorico=`date +"%d_%m_%Y_%s"`'.txt'
#Montando header do arquivo de historico
echo 'Data: '$dataAtual > $arqHistorico
echo 'Versão 1.0' >> $arqHistorico
echo ' ' >> $arqHistorico
echo 'Grau de Maturação Total: '$mediaParcial'%' >> $arqHistorico
echo ' ' >> $arqHistorico
echo -e
'Captura'$tabulacao$tabulacao'Maturação'$tabulacao'Cerejas'$tabulaca
o'Verdes'$tabulacao'Secos' >> $arqHistorico
echo '-------------------------------------------------------' >>
$arqHistorico
digit1=0
digit2=0
61 digit3=0
digit4=0
while true
do
if [ `cat /sys/class/gpio/gpio30/value` -eq 0 ]; then
echo "Inciando captura..."
./Projeto
retornoPercent=`cat .grauP`
totalPercent=$(echo "scale = 1; $totalPercent +
$retornoPercent" | bc)
outLine=`cat .outLine`
digit1=${retornoPercent:0:1}
digit2=${retornoPercent:1:1}
digit3=${retornoPercent:2:1}
digit4=${retornoPercent:4:1}
quantImagens+=1
mediaParcialTemp=$mediaParcial
mediaParcial=`echo "scale = 1; $totalPercent /
$quantImagens" | bc`
sed -i 's/Total: '$mediaParcialTemp'%/Total:
'$mediaParcial'%/g' $arqHistorico
echo -e $outLine >> $arqHistorico
echo $totalPercent
sleep 1
fi
if [ `cat /sys/class/gpio/gpio60/value` -eq 0 ]; then
mediaParcial=`echo "scale = 1; $totalPercent /
$quantImagens" | bc`
echo "exibirei: "$mediaParcial
if [ ${mediaParcial:1:1} == "." ]; then
#Valor tipo X.X
digit1=" "
digit2=" "
digit3=${mediaParcial:0:1}
digit4=${mediaParcial:2:1}
fi
if [ ${mediaParcial:2:1} == "." ]; then
#Valor tipo XX.X
digit1=" "
digit2=${mediaParcial:0:1}
digit3=${mediaParcial:1:1}
digit4=${mediaParcial:3:1}
62 fi
if [ ${mediaParcial:3:1} == "." ]; then
#Valor tipo XXX.X
digit1=${mediaParcial:0:1}
digit2=${mediaParcial:1:1}
digit3=${mediaParcial:2:1}
digit4=${mediaParcial:4:1}
fi
sleep 1
fi
echo 1 > /sys/class/gpio/gpio15/value
echo 0 > /sys/class/gpio/gpio3/value
echo 0 > /sys/class/gpio/gpio115/value
echo 0 > /sys/class/gpio/gpio113/value
echo 1 > /sys/class/gpio/gpio48/value #PONTO
printNum "$digit1"
displayOff
echo 0 > /sys/class/gpio/gpio15/value
echo 1 > /sys/class/gpio/gpio3/value
echo 0 > /sys/class/gpio/gpio115/value
echo 0 > /sys/class/gpio/gpio113/value
echo 1 > /sys/class/gpio/gpio48/value #PONTO
printNum "$digit2"
displayOff
echo 0 > /sys/class/gpio/gpio15/value
echo 0 > /sys/class/gpio/gpio3/value
echo 1 > /sys/class/gpio/gpio115/value
echo 0 > /sys/class/gpio/gpio113/value
echo 0 > /sys/class/gpio/gpio48/value #PONTO
printNum "$digit3"
displayOff
echo 0 > /sys/class/gpio/gpio15/value
echo 0 > /sys/class/gpio/gpio3/value
echo 0 > /sys/class/gpio/gpio115/value
echo 1 > /sys/class/gpio/gpio113/value
echo 1 > /sys/class/gpio/gpio48/value #PONTO
printNum "$digit4"
displayOff
done
Código em C++
Nome do arquivo: Projeto
#include
#include
#include
#include
#include
<iostream>
<fstream>
<unistd.h>
<stdio.h>
"opencv2/highgui/highgui.hpp"
63 #include "opencv2/imgproc/imgproc.hpp"
using namespace cv;
using namespace std;
int main() {
VideoCapture cap(0);
Mat imgOriginal, imgHSV,
elipseAbertura, elipseFechamento,
imgThresholdedCereja1, imgThresholdedCereja2,
imgThresholdedCereja3,
imgThresholdedVerde, imgThresholdedSeco,
imgThresholdedCeV,
imgThresholdedFinal, imgThresholdedFinalAdj, imgCerejas,
imgVerdes, imgSecos;
int totalPixels, pixelsCerejas, pixelsVerdes, pixelsSecos;
double percent;
int quantImages;
char outNumber[256];
char outPonto[256] = ".";
char numstr[21];
string imgSuffix = "img", binSuffix = "bin", imgExt = ".png";
int fatorOpening = 2, fatorClosing = 6;
//CEREJA
int iCLowH = 0;
int iCHighH = 14;
int iCLowH2 = 123;
int iCHighH2 = 179;
int iCLowS = 0;
int iCHighS = 255;
int iCLowV = 0;
int iCHighV = 255;
//VERDES
int iVLowH = 15;
int iVHighH = 85;
int iVLowS = 15;
int iVHighS = 255;
int iVLowV = 0;
int iVHighV = 255;
//SECOS
int iSLowH = 0;
int iSHighH = 179;
int iSLowS = 0;
int iSHighS = 122;
64 int iSLowV = 0;
int iSHighV = 170;
if (!cap.isOpened()) {
cout << "Falha na web cam" << endl;
return -1;
}
cap.set(CV_CAP_PROP_FRAME_WIDTH, 640);
cap.set(CV_CAP_PROP_FRAME_HEIGHT, 480);
quantImages = 0;
cap.read(imgOriginal);
cout << "Capturando frame" << endl;
quantImages = quantImages + 1;
sprintf(numstr, "%d", quantImages);
imwrite(imgSuffix+numstr+imgExt, imgOriginal);
cvtColor(imgOriginal, imgHSV, COLOR_BGR2HSV); //Converte de
BGR para HSV
//Range Cereja
inRange(imgHSV, Scalar(iCLowH, iCLowS, iCLowV),
Scalar(iCHighH, iCHighS, iCHighV), imgThresholdedCereja1);
//Segmentacao
inRange(imgHSV, Scalar(iCLowH2, iCLowS, iCLowV),
Scalar(iCHighH2, iCHighS, iCHighV), imgThresholdedCereja2);
//Segmentacao
imgThresholdedCereja3 = imgThresholdedCereja1 +
imgThresholdedCereja2;
//Range Verde
inRange(imgHSV, Scalar(iVLowH, iVLowS, iVLowV),
Scalar(iVHighH, iVHighS, iVHighV), imgThresholdedVerde);
//Segmentacao
subtract(imgThresholdedVerde, 100, imgThresholdedVerde);
//Range Seco
inRange(imgHSV, Scalar(iSLowH, iSLowS, iSLowV),
Scalar(iSHighH, iSHighS, iSHighV), imgThresholdedSeco);
//Segmentacao
subtract(imgThresholdedSeco, 200, imgThresholdedSeco);
imgThresholdedCeV = imgThresholdedCereja3 +
imgThresholdedVerde;
imgThresholdedSeco = imgThresholdedSeco - imgThresholdedCeV;
imgThresholdedFinal = imgThresholdedCeV + imgThresholdedSeco;
elipseAbertura = getStructuringElement(MORPH_ELLIPSE,
Size(fatorOpening, fatorOpening));
65 elipseFechamento = getStructuringElement(MORPH_ELLIPSE,
Size(fatorClosing, fatorClosing));
//Abertura morfologica (remove pequenos objetos da imagem)
erode(imgThresholdedFinal, imgThresholdedFinalAdj,
elipseAbertura);
dilate(imgThresholdedFinalAdj, imgThresholdedFinalAdj,
elipseAbertura);
//Fechamento morfologico (remove pequenos buracos da imagem)
dilate(imgThresholdedFinalAdj, imgThresholdedFinalAdj,
elipseFechamento);
erode(imgThresholdedFinalAdj, imgThresholdedFinalAdj,
elipseFechamento);
inRange(imgThresholdedFinalAdj, 255, 255, imgCerejas);
inRange(imgThresholdedFinalAdj, 155, 155, imgVerdes);
inRange(imgThresholdedFinalAdj, 55, 55, imgSecos);
pixelsCerejas = countNonZero(imgCerejas);
pixelsVerdes = countNonZero(imgVerdes);
pixelsSecos = countNonZero(imgSecos);
totalPixels = pixelsCerejas + pixelsVerdes + pixelsSecos;
percent = (pixelsCerejas * 100.0 / totalPixels);
cout << "Pixels: " << pixelsCerejas << endl;
cout << "Porcentagem Parcial: " << percent << endl;
imwrite(binSuffix+numstr+imgExt, imgCerejas);
sprintf(outNumber, "%g", percent);
string outNum1, outNum2, outNum3, outNum4, outLine;
if (percent ==
outNum1 =
outNum2 =
outNum3 =
outNum4 =
} else {
100) {
"1";
"0";
"0";
"0";
if (outNumber[1] == outPonto[0]) {
//Valor tipo X.X
outNum1 = " ";
outNum2 = " ";
outNum3 = outNumber[0];
outNum4 = outNumber[2];
}
if (outNumber[2] == outPonto[0]) {
//Valor tipo XX.X
outNum1 = " ";
outNum2 = outNumber[0];
outNum3 = outNumber[1];
outNum4 = outNumber[3];
66 }
if (outNumber[3] == outPonto[0]) {
//Valor tipo XXX.X
outNum1 = outNumber[0];
outNum2 = outNumber[1];
outNum3 = outNumber[2];
outNum4 = outNumber[4];
}
}
remove(".grauP");
remove(".outLine");
ofstream fileLine, fileGrau;
fileGrau.open (".grauP");
fileLine.open (".outLine");
fileGrau << outNum1 << outNum2 << outNum3 << "." << outNum4;
fileLine << "1\\t\\t" << percent << "%\\t" << pixelsCerejas
<< "\\t" << pixelsVerdes << "\\t" << pixelsSecos;
fileGrau.close();
fileLine.close();
cap.release();
cout << "Fim do programa" << endl;
return 0;
}