Avance - Tecnológico de Monterrey

Instituto Tecnológico y de Estudios Superiores de Monterrey
Campus Cuernavaca
Avance de Proyecto
Reconocimiento de Hojas de Plantas
Deny L. Hernández Rabadán
1125746
Francisco R. Uribe Cornejo
375673
Visión Computacional
Dr. Julián Guerrero
Cuernavaca, Mor., a 7 de octubre de 2009
Índice
ÍNDICE _______________________________________________________________________ 2
INTRODUCCIÓN ______________________________________________________________ 3
PROBLEMÁTICA ________________________________________________________________ 3
JUSTIFICACIÓN _________________________________________________________________ 4
OBJETIVO ____________________________________________________________________ 5
OBJETIVOS ESPECÍFICOS _________________________________________________________ 5
METODOLOGÍA ______________________________________________________________ 6
PROCESAMIENTO DE LA IMAGEN ____________________________________________________ 6
SEGMENTACIÓN _________________________________________________________________ 7
EXTRACCIÓN DE CARACTERÍSTICAS__________________________________________________ 7
RECONOCIMIENTO _______________________________________________________________ 8
ANTECEDENTES ______________________________________________________________ 9
CALENDARIZACIÓN _________________________________________________________ 11
AVANCES ___________________________________________________________________ 12
ESTADO DEL ARTE _____________________________________________________________ 12
TÉCNICAS ____________________________________________________________________ 15
PROCESAMIENTO DE IMAGEN______________________________________________________ 15
SEGMENTACIÓN ________________________________________________________________ 18
EXTRACCIÓN DE CARACTERÍSTICAS ________________________________________________ 19
RESULTADOS __________________________________________________________________ 20
ANEXO I – CÓDIGO __________________________________________________________ 23
REFERENCIAS _______________________________________________________________ 31
2
Introducción
Entre los desafíos más importantes que enfrenta la agricultura y el sector rural en el siglo
XXI destacan: a) el abastecimiento o seguridad alimentaria, b) la agricultura como motor en
la reducción de la pobreza y, c) el uso actual y el deterioro de los recursos naturales. En
cuanto al primero, el reto consiste en producir comida suficiente para alimentar a una
población mundial que alcanzará 8 mil millones de habitantes en el año 2025 o 2030 y 10
mil millones antes del 2050 según El País [1], incremento que tendrá lugar sobre todo en los
países en desarrollo.
El sector rural mexicano de la primera década del siglo XXI alcanza 198 millones de
hectáreas de las cuales 16 % son tierras agrícolas, 61 % de agostadero y 23 % de bosques y
selvas de acuerdo al INEGI [2].
El Plan Nacional de Desarrollo 2007-2012 plantea como premisa básica la búsqueda del
Desarrollo Humano Sustentable, correspondiendo a esto el Programa Especial Concurrente
para el Desarrollo Rural Sustentable 2007-2012 (PEC 2007-2012) establece un conjunto de
estrategias y alternativas para reactivar el agro mexicano entre las que podemos resaltar la
protección al país de plagas y enfermedades y mejorar la situación sanitaria. Así como
garantizar la aplicación de la normatividad vigente en materia de sanidad e inocuidad
agroalimentaria y mejorarla permanentemente para mantener el reconocimiento a nuestros
estatus sanitario por parte de los mercados globales.
Respecto a los cultivos, lo más importante para el control y el manejo de sus plagas y
enfermedades es el diagnóstico oportuno de los agentes causales de los padecimientos. En
muchos casos, el diagnóstico puede tomar una hora [3]. En otros, la identificación puede
tardar de 5 a 7 días. Si la situación es muy alarmante, en casos donde toda la siembra se ve
afectada entonces es inminente un sistema que pueda hacer las evaluaciones directamente
en los predios y lo antes posible.
Problemática
Las pérdidas que ocasionan las plagas y enfermedades en los cultivos de los países
desarrollados se ubican entre 10 y 20 por ciento de la producción [4], convirtiéndose en uno
de los principales inconvenientes para los productores. Por ello, el diagnóstico y control de
enfermedades es uno de los retos más importantes en los sistemas de producción de plantas
cultivadas en el país.
Justificación
Las propiedades ópticas de las plantas no sólo varían en el tiempo en función del estado de
la planta, también varían en función de factores externos e internos [5]. Por lo tanto,
imágenes de las plantas pueden ser una fuente muy valiosa de información respecto a
cambios en el crecimiento del cultivo, estado nutricional, incidencia de enfermedades y
plagas, rendimiento y propiedades del suelo [6].
Los métodos usados en el diagnóstico de enfermedades idealmente deben de ser sencillos,
baratos, flexibles, preciso y exactos. Actualmente, los utilizados para prescripción mediante
síntomas son cualitativos o semi cuantitativos, y en su mayoría se basan en la evaluación
visual por algún experto. Mientras que muchas de estas técnicas han sido exitosamente
empleadas en el análisis y valoración de afecciones, existen estudios donde se demuestra la
arbitrariedad del ojo humano para la determinación de los síntomas [7].
Un sistema de visión computacional para diagnóstico de enfermedades en plantas de
invernaderos se está desarrollando en esta institución. Uno de los problemas principales a
los que se enfrenta este proyecto es trabajar en un ambiente real. En términos generales el
sistema debe realizar las siguientes acciones: a) obtener imágenes de la planta, b) reconocer
la hoja y, c) diagnosticarla, ver Figura 1.
Saludable
Enfermedad 1
Enfermedad 2
Figura 1. Proceso general del sistema de visión para diagnóstico de enfermedades en plantas
Tan sólo el proceso de reconocer la hoja involucra un gran problema ya que, en el
ambiente real, es muy difícil encontrar una hoja que se encuentre en las condiciones
óptimas que permitan obtener un alto porcentaje de reconocimiento, es decir, normalmente
nos encontraremos con ciertas limitantes como por ejemplo: hojas que están deformes,
que les hace falta una parte de sus orillas o se encuentren ocluidas por otra hoja.
Este proyecto pretende enfrentar este primer problema aplicando una metodología que
realice el reconocimiento de la hoja de la planta independientemente de las limitantes que
se mencionaron anteriormente.
Objetivo
Reconocer la forma geométrica de una hoja de una especie de planta para identificar
alteraciones en la misma, bajo un ambiente controlado de iluminación y fondo. Se
considerarán algunas limitantes presentes en el ambiente real (deformidades naturales y no
naturales de la hoja).
Cabe mencionar que en este proyecto no se pretende realizar clasificación de especies ni
detección de enfermedades de la planta, el último es nuestro trabajo futuro, por lo que
nuestro interés con este proyecto es perfeccionar el reconocimiento de la hoja para que sea
adaptable a situaciones que se presentan en el ambiente real.
Objetivos específicos
•
Adquirir imágenes de hojas de una especie de planta en un ambiente controlado de
iluminación y fondo.
•
Filtrar la imagen para mejorar la segmentación.
•
Identificar características geométricas relevantes para el reconocimiento de la forma
de la hoja.
•
Analizar la imagen para obtener las características geométricas relevantes para
caracterizar la observación.
•
Generar una base de conocimiento respecto a distintas observaciones de las hojas de
una especie de planta para comparar distintas escenas.
•
Entrenar una red neuronal y un sistema basado en modelos ocultos de Markov con
la base de conocimiento de las diversas observaciones a distintas hojas de una
especie de planta.
•
Implementar un sistema que entienda la imagen de una hoja de una especie de
planta y describa si pertenece o no a la especie de planta aprendida u observada.
• Evaluación del sistema bajo diferentes características de la hoja (con deformidades
naturales y no naturales). Así como con hojas de especies diferentes a la entrenada o
conocida.
Metodología
La metodología que se pretende seguir en el desarrollo de este proyecto se muestra a
continuación en el siguiente diagrama.
Suavizado
Ecualización
Procesamiento
Operaciones Morfológicas
Otsu
Segmentación
Canny
Extracción de
Características
Códigos de cadena
Contornos de Momento
Redes Neuronales
Reconocimiento
Modelos Ocultos de
Markov
Figura 2. Metodología
Procesamiento de la imagen
El procesamiento de la imagen es primordial en el desarrollo de este proyecto para mejorar
la calidad de las imágenes, un buen tratamiento de la imagen nos facilitará la obtención de
las características que nos permitan realizar el reconocimiento de la hoja.
En este proyecto se propone la aplicación de un filtro gaussiano [8], para la eliminación del
ruido de la imagen, y la aplicación de un realzado mediante histograma. El histograma de
una imagen es una función discreta que representa el número de pixeles en la imagen en
función de los niveles de intensidad.
El histograma es de gran utilidad en el tratamiento de imágenes ya que su manipulación
sirve para variar el aspecto de las imágenes y por tanto se puede utilizar para mejorar la
calidad de la imagen.
Segmentación
La segmentación es el proceso por el cual se extrae de la imagen cierta información
subyacente para su posterior uso. La segmentación está basada en dos principios
fundamentales: discontinuidad (orientada a bordes) y similitud (orientada a regiones).
En este proyecto nos interesa realizar una segmentación orientada a bordes y el algoritmo
que aplicaremos es el de Canny [9]. El algoritmo de Canny se fundamenta en la teoría de
operadores primera derivada y resulta particularmente interesante porque extrae bordes y
cierra los contornos evitando posibles rupturas de los mismos durante su extracción.
Extracción de características
Cuando las personas tratan de reconocer una planta ellas normalmente observan sus hojas,
sus flores, su fruto y su tallo, para poder extraer características discriminantes. Estas
características pueden ser directamente obtenidas con tan sólo observar las hojas, ya que
éstas contienen suficiente información para poder identificar a que especie de planta
pertenecen [10].
La asimetría, redondez, irregularidad del borde, diámetro e índice de alargamiento
(anisotropía) de la hoja son algunas características que distinguen a una especie de planta
de otra. Estas características pueden obtenerse de la imagen de una hoja a través de su
contorno.
En este proyecto se propone la utilización de dos descriptores de contorno, son los
siguientes:
a) Códigos de cadena. Se usan para representar una frontera como un conjunto de
segmentos con longitud y dirección especificadas.
b) Momentos: La forma de una representación unidimensional de un contorno a
través de función real, g(x), se puede escribir utilizando momentos estadísticos,
como la media, la varianza o momentos de orden superior. Dicha función puede ser
la signatura del contorno. En el caso de contornos abiertos, se puede utilizar la
función que se obtiene de las distancias de los puntos del contorno al segmento que
une los dos puntos extremos de dicho contorno.
Se eligieron estos descriptores porque son sencillos de implementar, obtienen buena
caracterización del contorno de la hoja y son utilizados en algunos de los trabajos revisados
brindándoles buenos resultados [11] [12] [13][14].
Reconocimiento
Red Neuronal
Es un grupo interconectado de neuronas artificiales que simulan el proceso de pensamiento
de un cerebro humano. Uno puede considerar una red neuronal como una caja negra
entrenada para obtener procesos inteligentes a través de la entrada y salida del flujo de
información. La ventaja de la utilización de una red neuronal aplicada en el reconocimiento
de formas es que el entrenamiento de la red es muy rápido y fácil.
HMM
Un modelo oculto de Markov (Hidden Markov Model HMM) es un proceso estocástico que
consta de un proceso de Markov no observado (oculto) q={qt} tєN y proceso observado
O={ot} tєN cuyos estados son dependientes estocásticamente de los estados ocultos, es decir,
es un proceso bivariado (q,o). Los HMM se pueden considerar también como sistemas
generativos estocásticos, los cuales se emplean en la modelación de series de tiempo
[15],[16].
Antecedentes
El reconocimiento de hojas de plantas ha sido objeto de estudio por muchos investigadores,
en la mayoría de los casos, con el fin principal de distinguir entre especies diferentes de
plantas; en seguida hablaremos un poco de los trabajos revisados que consideramos más
relevantes.
En [17] presentan un enfoque para extracción de las venas de una hoja, consideran que las
venas brindan información importante y discriminante en el reconocimiento de especies
de plantas.
El enfoque que proponen se basa en dos etapas, en la primer etapa realizan la
segmentación utilizando un histograma de intensidad de la imagen de la hoja para estimar
las regiones de pixeles que pertenecen a las venas; enseguida, la segunda etapa consiste en
reforzar la detección de la vena mediante el entrenamiento de una red neuronal que lleva a
cabo la clasificación de los pixeles en dos clases: venas y fondo.
Otro trabajo que realiza extracción de venas es presentado por [18] ellos proponen un
método de segmentación que combina la técnica snake con redes neuronales celulares, su
método tiene la ventaja de aplicar conocimiento a priori para mejorar la precisión y
robustez de la segmentación.
En [19] proponen un método de reconocimiento de hojas de plantas utilizando una red
neuronal que clasifica las hojas en 32 especies diferentes; el método primeramente procesa
las imágenes y extrae de ellas 12 características morfológicas las cuales, posteriormente,
son ortogonalizadas utilizando la técnica de Análisis de Componentes Principales (PCA de
sus siglas en inglés).
PCA es utilizado con la finalidad de reducir la dimensión del vector de entrada de la red
neuronal. Su algoritmo es rápido en ejecución, eficiente en reconocimiento y fácil de
implementar.
En [20] proponen un método que realiza el reconocimiento de hojas que se encuentran
parcialmente ocluidas utilizando el algoritmo de Watershed modificado. La idea básica del
algoritmo Watershed es que una imagen digital es considerada como una superficie
topográfica y el valor de cada pixel representa la elevación en ese punto.
Los bordes de los objetos son definidos como elevaciones altas y las regiones dentro del
objeto como elevaciones bajas. El objetivo principal de su trabajo es obtener un mejor
reconocimiento de las hojas en escenas naturales donde éstas, normalmente, se encuentra
ocluidas.
Un método de identificación de especies de plantas basado en una técnica de matching de
forma es propuesto por [21], proponen un algoritmo de programación dinámica modificado
(MDP) para realizar el matching de las formas y obtener el reconocimiento de las hojas de
las plantas, la ventaja de su algoritmo es su robustez ya que el reconocimiento es apropiado
no solo con hojas intactas sino también con aquellas que están distorsionadas o que son
parcialmente ocluidas.
El reconocimiento de hojas se ha abordado en la mayor parte de los trabajos utilizando
redes neuronales. En este proyecto proponemos utilizar, además de las redes neuronales, los
Modelos Ocultos de Markov (HMM) para llevar a cabo el reconocimiento y reforzar las
observaciones para el entrenamiento del modelo utilizando los siguientes métodos para
extracción de características: Momento de contornos y códigos de cadena.
Según [11] la clave en el reconocimiento de hojas es la obtención de características estables
que puedan distinguir las hojas como únicas; es por esto que creemos que las
características geométricas elegidas que son únicas de cada especie de hoja nos brindarán
un alto porcentaje de reconocimiento.
Calendarización
31-Ago-09
07-Sep-09
14-Sep-09
21-Sep-09
28-Sep-09 05-Oct-09
Propuesta
Análisis de Técnicas
Implementación de
Técnicas de
Procesamiento
Implementación de
Técnicas de Análisis
[Extracción]
Implementación de
Técnicas de Análisis
[Reconocimiento]
Integración
Verificación
Entrenamiento
12-Oct-09
Implementación de
Técnicas de
Análisis
[Extracción]
Implementación de
Técnicas de
Análisis
[Reconocimiento]
Integración
Verificación
Entrenamiento
Reconocimiento
Validación
Entrega
19-Oct-09
26-Oct-09
02-Nov-09
09-Nov-09
23-Nov-09
Avances
Siguiendo la calendarización presentada al inicio, este primer avance del proyecto abarca
hasta la implementación de las técnicas para procesamiento de la imagen; sin embargo,
decidimos adelantarnos en tiempos ya que el objetivo final, el reconocimiento del objeto,
nos tomará más tiempo del que habíamos planeado, por lo que incluimos en este avance
algunas de las técnicas para extracción de características que ya hemos implementado.
De acuerdo a la metodología planteada, las técnicas a implementar para detección de
contorno son: códigos de cadena de Freeman, Momentos y Descriptores de Fourier. Los
descriptores de Fourier ya no se implementarán en este proyecto ya que los dos métodos
restantes nos han dado buenos resultados en la descripción de la forma y nos son más útiles
en la obtención de las características discriminativas de las hojas, características que serán
entrada de nuestros dos métodos de reconocimiento planteados en la metodología.
La presentación del avance se estructura de la siguiente manera:
c) Estado del arte, revisión de otros trabajos para solución del problema en cuestión.
d) Descripción de técnicas implementadas para procesamiento y extracción de
características de la imagen.
e) Presentación de resultados
Estado del Arte
En la mayoría de los trabajos revisados se enfocan en la extracción de características
geométricas discriminantes de la hoja que permitan llevar a cabo un buen reconocimiento
de la misma, la hoja les brinda información importante para reconocimiento, clasificación y
detección de enfermedades de la planta.
El objetivo a largo plazo de este proyecto es llevar a cabo la detección de enfermedades de
una planta y es primordial, al igual que en otros trabajos, obtener características de la hoja
que permitan reconocerla y diagnosticarla independientemente de cómo se encuentre en el
ambiente.
Los trabajos que se han revisado desde la entrega del primer avance a la fecha se describen
a continuación.
Qingfeng Wu y otros [11] creen que el problema clave de reconocimiento de hojas, que
involucra a su vez el reconocimiento de plantas, es la extracción de características que sean
estables y puedan distinguir hojas individuales. Ellos extraen características de forma,
márgenes, dientes y venas para representar la hoja, estas características son la entrada de
una red neuronal que como salida obtiene el reconocimiento de la planta a la que pertenece.
Ellos extrajeron características visuales relacionadas al dominio de la hoja considerando
tres aspectos de la misma: la forma, los dientes y las venas.
De la forma de la hoja obtuvieron las siguientes características: delgadez, redondez y
solidez. El uso de momentos invariantes les ayudo en la obtención de las dos primeras
características. Del margen de la hoja y la forma de los dientes obtuvieron: tosquedad (del
margen de la hoja); tamaño, ángulo y nitidez (que tan afilado) del diente. De las venas de la
hoja obtuvieron las siguientes características: número de ramificaciones y el grado de
curvatura de la vena principal.
Con estas características entrenaron su red neuronal y obtuvieron muy buenos porcentajes
de reconocimiento para las pruebas realizadas con seis especies diferentes de plantas.
Z. Wang y otros [12], proponen un método de dos etapas para recuperar la imagen de la
hoja usando características de forma simple que incluyen: curva de distancia al centroide
del contorno (CCD), excentricidad e histograma de código de ángulos (ACH). En la primer
etapa, las imágenes que son disimilares con la imagen de búsqueda serán filtradas usando
excentricidad para reducir el espacio de búsqueda, en la segunda etapa la recuperación se
refinará al usar el grupo de las tres características antes mencionadas en el espacio de
búsqueda reducido.
El CCD sigue la misma idea que los códigos de cadena, es éstos el trazado del contorno se
realiza en una sola dirección tomando un punto de inicio fijo, la secuencia de puntos del
contorno se determina calculando la distancia R que existe del punto P al centroide C del
contorno y su ángulo.
Para el mismo punto de inicio, el contorno del objeto puede ser reconstruido usando una
curva CCD de esta forma un objeto de dos dimensiones puede ser representado por una
curva de una dimensión.
Las ondas en las hojas son una característica local importante para identificación de
especies de plantas por los humanos. En este trabajo utilizan un código de ángulos, en su
método cada contorno cerrado es representado por una secuencia de segmentos de línea
con dos segmentos de línea sucesivos formando un ángulo.
Con el fin de discretizar los ángulos construyen un histograma, de esta forma es más
sencillo el realizar un matching entre diferentes contornos.
Este trabajo realizó pruebas con 1400 imágenes de hojas y según lo publicado obtuvieron
resultados razonablemente buenos.
En Du [13], obtienen características geométricas de una gran base de datos de hojas de
plantas con el fin de reconocer la planta utilizando un clasificador hiperesfera MMC
(Move Median Center). El método que ellos proponen es más robusto que los basados en
características de contorno.
Las características geométricas que utilizan son:
rectangularidad, perímetro, área, esfericidad, circularidad, excentricidad, factor de forma y
momentos invariantes de la hoja.
La idea del clasificador hiperesfera que ellos proponen es que cada clase de patrones son
considerados como una serie de hiperesferas las cuales son tratadas como un grupo de
puntos en los métodos convencionales.
El algoritmo trabaja, en breves palabras, de la siguiente manera: calcula la mediana
multidimensional de la clase, encuentra el radio que puede abarcar los puntos de la clase,
realiza un número determinado de iteraciones para eliminar el centro de la hiperesfera con
el fin de ampliarla y abarcar tantos puntos como sea posible.
Una vez que el algoritmo encuentra la hiperesfera más grande, los puntos dentro de ésta son
eliminados y el procedimiento completo es repetido para los puntos restantes de la clase. El
paso final es remover las hiperesferas redundantes, las cuales son abarcadas por una
hiperesfera más grande.
Zagrouba y otros [14] presentan un método para reconocimiento de melanomas, extraen
características discriminantes de imágenes de lesiones de piel para diferenciar entre una
lesión benigna de una maligna (melanoma), las características que ellos extraen son las
siguientes: Asimetría, irregularidad del borde, variación del color, diámetro e índice de
alargamiento (anisotropía).
Las características antes mencionadas son entrada a una red neuronal con arquitectura
perceptrón monocapa . Este trabajo, aunque no trata el problema de reconocimiento de
hojas, nos fue útil porque algunas de las características discriminativas de una lesión de piel
también se presentan en las hojas, como son: la asimetría, el alargamiento (dependiendo de
la especie de plantas unas están más largas que otras), la compacidad y la irregularidad del
borde.
Técnicas
Procesamiento de Imagen
Suavizado
Aún cuando el ambiente es controlado, existen pequeños disturbios por lo que se empleo un
suavizado. A diferencia de Matlab, OpenCV crea pixeles "virtuales" fuera de la imagen, en
las fronteras, para producir imágenes de salida del mismo tamaño que la de entrada o para
no afectar el filtrado de los pixeles de los bordes de la imagen.
El suavizado por una Gaussiana es el más útil, aunque no el más rápido. En vista que la
imagen de entrada es buena solo deseamos eliminar el poco ruido que podría estar en la
imagen debido a pequeños cambios en el ambiente. Por esta razón se implementó un
desenfoque simple, el cual es el suavizado más sencillo y rápido que OpenCV soporta.
Cada píxel en la salida es la media simple de todos los píxeles en una ventana alrededor del
píxel correspondiente en la entrada.
Figura 3. Comparación suavizado por una Gaussiana (centro) y desenfoque simple (derecha).
Ecualización por Histograma
Las cámaras por lo general deben enfrentarse no sólo al contraste en una escena, sino
también a la exposición de sus sensores a la luz de la escena. En una cámara normal, la
obturación y apertura del lente oscilan entre exponer poco o demasiado los sensores a la
luz. A menudo el rango de contrastes es muy amplio para los sensores, por lo que existe un
trade-off entre la captura de las áreas oscuras (por ejemplo, las sombras) que requiere más
tiempo de exposición, y las áreas brillantes, que requieren menor exposición para evitar la
saturación de “nublados”.
Por lo que una forma de lidiar con este trade-off es tratar de ampliar el rango dinámico de la
imagen, para lo que la técnica más común es la ecualización por histograma. [22]
Operaciones Morfológicas
Por último, después de la eliminación de ruido, buscaremos el aislamiento de los elementos
individuales, y la unión de elementos dispares en la imagen, de forma que emplearemos las
transformaciones morfológicas más simples, dilatación y erosión []. Para preservar el área
de regiones conectadas con más precisión, se implementaron las operaciones de apertura y
cierre.
Figura 4. Comparación de la operación de apertura (centro) y de cierre (derecha).
El cierre se utiliza en la mayoría de los algoritmos de componentes conectados para reducir
los segmentos no deseados o generados por el ruido. En la implementación encontramos
que las regiones brillantes se mantuvieron unidas, pero conservando su tamaño básico.
Figura 5. Operación de cierre.
La operación de apertura es empleada a menudo para separar elementos que se encuentren
muy cerca entre ellos en la imagen. Por su parte, en el proyecto se encontró que las
pequeñas regiones brillantes, causadas por la fuente de luz, fueron eliminadas, y el resto de
regiones brillantes fueron aislados manteniendo su tamaño.
Figura 6. Operación de apertura.
Parte fundamental de este trabajo es encontrar los componentes conectados, por lo que la
operación de cierre se realiza primero para eliminar los elementos que surgen
exclusivamente del ruido y luego la operación de apertura se utiliza para conectar las
regiones cercanas más grandes.
Segmentación
Otsu
Con frecuencia se realizan distintas etapas durante los pasos de procesamiento de imagen y
llega un punto en el cual se desea hacer una decisión final sobre los píxeles de la imagen o
rechazar categóricamente esos píxeles por debajo o por encima de cierto valor,
manteniendo los demás [23]. Se eligió el método de umbralización de Otsu [24] ya que en
[25] se recomendó por aportar información útil para extracción de características y
caracterización de la hoja.
Canny
Finalmente se aplica un algoritmo de detección de bordes con la intensión de resumir la
binarización de la imagen en información útil para encontrar contornos. El algoritmo de
Canny trata de reunir los posibles pixeles de borde en contornos. Dichos contornos se
forman mediante la aplicación última de un umbral de histéresis a los píxeles.
Extracción de Características
Hasta este punto hemos encontrado los píxeles del borde que separan a los distintos
segmentos de una imagen, sin embargo esto no aporta nada sobre los bordes de las
entidades en sí mismas. El siguiente paso es reunir los píxeles del borde en contornos.
Un contorno es una lista de puntos que representan una curva en una imagen. Esta
representación puede ser diferente dependiendo de la escena o circunstancia [26]. En
OpenCV los contornos son representados por secuencias en las que cada entrada en la
secuencia codifica la información sobre la ubicación del siguiente punto de la curva.
Códigos de Cadena
Normalmente, los contornos se pueden representar como una secuencia de vértices. Una
representación alternativa puede ser las cadenas de Freeman [27]. Con una cadena de
Freeman, un polígono es representado como una secuencia de pasos en una de las ocho
direcciones, cada paso es designado por un número entero de 0 a 7. Las cadenas de
Freeman tienen aplicaciones útiles en el reconocimiento y otros contextos.
Figura 7. Cadenas de Freeman.
Momentos
Una de las maneras más simples para comparar dos curvas es calcular los momentos de
contorno. En términos generales, un momento es una característica del contorno calculado
mediante la integración sobre todos los píxeles del contorno.
El cálculo de momentos proporciona algunas características elementales de un contorno
que se puede utilizar para comparar dos curvas. Sin embargo, los momentos por sí mismos
no son los mejores parámetros para este tipo de comparaciones, en la mayoría de los casos
prácticos.
Usualmente, se utilizan los momentos normalizados, de modo que los objetos de la misma
forma pero diferentes tamaños proporcionen valores similares. Del mismo modo, los
momentos simples dependen del sistema de coordenadas elegido, lo que significa que los
objetos no se comparan correctamente si se rotan.
Resultados
Los resultados muestran un programa* que obtiene el contorno de la hoja. Así mismo, se
muestra un punto correspondiente al centro geométrico obtenido a partir de los momentos.
Respecto al trabajo futuro, cabe señalar que las imágenes presentadas como resultado
muestran deformidades en el contorno debido a la sombra. Sin embargo, el trabajo a
realizar será más sobre el diseño del experimento para mantener controlado el ambiente.
Por otra parte, la continuación del proyecto llevará a cabo la extracción de más
características geométricas así como el entrenamiento de la red neuronal y el modelado de
los procesos ocultos de Markov.
*
Ver Anexo I
Anexo I – Código
//=======================================================================
// System Includes
//=======================================================================
#include <assert.h>
#include <stdio.h>
#include <sys/timeb.h>
#include <memory.h>
//=======================================================================
// Project Includes
//=======================================================================
#include "cv.h"
#include "highgui.h"
#include "PGRFlyCapture.h"
//=======================================================================
// FireFly Constants
//=======================================================================
#define FILENAME "img.bmp"
// The maximum number of cameras on the bus.
#define MAX_CAMS
1
// The index of the camera to grab from.
#define CAMERA_INDEX 0
// The image resolution
#define WIDTH 640 // Columns
#define HEIGHT 480
// Rows
// The image pixel size in bytes
#define PIXEL 4
//=======================================================================
// OpenCV Constants
//=======================================================================
#define CVCONTOUR_APPROX_LEVEL 2
#define CVCLOSE_ITR 1
#define PERIM_SCALE 8
//=======================================================================
// FireFlye variables
//
http://www.ptgrey.com/support/downloads/documents/flycapture/flycapture_s
tart.htm
//=======================================================================
FlyCaptureImage frame;
FlyCaptureImage image;
FlyCaptureContext context;
FlyCaptureError error;
FlyCaptureInfo info;
//=======================================================================
// OpenCV variables
// file:///C:/Program%20Files/OpenCV/docs/index.htm
// file:///C:/Program%20Files/OpenCV1.2/doc/index.htm
//=======================================================================
IplImage *cvImage = 0;
IplImage *out_rgb = 0;
IplImage *out_gray = 0;
// Contours variables
CvMemStorage* storage = cvCreateMemStorage(0);
CvContourScanner scanner;
CvSeq* contour = 0;
CvSeq* contours = 0;
// Moments variables
CvMoments moments;
double M00;
double M01;
double M10;
//=======================================================================
// Function prototypes
//=======================================================================
void init();
//=======================================================================
// OpenCV function prototypes
//=======================================================================
void processImage();
void segmentImage();
void featureExtraction();
//=======================================================================
// FireFly function prototypes
//=======================================================================
int startFireFly();
int stopFireFly();
int grabFireFly();
int saveFireFly();
void reportError(FlyCaptureError error, char* fname);
//=======================================================================
// main Description:
//
Function to
//=======================================================================
int main( int argc, char** argv ) {
struct _timeb
timeStart;
struct _timeb
timeFinish;
cvNamedWindow( "Camera", CV_WINDOW_AUTOSIZE );
cvNamedWindow( "Output", CV_WINDOW_AUTOSIZE );
if( startFireFly() )
{
init();
while(true)
{
//=================================================================
// Start
//=================================================================
_ftime( &timeStart );
if (grabFireFly())
{
processImage();
segmentImage();
cvZero(out_rgb);
cvDrawContours( out_rgb, contours,
CV_RGB(255,255,0), CV_RGB(255,255,255),1);
featureExtraction();
cvCircle(out_rgb, cvPoint(
(int)(M10/M00),(int)(M01/M00) ), 1, cvScalar(255,0,255), 2);
}
_ftime( &timeFinish );
//=================================================================
// End
//=================================================================
#ifdef WIN64
__time64_t uiTime =
#else
unsigned int uiTime =
#endif
(unsigned int) (60000 /( ( timeFinish.time * 1000 +
timeFinish.millitm ) - ( timeStart.time * 1000 + timeStart.millitm ) ) );
printf("%u fps\n", uiTime);
cvShowImage( "Camera", cvImage);
cvShowImage( "Output", out_rgb );
if( cvWaitKey( 10 ) >= 0 )
break;
}
}
stopFireFly();
// Destroy the window previously created
cvDestroyWindow("Camera");
//cvDestroyWindow("Output");
return 0;
}
//=======================================================================
// init Description:
//
Function to initialize
//=======================================================================
void init()
{
frame.pData = new unsigned char[ WIDTH * HEIGHT * PIXEL ];
// From grabFireFly()
image.pData = new unsigned char[ WIDTH * HEIGHT * PIXEL ];
cvImage = cvCreateImage( cvSize(WIDTH, HEIGHT), IPL_DEPTH_8U, 3 );
// From preProcess()
out_rgb = cvCreateImage( cvSize(WIDTH, HEIGHT), IPL_DEPTH_8U, 3 );
out_gray = cvCreateImage( cvSize(WIDTH, HEIGHT), IPL_DEPTH_8U, 1 );
}
//=======================================================================
// processImage Description:
//
Function to process the cvImage
//=======================================================================
void processImage()
{
//out_rgb = cvCreateImage( cvSize(cvImage->width,cvImage->height),
IPL_DEPTH_8U, 3 );
// Smooth
cvSmooth(cvImage, out_rgb, CV_BLUR, 5, 5);
// Grayscale
//out_gray = cvCreateImage( cvSize(cvImage->width,cvImage->height),
IPL_DEPTH_8U, 1 );
cvCvtColor( out_rgb, out_gray, CV_BGR2GRAY );
// Equalization
cvEqualizeHist( out_gray, out_gray );
// Morphological open and closing operations
cvMorphologyEx( out_gray, out_gray, 0, 0, CV_MOP_OPEN, CVCLOSE_ITR
);
cvMorphologyEx( out_gray, out_gray, 0, 0, CV_MOP_CLOSE, CVCLOSE_ITR
);
}
//=======================================================================
// segmentImage Description:
//
Function to segment the cvImage
//=======================================================================
void segmentImage()
{
// Thresholding - Otsu
cvThreshold(out_gray,out_gray,0,160,CV_THRESH_OTSU);
// Thresholding - Canny
cvCanny(out_gray,out_gray,0,160);
}
//=======================================================================
// featureExtraction Description:
//
Function to extract features from the cvImage
//=======================================================================
void featureExtraction()
{
// Retrieves all the contours and puts them in the list.
// Compresses horizontal, vertical, and diagonal segments, leaving
only their ending points.
scanner = cvStartFindContours(out_gray, storage, sizeof(CvContour),
CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE );
int numCont = 0;
while( (contour = cvFindNextContour( scanner )) != NULL )
{
double len = cvContourPerimeter( contour );
// calculate perimeter len threshold:
double q = (out_gray->height + out_gray->width) /
PERIM_SCALE;
//Get rid of blob if its perimeter is too small:
if( len < q )
{
cvSubstituteContour( scanner, NULL );
} else
{
// Smooth its edges if its large enough
CvSeq* new_contour;
// Polygonal approximation - Douglas-Peucker
approximation algorithm
new_contour = cvApproxPoly(contour, sizeof(CvContour),
storage, CV_POLY_APPROX_DP, CVCONTOUR_APPROX_LEVEL, 0);
// Convex Hull of the segmentation
//new_contour = cvConvexHull2( contour, storage,
CV_CLOCKWISE, -1);
cvSubstituteContour( scanner, new_contour );
numCont++;
}
}
contours = cvEndFindContours( &scanner );
// Moments
cvMoments(out_gray,&moments);
M00 = cvGetSpatialMoment(&moments,0,0);
M10 = cvGetSpatialMoment(&moments,1,0);
M01 = cvGetSpatialMoment(&moments,0,1);
}
//=======================================================================
// grabFireFly Description:
//
Function to grab a frame with the FireFly
//=======================================================================
int grabFireFly()
{
// Start grabbing images.
error = flycaptureGrabImage2( context, &frame );
if (error != 0 )
{
reportError(error,"flycaptureGrabImage2");
return 0;
}
// Convert the image.
//image.pData = new unsigned char[ frame.iCols * frame.iRows * 4 ];
image.pixelFormat = FLYCAPTURE_BGR;
error = flycaptureConvertImage( context, &frame, &image);
if (error != 0 )
{
reportError(error,"flycaptureConvertImage");
return 0;
}
//cvImage = cvCreateImage( cvSize(image.iCols, image.iRows),
IPL_DEPTH_8U, 3 );
cvImage->widthStep = image.iRowInc;
cvImage->imageData = (char *) image.pData;
return 1;
}
//=======================================================================
// startFireFly Description:
//
Function to start the FireFly connection
//=======================================================================
int startFireFly()
{
if (MAX_CAMS > 1)
{
// Enumerate the cameras on the bus.
FlyCaptureInfoEx arInfo[ MAX_CAMS ];
unsigned int
uiSize = MAX_CAMS;
error = flycaptureBusEnumerateCamerasEx( arInfo, &uiSize );
if (error !=0)
{
reportError(error, "flycaptureBusEnumerateCameras");
return 0;
}
for( unsigned int uiBusIndex = 0; uiBusIndex < uiSize;
uiBusIndex++ )
{
FlyCaptureInfoEx* pinfo = &arInfo[ uiBusIndex ];
printf(
"Index %u: %s (%u)\n",
uiBusIndex,
pinfo->pszModelName,
pinfo->SerialNumber );
}
}
// Create the context.
error = flycaptureCreateContext(&context);
if (error != 0)
{
reportError(error, "flycaptureCreateContext");
return 0;
}
// Initialize the camera.
error = flycaptureInitialize(context, CAMERA_INDEX);
if (error != 0)
{
reportError(error, "flycaptureInitialize");
return 0;
}
// Get the info for this camera.
error = flycaptureGetCameraInformation(context, &info);
if (error != 0)
{
reportError(error,"flycaptureGetCameraInformation");
return 0;
}
if (info.CameraType ==
FlyCaptureCameraType::FLYCAPTURE_BLACK_AND_WHITE)
{
printf("B&W %s s/n %d\r\n",info.pszModelString,
info.SerialNumber);
}
else if (info.CameraType == FlyCaptureCameraType::FLYCAPTURE_COLOR)
{
printf("Colour %s s/n %d\r\n",info.pszModelString,
info.SerialNumber);
}
// Start FlyCapture.
error = flycaptureStart(context,
FlyCaptureVideoMode::FLYCAPTURE_VIDEOMODE_ANY,
FlyCaptureFrameRate::FLYCAPTURE_FRAMERATE_ANY);
if (error != 0)
{
reportError(error,"flycaptureStart");
return 0;
}
return 1;
}
//=======================================================================
// stopFireFly Description:
//
Function to stop the FireFly connection
//=======================================================================
int stopFireFly()
{
// Stop FlyCapture.
error = flycaptureStop(context);
if (error != 0)
{
reportError(error, "flycaptureStop");
return 0;
}
printf("Disconnected.");
// Destroy the context.
error = flycaptureDestroyContext( context );
if (error != 0)
{
reportError(error, "flycaptureDestroyContext");
return 0;
}
delete [] image.pData;
return 1;
}
//=======================================================================
// saveFireFly Description:
//
Function to save a frame with the FireFly
//=======================================================================
int saveFireFly()
{
// Save the converted image to disk.
error =
flycaptureSaveImage(context,&image,FILENAME,FLYCAPTURE_FILEFORMAT_BMP );
if (error != 0 )
{
reportError(error,"flycaptureSaveImage");
return 0;
}
return 1;
}
//=======================================================================
// reportError Description:
//
Function to return error code
//=======================================================================
void reportError(FlyCaptureError error, char* fname)
{
fprintf(stderr, "%s error:
\"%s\"\r\n",fname,flycaptureErrorToString(error));
return;
}
Referencias
Las figuras 3 - 7 fueron obtenidas del libro Learning OpenCV, Computer Vision with the
OpenCV Library, Gary Bradski y Adrian Kaebler, O’Reilly 2008.
[1] El País - Uruguay. "Crisis alarmante", El País. Montevideo: May 11, 2008.
[2] INEGI Estadísticas, ANUIES Anuarios estadísticos, 2002.
[3] L. Y. Del Valle, "Con su CDT los cultivos" El Nuevo Día. San Juan, Puerto Rico: Feb 7,
2008.
[4] E. C. Oerke, H. W. Dehne, F. Shoenbeck, A. Weber. Crop Protection and Crop
Production. Amsterdam. Elsevier. 1994
[5] G. Guyot, “Optical properties of vegetation canopies”, Applications of Remote Sensing
in Agriculture, M.D. Steven and J.A. Clark (Eds), pp. 19–43, 1990.
[6] Y. J. Lee, K. W. Chang, Y. Shen, T. M. Huang, H. L. Tsay, “A handy imaging system
for precision agriculture studies”, International Journal of Remote Sensing, vol. 28 no. 21,
pp. 4867 - 4876, 2007.
[7] D. P. Martin, E. P. Rybicki, Microcomputer-based quantification of maize streak virus
symptoms in Zea mays. Phytopathology, vol. 88, pp. 422-427, 1998.
[8] G. Pajares G., J. De la Cruz. Visión por computador, imágenes digitales y aplicaciones.
Editorial Ra-Ma. 2002.
[9] J. Canny. A Computational Approach to Edge Detection. IEEE Trans. on Pattern
Analysis and Machine Intelligence, vol. 8 no. 6, pp. 679-698, 1986.
[10] T.E. Weier, C. R. Stocking, et al. : Botany: An Introduction to Plant Biology. John
Wiley and Sons(1982)
[11] Wu Qingfeng, Lin Kunhui Lin , Zhou Changl. Feature extraction and automatic
recognition of plant leaf using artificial neural network. The 2nd International Conference
on Computer Science & Education (ICCSE’2007), pp.47-50 ISTP BGQ59, 2007
[12] Wang, Z., Chi, Z. and Feng. Shape based leaf image retrieval. Image Signal Process
150, 34-43, Diciembre 2003.
[13] J.-X. Du, X.-F. Wang, and G.-J. Zhang. Leaf shape based plant species recognition.
Applied Mathematics and Computation, vol. 185, 2007.
[14] E. Zagrouba , W. Barhoumi. A prelimary approach for the automated recognition of
malignant melanoma, Image Analysis and Stereology Journal, 23(2), pp. 121–135, 2004.
[15] L.R. Rabiner, B.H Juang. An introduction to hidden Markov Models, IEEE ASSP
Mag., vol. 3, no. 1, pp. 4-16, 1986.
[16] L. R. Rabiner. "A tutorial on hidden Markov models and selected applications in speech
recognition". Proceedings of the IEEE, vol. 77 no. 2, pp. 257–286, 1989.
[17] Hong Fu , Zheni Chi. A two-stage approach for leaf vein extraction. Neural Networks
and Signal Processing, 2003. Proceedings of the 2003 International Conference on vol. 1,
pp. 208 – 211, 2003.
[18] YunFeng Li, QingSheng Zhu,
YuKun Cao, Cheng Liang Wang. A Leaf Vein
Extraction Method Based On Snakes Technique. Neural Networks and Brain, 2005.
ICNN&B '05. International Conference on vol. 2, pp. 885 – 888, 2005.
[19] S.G. Wu , F.S. Bao , E.Y Xuan Wang , Yi-Fan Chang, Qiao-Liang Xiang. A Leaf
Recognition Algorithm for Plant Classification Using Probabilistic Neural Network. Signal
Processing and Information Technology, 2007 IEEE International Symposium on pp. 11 16, 2007
[20] W. S. Lee, D. C. Slaughter. Recognition partially occluded plant leaves of using a
modified Watershed algorithm. Transactions of the ASAE, ISSN 0001-2351, vol. 47, no. 4,
pp. 1269-1280, 2004.
[21] Ji-Xiang Du, De-Shuang Huang, Xiao-Feng Wang, Xiao Gu. Computer-aided plant
species identification (CAPSI) based on leaf shape matching technique.Transactions of the
Institute of Measurement and Control, vol. 28 no.3,pp. 275, 2006.
[22] A. A. Schwarz, J. M. Soha. Multidimensional histogram normalization contrast
enhancement. Proceedings of the Canadian Symposium on Remote Sensing, pp. 86–93,
1978.
[23] M. Sezgin, B. Sankur. Survey over image thresholding techniques and quantitative
performance evaluation. Journal of Electronic Imaging, vol. 13 pp. 146–165, 2004.
[24] N.A. Otsu. Threshold selection method from gray-level histograms. IEEE Trans.
System Man Cybernet, vol. 9 no. pp 62–66, 1979.
[25] Xiao-Feng Wang, Ji-Xiang Du, Guo-Jun Zhang. Recognition of Leaf Images Based on
Shape Features Using a Hypersphere Classifier. Applied Mathematics and Computation.
vol. 205 pp. 916-926, 2008.
[26] S. Suzuki, K. Abe. Topological structural analysis of digital binary images by border
following. Computer Vision, Graphics and Image Processing, vol. 30pp. 32–46, 1985.
[27] H. Freeman. On the classification of line-drawing data. Models for the Perception of
Speech and Visual Form, pp. 408–412, 1967.