• No se han encontrado resultados

D I SW C 6

N/A
N/A
Protected

Academic year: 2023

Share "D I SW C 6"

Copied!
25
0
0

Texto completo

(1)

C APÍTULO 6

D ESARROLLO DE LA I NTERFAZ SW

6.1. Introducción

En el presente capítulo se abordará con detalle la implementación de los algoritmos expuestos en el capítulo anterior, así como, las herramientas y métodos utilizados en su desarrollo.

Para el presente proyecto fin de carrera se han propuesto dos interfaces software, la primera realiza un procesado con el algoritmo hardware PRXFIL. Este algoritmo realiza una detección de bordes con una máscara de Laplace; la segunda interfaz, realiza el cálculo del perímetro de la imagen, con el algoritmo hardware PERIM.

Para comprobar la validez de los resultados obtenidos, se ha realizado paralelamente el mismo procesado con algoritmos software. Estos algoritmos se encuentran en una librería de procesado de imágenes de Matrox llamada MIL (Matrox Imaging Library).

Las interfaces software han sido programadas en C/C++, bajo el entorno de programación de Microsoft Visual C++ 6.0.

(2)

6.2. Herramientas software

Las interfaces software han sido desarrolladas sobre un PC (host), Pentium II a 400MHz con memoria RAM de 64MB sobre Windows NT 4.0 (sp. 6). En el host se ubican dos tarjetas PCI, la primera pertenece a la casa Matrox, modelo Genesis y realiza la función de captura de imágenes; la segunda (Aristotle) está dedicada al cómputo algorítmico y pertenece a la empresa MiroTech.

Para la comunicación entre el host y la tarjeta Aristotle, MiroTech proporciona varias funciones y comandos RCI (Reconfigurable Computing Interface). Estas funciones son implementadas a través una librería de enlace dinámico (.DLL) llamada MTRCI.DLL.

La comunicación con la tarjeta Aristotle conlleva importar la librería MTRCI.LIB al proyecto de C/C++ e incluir MTRCI.H en la cabecera del código fuente del proyecto.

La lista de funciones suministradas por el fabricante y disponibles para el control y configuración de la tarjeta Aristotle se indican en la Tabla 6.1., así como una breve descripción de cada una de ellas. Para obtener más información sobre estas funciones ver Anexo I. Mirotech RCI Library Reference.

La comunicación con el dispositivo de captura de imágenes, en este caso el Frame Grabber Genesis de Matrox, se realiza mediante las librerías de procesado de imágenes conocidas como librerías MIL (Matrox Imaging Library). Estas librerías disponibles en C/C++

-126- Function Name Description

RciBootDevice Inicia un proceso o un VPE (virtual processing element) en un dispositivo.

RciCloseDevice Cierra un handle abierto por RciOpenDevice.

RciDeviceControl Envía un código de control al dispositivo especificado.

RciEnumDevices Enumera los dispositivos existentes en una máquina determinada.

RciGetDeviceInfo Muestra información sobre un dispositivo específico.

RciGetLastError Retorna extensa información de error

RciOpenDevice Abre un handle para configurar un dispositivo reconfigurable.

RciReadDevice Lee un bloque de datos de un dispositivo especificado.

RciResetDevice Resets a un dispositivo especifico.

RciSetDeviceClock Controla el dispositivo generador de reloj.

Tabla 6.1. Funciones disponibles en la librería MTRCI.LIB

(3)

permiten el control, captura y almacenamiento en disco de imágenes, así como, un conjunto de funciones para el procesado de imágenes.

El paquete Matrox Imaging Library (MIL) es una librería de módulos software independientes. Las MIL poseen un extenso juego de comandos para procesamiento de imágenes y operaciones específicas, tales como análisis de objetos, reconocimiento de modelos, calibración y OCR1. Además, posee un conjunto de gráficos básicos. En general, las MIL pueden manipular cualquier imagen en escala de grises o color. Sin embargo, los cálculos estadísticos, análisis de objetos, reconocimiento de patrones y OCR sólo están disponibles para imágenes en escala de grises.

El paquete ha sido diseñado para desarrollar aplicaciones de una forma rápida y sencilla. Las MIL pueden ejecutarse sobre cualquier tarjeta VGA compatible VESA o en una tarjeta Matrox bajo diferentes ambientes (DOS, y Windows 9x/NT/XP). Las MILs pueden ser ejecutadas directamente sobre la CPU, o pueden ser aceleradas mediante hardware especializado de Matrox.

Las características a destacar de las MIL son:

 Adquisición de imágenes.

Las imágenes pueden cargarse desde un disco o ser adquiridas mediante un amplio rango de dispositivos de entrada (si el hardware lo permite). Además, es posible almacenarlas en plataformas de almacenaje estándar.

 Capacidades de procesamiento de imagen.

Mediante las MIL se puede suavizar, realzar, o modificar características específicas de una imagen. Estas características del paquete incluyen operaciones punto-a-punto, estadísticas, filtros espaciales, y operaciones morfológicas.

 Posibilidades gráficas.

El paquete permite anotar o alterar imágenes. Las MIL poseen comandos que permiten escribir texto, añadir gráficos básicos como rectángulos, arcos, líneas, y puntos.

 Análisis de objetos (blobs2).

El análisis de blobs permite identificar y medir la conectividad entre diferentes regiones de una imagen.

1 OCR: Optical Character Recognition.

2 Blobs: Objetos o regiones dentro de una imagen.

(4)

El módulo de análisis de blobs permite extraer una gran cantidad de información sobre las características de un objeto, tales como, área, compacidad, etc. También permite ejecutar operaciones de procesamiento de la imagen como reconstrucción o eliminación de blobs.

 Capacidades de Medida.

Las MIL permiten la medida de dimensiones, posiciones, y características de objetos. Así mismo, permiten usar como marcadores objetos tales como puntos, bordes, y líneas. Los bordes y marcadores son determinados por el usuario y posicionados en la imagen. Es posible realizar mediciones (tal como distancia, ángulo, y ecuaciones lineales) entre marcadores. También podemos tomar medidas de los propios marcadores tal como anchura, contraste, y polaridad.

 Reconocimiento de patrones.

El reconocimiento de modelos puede ayudar a resolver problemas de visión tales como alineación, medida, e inspección de objetos. Estas capacidades incluyen localizar:

 Las coordenadas de un modelo en una imagen.

 El número de eventos de un modelo en una imagen.

Por ejemplo, puede alinearse un objeto encontrado por el modelo del objeto en una imagen y determinar su desplazamiento desde la posición de exclusión.

 Reconocimiento óptico de caracteres (OCR).

El MIL OCR permite leer y analizar los caracteres en una imagen.

 Generador de funciones MIL.

En el caso de que las MIL no proporcionen la funcionalidad requerida para una aplicación específica, la aplicación permite acceder a los drivers del sistema y/o crear tus propias seudo- funciones MIL.

 Objetos MIL.

Las MIL manejan tanto objetos físicos (sistemas, digitalizadores, displays, y buffers de datos) como objetos virtuales. Estos objetos virtuales deben ser asignados antes de poder manipularse y se deben liberar cuando ya no sean requeridos.

-128-

(5)

Para aplicaciones sencillas raramente se necesita asignar estos objetos individualmente, en esos casos el comando (MappAllocDefault ()) reúne las necesidades básicas para la aplicación.

 Resolución de los píxeles.

El paquete MIL permite:

 Capturar imágenes en escala de grises (8, 16-bit) o en color.

 Procesar imágenes de 1, 8, 16, o 32-bit.

 Procesar algunas funciones para imágenes en color (no permite análisis estadísticos, análisis de blobs, reconocimiento de modelos y OCR). Cada banda de una imagen en color se procesa individualmente.

Visualiza imágenes de 1, 8, o 16-bit en escala de grises o color (si la plataforma lo permite). Las librerías MIL están disponibles como una librería de funciones C, o como DLL bajo Windows 9x/NT/XP.

La programación de las interfaces ha sido realizada bajo el entorno de programación Microsoft Visual C++. A continuación, se resumen algunos de los muchos servicios que proporciona este entorno:

 Las ventanas que proporcionan visualizaciones de aspectos diferentes del proceso de desarrollo, desde listas de clases y archivos fuente a mensajes del compilador.

 Acceso de menú a un extenso sistema de ayuda en línea.

 Un editor de texto para la creación y mantenimiento de archivos fuente, un editor inteligente para diseñar cuadros de diálogo y un editor de gráficos para crear otros elementos de interfaz, como por ejemplo mapas de bits, iconos, cursores de ratón y barras de herramientas.

 Asistentes que crean archivos iniciadores para un programa, dándole un inicio de cabecera en la tarea mundana de ajustar un proyecto nuevo. Visual C++ proporciona asistentes para distintos tipos de programas de Windows, incluyendo aplicaciones estándar con bases de datos opcionales y soporte de Automatización, bibliotecas de enlace dinámico, aplicaciones basadas en diálogo, extensiones para un servidor Web utilizando el Internet Server API (ISAPI) y los controles Active X.

 ClassWizard, un asistente que ayuda a mantener clases para las aplicaciones MFC.

 Componentes ejecutables temporales mantenidos por la Gallery que añaden características instantáneas a sus programas.

(6)

 Un excelente depurador.

 Acceso conveniente y lógico a las órdenes a través de menús y barras de herramientas. Puede personalizar los menús y las barras de herramientas existentes en Visual C++ o crear otras nuevas.

 La posibilidad de añadir sus propias herramientas de entorno a través de macros y bibliotecas de enlace dinámicas añadidas.

6.3. Arquitectura de la interfaz

Para cada uno de los algoritmos desarrollados se ha generado una interfaz software. En el caso del algoritmo PRXFIL se ha generado el código en C/C++ “TestBinM”, mientras que para el algoritmo PERIM se ha generado el código “TestPerim”.

 Interfaz Laplace (TestBinM): Esta interfaz software realiza una detección de bordes con los algoritmos hardware y software, pudiéndose comparar la eficacia tanto de uno como de otro.

 Interfaz Perímetro (TestPerím): Con esta interfaz se obtiene el resultado del cálculo del perímetro mediante el algoritmo hardware, y para dar veracidad al resultado se ha realizado, también, el cálculo con las librerías MIL.

Aunque se han desarrollado dos interfaces distintas, la estructura que tienen las dos es la misma. Para ello se ha creado una arquitectura genérica de cómo se realizan los distintos procesos (hardware y software), y cómo se realiza el flujo de los módulos que componen la interfaz.

La arquitectura general que presentan las interfaces software se muestra en la figura siguiente:

-130-

(7)

Figura 6.1. Arquitectura de la interfaz SW

La diferencia principal que hay que destacar entre las dos interfaces es que para la primera, la FIFO de salida del algoritmo hardware está configurada para datos de 8 bits y para la segunda la FIFO de salida está configurada para datos de 16 bits (cubre un perímetro de hasta 216 = 65.536). Esto influye sobretodo en el desempaquetado de los datos.

La interfaz software tiene la tarea de gestionar el correcto funcionamiento de la arquitectura, para ello realiza las funciones de:

 Configuración de la tarjeta reconfigurable (Aristotle). Esta función permite seleccionar el algoritmo de visión que será implementado en la FPGA de la Aristotle.

(8)

 Comunicación bidireccional con tarjeta Genesis. La adquisición de imágenes desde la tarjeta Genesis ha sido implementada utilizando las librerías MIL. La tarjeta capta, desde una cámara analógica, una imagen que posteriormente almacena en un buffer de la propia tarjeta, para su posterior tratamiento y procesado por la tarjeta Aristotle. Una vez la imagen está almacenada en el buffer de la tarjeta Genesis se transfiere a la memoria del PC_Host en formato array2D para su posterior transferencia al módulo de empaquetado.

 Empaquetado de datos. La interfaz software recibe los datos correspondientes a la imagen digitalizada desde la tarjeta Genesis para su manipulación. La manipulación conlleva el empaquetado de la información de manera que sea legible por la tarjeta Aristotle. El empaquetado de estos datos dependerá del algoritmo hardware que haya sido implementado sobre el dispositivo reconfigurable (FPGA).

 Comunicación bidireccional con la tarjeta Aristotle. Una vez empaquetados los datos, estos son enviados a la tarjeta Aristotle. El envío de los datos procedentes de la imagen capturada por la tarjeta Genesis es una tarea crítica en lo que al tiempo de cómputo se refiere. La transferencia de datos requiere un tiempo fijo por píxel dependiente de la plataforma (CPU) en la que se ejecute el algoritmo. Para acelerar este proceso se han empleado funciones de C/C++ basadas en hilos.

Estas funciones de C/C++ permiten una ejecución concurrente de procesos, así como, aumentar el rendimiento del programa.

Los hilos son utilizados para escribir los datos de la imagen en la cola FIFO_IN y leer los datos desde la cola FIFO_OUT de forma concurrente en la tarjeta Aristotle. Una vez terminado el proceso concurrente de lectura y escritura, los resultados son devueltos a la interfaz software.

 Desempaquetado de datos. Una vez la tarjeta Aristotle ha realizado una o varias tareas de procesado de imagen, los datos procesados son devueltos a la interfaz software donde son desempaquetados y mostrados por pantalla. La función de desempaquetado pretende adecuar de nuevo los datos procesados por el algoritmo hardware a la interfaz software. El desempaquetado conlleva una operación adicional en función de la arquitectura de diseño empleada para la ejecución del algoritmo, esta operación consiste en la selección de los píxeles válidos. El significado de píxel válido atañe a que todos los píxeles procesados por un algoritmo hardware no son válidos para su representación por pantalla. La selección de los datos válidos será realizada vía software por la interfaz.

-132-

(9)

6.3.1. Transmisión de datos

En la transmisión y recepción de datos entre el host y la tarjeta Aristotle se utiliza el formato denominado “Little Endian”, el cual significa [w_algoritmia] “que el byte de menor peso se almacena en la dirección más baja de memoria y el byte de mayor peso en la más alta”. Con esto, si se pretende enviar o recibir datos de ocho bits (un byte), a través del bus PCI que trabaja con datos de 32 bits (cuatro bytes) es necesario que la comunicación sea lo más efectiva posible.

Por ello, para el envío de datos de 8 bits hacia la tarjeta Aristotle, se han de empaquetar los datos de un byte en palabras de cuatro bytes o viceversa. Tomando cuatro datos de la imagen (cuatro píxeles) y teniendo en cuenta el formato Little Endían, se tienen que agrupar (empaquetar) para formar las palabras de cuatro bytes que se enviarán por el bus PCI.

La Figura 6.2. muestra con mas detalle lo expuesto con anterioridad:

La tarjeta Aristotle trata los datos del bus PCI con el mismo formato

“Little Endian”, para cargarlos en la memoria FIFO. La FIFO se puede configurar para dos tamaños distintos, uno que toma datos de 1 byte (8 bits) y otro que los toma de 2 bytes (16 bits). Hay que recordar que el bus de datos de entrada o salida de la FPGA es de 16 bits (FID[15:0] o FOD[15:0]). A continuación se muestra como están dispuestos los datos en la memoria FIFO:

120 11 5 12

9 12 0 11

9 11 2 11

4 14 4 15

7 18 9 126 13

0 13 7 14

4 22 4 21

5 20 1 18

9 13 0 14

0 138 15

2 16 9 20

2 21 0 22

5 21 5 20

4 19 4 17

0 16

7 18 7 19

0 21 0 21

2 23 0 23

4 22 7 21

0 17 9 10

2 12 0 18

8 21 2 22

0 22 5 23

0 23 6 21

5 19 5 ...

11 129 120 119 125 0

...

...

...

...

14 4 11

4 11

2 11

9 12

0 12

9 11

5 12

0

PCI

31

0

Imagen en escala de grises

Píxeles de la imagen de tamaño byte (8 bits)

Empaquetado de 4 datos de 1 byte en una palabra de 4 bytes (32 bits)

Envío de datos a la tarjeta Aristotle a través del bus

Figura 6.2. Empaquetamiento de datos según método Little Endian.

(10)

6.4. Definición de variables de programa

Para el almacenamiento temporal de información se definen una serie de constantes y variables globales para el código de la interfaz Laplace, las cuales se muestran en la Figura 6.4.

Para el código de la interfaz Perímetro el tamaño de ReadData es [BUFFER_SIZE*2].

6.4.1. Constantes globales

Las Constantes globales permanecen invariables una vez definidas en la cabecera del programa, como tales se utilizarán:

fi: define el número de filas de la imagen.

-134- 120

129 11 5 12

0 144

114 11 2 11

9

xx x

xx x

xx x

xx x

xx x

xx x

xx x ... 112 11

9 12 0 12

9 11 5 12

0

... ... ... 144 11 2

12 0

11 5 ... ... ... 114 11

9 12 9 12

0

31

0

0 FIFO_IN 16

PCI FID [7:0]

Configuración de 8 bits

FIFO_IN

0 16

FID [15:0]

Configuración de 16 bits

Figura 6.3. Transmisión de datos por la FIFO según configuración.

//Constantes Globales

#define BUFFER_SIZE (144*100)

#define FLUSH_SIZE (32)

#define fi 144

#define co 101 //Variables Globales DWORD var[4];

DWORD ReadData[BUFFER_SIZE];

DWORD WriteData[BUFFER_SIZE + FLUSH_SIZE];

DWORD WriteSize;

HANDLE hDevice;

Figura 6.4. Variables y constantes de programa.

(11)

co: define el número de columnas de la imagen.

BUFFER_SIZE: esta constante define el tamaño del buffer que será enviado hacia el sistema de procesado hardware. La constante se inicializa con el tamaño de los datos que serán enviados a la tarjeta Aristotle, el tamaño de este buffer dependerá del algoritmo hardware implementado sobre el dispositivo reconfigurable.

FLUSH_SIZE: esta constante obliga a la FIFO a tener como mínimo 4 byte para asegurar una correcta comunicación con la tarjeta Aristotle.

6.4.2. Variable globales

Las variables globales definidas en la Figura 6.4. son utilizadas para el almacenamiento temporal de datos y serán inicializadas al inicio del programa.

DWORD var[4]: Array destinado al almacenaje de variables locales utilizadas por el módulo de empaquetado de datos para el desplazamiento de los bytes a lo largo de Global_bus de 4 bytes.

DWORD ReadData[BUFFER_SIZE]: Array1D donde se almacenarán los datos procedentes del procesado hardware.

DWORD WriteData[BUFFER_SIZE + FLUSH_SIZE]: Array1D donde se almacenarán los datos que serán enviados al sistema de procesado hardware.

DWORD WriteSize: Tamaño del array WriteData en formto 32bit.

HANDLE hDevice: Variable global para la apertura de elementos hardware.

6.5. Funciones para la transferencia de datos hacia/desde el sistema hardware

La transferencia de datos hacia el dispositivo reconfigurable es una tarea crítica en lo que se refiere al tiempo de procesado del sistema.

Por ello, y para explotar el paralelismo entre los dos procesadores puestos en juego en las interfaces software, el módulo de transferencia de datos ha sido implementado mediante funciones de C/C++ que permiten concurrencia de procesos, para ello se plantea la estructura basada en hilos (threads) que muestra la Figura 6.5. En ella se lanzan sucesivamente dos hilos de proceso al sistema, el primero de ellos escribe en la FIFO (write_thread) y el segundo lee la

(12)

FIFO (read_thread). La independencia entre las FIFO permite una lectura y escritura simultanea de ambos elementos hardware alcanzando el grado de concurrencia deseado. La función do_transfer() es la encargada de la llamada a los dos hilos descritos anteriormente.

6.6. Función main()

La función main() es la encargada de gestionar el programa principal donde se ha implementado la arquitectura software, en la que, como ya se ha mencionado antes, se han introducido los módulos necesarios para la gestión y control de la tarjeta Aristotle. Antes de describir los distintos módulos, se van a definir las variables locales que se han utilizado para esta arquitectura.

6.6.1. Variables locales

En la Figura 6.6. se muestran las variables que se han utilizado en el código de las interfaces.

-136- //Hilo de escritura

DWORD WINAPI write_thread(LPVOID lpParam) { DWORD nBytesReturned;

return RciWriteDevice(hDevice, (DWORD)lpParam, WriteData, WriteSize, &nBytesReturned); }

//Hilo de lectura

DWORD WINAPI read_thread(LPVOID lpParam) { DWORD nBytesReturned;

return RciReadDevice(hDevice, (DWORD)lpParam, ReadData, sizeof(ReadData), &nBytesReturned); } //Función de transferencia

void do_transfer(DWORD read_flag, DWORD write_flag) { //Definición de variables

DWORD thdReadId, thdWriteId;

HANDLE hThread[2];

//Selecciona el tamaño a transferir if( (read_flag & RCI_DEV_VPE) || (write_flag &

RCI_DEV_VPE) )

WriteSize = (BUFFER_SIZE + FLUSH_SIZE)*sizeof(DWORD);

else

WriteSize = BUFFER_SIZE*sizeof(DWORD);

//Comienza la escritura y lectura concurrente sobre la VPE

hThread[0] = CreateThread(NULL, 0, read_thread, (LPVOID)(read_flag | RCI_DEV_DMA0), 0,

&thdReadId);

hThread[1] = CreateThread(NULL, 0, write_thread, (LPVOID)(write_flag | RCI_DEV_DMA1), 0, &thdWriteId);

//Espera que finalizen los hilos de lectura y de escritura

WaitForMultipleObjects(2, hThread, TRUE, INFINITE); } Figura 6.5. Funciones concurrentes de transferencia de

datos.

//Variables Locales DWORD tiempoD1,

tiempoD2, tiempoM1, tiempoM2, tiempoEmp1, tiempoEmp2, tiempoConf1, tiempoConf2, tiempoTransf1, tiempoTransf2, tiempoBorra1, tiempoBorra2, tiempoDesem1, tiempoDesem2, tiempoTotal1, tiempoTotal2;

BOOL status;

int i, j, k, r, cont,

int frames; //Interfaz

Laplace

long perimeter[2]; //Interfaz Perimetro

//Variables MIL

MIL_ID MilApplication, MilSystem,

MilDigitizer, MilDisplay, MilDisplay1, MilDisplay2, MilImageOnBoard, MilImageDisp, MilImageDisp1,

MilImageDisp2, //Interfaz Laplace MilImageDisp3; //Interfaz Laplace FeatureList; //Interfaz Perimetro BlobResult //Interfaz Perimetro //Variables Array para almacenamiento de datos

static unsigned char abuffer[144][101];

static unsigned char abuffer2[144][100];

//Interfaz Laplace

WORD abuffer4[100*144*4];

//Interfaz Perimetro //Puntero

void *UnderlayPhysicalAddress = NULL;

Figura 6.5. Variables locales de programa.

(13)

Las variables de tipo DWORD han sido utilizadas para medir el tiempo que tardan los distintos módulos en ejecutarse; la variable status de tipo BOOL indica cuando se ha producido un error en la comunicación con la tarjeta Aristotle; y las variables de tipo entero(int) han sido utilizadas para recorrer las imágenes píxel a píxel y como contadores.

Las variables MIL se utilizan para la visualización en pantalla de las imágenes antes y después de ser procesadas.

Las variables Array bidimensionales se utilizan para almacenar las imágenes que van a ser o han sido procesadas.

El puntero UnderlayPhysicalAddress se utiliza para indicar dónde se encuentra almacenada la dirección física de la imagen capturada por el frame grabber (Genesis).

(14)

En las líneas de código que definen las variables específicas para cada algoritmo se ha comentado a qué algoritmo pertenecen. Las que no tienen comentario son comunes a los dos algoritmos.

6.6.2. Módulo de inicialización y configuración de la tarjeta Genesis

El sistema de visión está formado por una cámara analógica monocroma, funcionando en formato CCIR, y la tarjeta Genesis (Frame Grabber), encargada de la captura de imágenes a través de la cámara analógica. Además de la captura el frame grabber realiza la digitalización de las imágenes capturadas y el posterior envió a memoria del host. En este módulo de comunicación bidireccional, bajo las librerías MIL de Matrox, se realiza la inicialización, configuración y control de la tarjeta Genesis.

-138- //Inicialización del sistema Genesis MappAlloc(M_DEFAULT, &MilApplication);

MsysAlloc(M_SYSTEM_GENESIS, M_DEF_SYSTEM_NUM, M_SETUP, &MilSystem);

MdigAlloc(MilSystem, M_DEFAULT,"M_CCIR", M_DEFAULT, &MilDigitizer);

//Escalado de imagen obtenida de la cámara MdigControl(MilDigitizer, M_GRAB_SCALE , 0.25);

//Se definen tres displays: Imagen Original/ Procesado MIL/Procesado Aristotle MdispAlloc(MilSystem,M_DEFAULT,M_DISPLAY_SETUP,M_DEFAULT,&MilDisplay);

MdispAlloc(MilSystem,M_DEFAULT,M_DISPLAY_SETUP,M_DEFAULT,&MilDisplay1);

MdispAlloc(MilSystem,M_DEFAULT,M_DISPLAY_SETUP,M_DEFAULT,&MilDisplay2);

//Fuerza a los displays en monocromo utilizar la banda del Azul MdispControl(MilDisplay, M_COLOR_MODE, M_BLUE);

//Reserva buffers bidimensionales para los displays MbufAlloc2d(MilSystem, co, fi, 8+M_UNSIGNED,

M_IMAGE+M_PROC+M_DISP+M_NON_PAGED, &MilImageDisp);

MbufAlloc2d(MilSystem, co, fi, 1+M_UNSIGNED,

M_IMAGE+M_PROC+M_DISP+M_NON_PAGED, &MilImageDisp1);

MbufAlloc2d(MilSystem, co, fi, 8+M_UNSIGNED,

M_IMAGE+M_PROC+M_DISP+M_NON_PAGED, &MilImageDisp2);

MbufAlloc2d(MilSystem, co, fi, 8+M_UNSIGNED,

M_IMAGE+M_PROC+M_DISP+M_NON_PAGED, &MilImageDisp3);

//Inicializa los buffers de display con el valor 0 (negro) MbufClear(MilImageDisp, 0);

MbufClear(MilImageDisp1, 0);

MbufClear(MilImageDisp2, 0);

MbufClear(MilImageDisp3, 0);

//Adquiere la dirección base de la imagen capturada

MsysInquire(MilSystem, M_PHYSICAL_ADDRESS_UNDERLAY, &UnderlayPhysicalAddress);

//Crea un buffer en la banda Roja para la imagen capturada MbufCreateColor(MilSystem, 1, co, fi, 8L+M_UNSIGNED,

M_IMAGE+M_GRAB+M_PROC+M_ON_BOARD,

M_PHYSICAL_ADDRESS+M_PITCH_BYTE, M_DEFAULT, (void

*)&(UnderlayPhysicalAddress), &MilImageOnBoard);

// Habilita el bus master para copiar desde Genesis al host MsysControl(MilSystem, M_BUS_MASTER_COPY_TO_HOST, M_ENABLE);

//Asigna los buffers a los displays MdispSelect(MilDisplay, MilImageDisp);

MdispSelect(MilDisplay1, MilImageDisp1);

MdispSelect(MilDisplay2, MilImageDisp2);

Figura 6.7. Módulo de comunicación bidireccional con el sistema de visión

(15)

En la Figura 6.7. se muestra el código C/C++ que compone el módulo de comunicación con el sistema de visión, para el interfaz Laplace.

Para el caso de la inerfaz Perímetro, se muestra a continuación los apartados que difieren del otro algoritmo, permaneciendo iguales para el resto de apartados:

Como se puede observar en la reserva de buffers para los displays, en el código de la interfaz Perímetro, para MilImageDisp1 y MilImageDisp3, el tercer parámetro es 1+M_UNSIGNED, mientras que para el caso de la interfaz Laplace, son 8+M_UNSIGNED, esta diferencia se debe a que en la interfaz Perímetro, se tiene que trabajar con datos de tipo binario (1 bit) para realizar el procesado. El resto pueden trabajar con datos en escala de grises con valores de 0 a 255 (8 bits).

También se tiene que tener en cuenta que para la interfaz Perímetro no es necesario mostrar en un display los datos obtenidos de la tarjeta Aristotle, ya que estos datos son el resultado del cómputo realizado por el algoritmo hardware. Por eso no se necesita la misma cantidad de displays, que para el caso de la interfaz Laplace.

6.6.3. Módulo de inicialización y configuración de la tarjeta Aristotle

El módulo de inicialización y configuración de la tarjeta Aristotle es el encargado de la apertura del dispositivo hardware reconfigurable, y del establecimiento de las frecuencias de reloj del núcleo hardware.

La apertura del dispositivo hardware conlleva la búsqueda del mismo en el PC o su búsqueda a través de la dirección IP del servidor donde este esté ubicado. En nuestro caso la plataforma estará ubicada en el PC donde se ejecuten los algoritmos de visión.

//Se definen dos displays: Imagen Original/ Procesado MIL

MdispAlloc(MilSystem,M_DEFAULT,M_DISPLAY_SETUP,M_DEFAULT,&MilDisplay);

MdispAlloc(MilSystem,M_DEFAULT,M_DISPLAY_SETUP,M_DEFAULT,&MilDisplay1);

//Reserva buffers bidimensionales para los displays MbufAlloc2d(MilSystem, co, fi, 8+M_UNSIGNED,

M_IMAGE+M_PROC+M_DISP+M_NON_PAGED, &MilImageDisp);

MbufAlloc2d(MilSystem, co, fi, 1+M_UNSIGNED,

M_IMAGE+M_PROC+M_DISP+M_NON_PAGED, &MilImageDisp1);

//Inicializa los buffers de display con el valor 0 (negro) MbufClear(MilImageDisp, 0);

MbufClear(MilImageDisp1, 0);

//Asigna los buffers a los displays MdispSelect(MilDisplay, MilImageDisp);

MdispSelect(MilDisplay1, MilImageDisp1);

Figura 6.8. Líneas del código Algoritmo Perímetro que difieren del Algoritmo Laplace

(16)

La implementación del módulo de configuración en C/C++ conlleva el uso de las librerías específicas de la tarjeta Aristotle (MTRCI.LIB ver Apéndice I).

El módulo emite un mensaje de error en caso de que la variable hdevice = NULL.

En la figura 6.9. se puede observar cómo se realiza la inicialización y configuración de la tarjeta:

La última línea de este código es la encargada de configurar la FPGA de la tarjeta Aristotle con el núcleo oportuno, siendo este un archivo .BIT, el cual se debe encontrar en el mismo directorio donde esté ubicado el archivo de proyecto de la interfaz software que lo requiera. Para el caso de la interfaz Laplace, el archivo es prxfil.BIT y para la interfaz Perímetro es el archivo perim.BIT.

6.6.4. Módulo de procesado

El módulo de procesado para las dos interfaces software difiere bastante el uno del otro, para poder comentar el código utilizado para ambos casos se va a explicar primero uno y después el otro.

6.6.4.1. Módulo de procesado para la Interfaz Laplace

El procesado para esta interfaz se ha hecho obteniendo imágenes en modo continuo y procesándolas con las funciones MIL y con el núcleo hardware, el propósito de esto es ver la posibilidad de conseguir un procesado en tiempo real (aproximadamente más de 25 imágenes por segundo).

Para realizar el procesado en modo continuo se ha utilizado un bucle condicional, en concreto un bucle while(), cuya condición para finalizar es pulsar una tecla del teclado. La función que detecta si se ha pulsado una tecla es kbhit(), por lo tanto el bucle quedaría de la siguiente forma:

-140- //Abre el dispositivo (Aristotle)

hDevice = RciOpenDevice( (argc == 3) ? argv[2] : NULL, (argc >=

2) ? argv[1] : "#0", 0);

//Pone el reloj de la FIFO a 35MHz (Mitad del reloj de la VPE) RciSetDeviceClock(hDevice, RCI_CLK_VPE | RCI_CLK_ON, 70000);

//Configura VPE con núcleo (.BIT)

status = RciBootDevice(hDevice, RCI_DEV_VPE | RCI_DEV_DMA0,

"prxfil.BIT");

Figura 6.9. Módulo de inicialización y configuración de la tarjeta Aristotle

(17)

while(!kbhit()) { //Código de procesado }

Antes de procesar una imagen hay que obtenerla, para ello las librerías MIL ofrecen una función que permiten obtener imágenes de forma continua, esta función es MdigGrabContinuous(), esta función tiene que ir acompañada de otra función que permita retener la captura para realizar la siguiente captura, esta función es MdigHalt().

El código implementado tendría la siguiente forma:

MdigGrabContinuous(MilDigitizer,MilImageOnBoard);

MdigHalt(MilDigitizer);

Para realizar los mismos pasos que se aplicaron en el algoritmo hardware, con las librerías MIL se han realizado dos tipos de procesado sobre la imagen capturada, una binarización (umbral = 200) y una convolución con la máscara de Laplace, estas son:

MbufCopy(MilImageOnBoard, MilImageDisp);

MimBinarize(MilImageDisp, MilImageDisp3, M_GREATER, 200, M_NULL);

MimConvolve(MilImageDisp3, MilImageDisp1, M_LAPLACIAN_EDGE);

La primera línea copia la imagen capturada en un buffer de display (MilImageDisp), este buffer está asignado a un display que mostrará la imagen original por pantalla; en la segunda línea binariza la imagen y la carga en otro buffer de display (MilImageDisp3); y en la tercera realiza una convolución con el operador Laplace, dejando finalmente la imagen procesada en el buffer de display MilImageDisp1, el cual está asignado a un display que mostrará el resultado por pantalla.

A continuación se ha realizado el procesado a través del núcleo hardware, para ello, como ya se explicó anteriormente se han de empaquetar y desempaquetar los datos para la comunicación con la tarjeta Aristotle.

Antes de realizar el empaquetado de la imagen, esta se ha cargado en un array bidimensional con el que poder tener acceso a los datos que forman la imagen, esto se ha realizado de la siguiente forma:

MbuGet2d(MilImageDisp, 0, 0, co, fi, abuffer);

Para realizar el empaquetado se tiene que recorrer la imagen por columnas y por filas, para ello se han utilizado dos bucles for anidados, uno que recorre las filas y otro que recorre las columnas. En la Figura 6.10. se muestra el código del empaquetado de la imagen:

-141- //Módulo de empaquetado

MbufGet2d(MilImageDisp,0,0,co,fi,abuffer);

for (i=0,k=0;i<fi; i++) //fi = 144 {

for( j=1; j<co; j=j+4) //co = 101 {

var[0]= abuffer[i][j];

var[1]= abuffer[i][j+1];

var[1]= var[1]<<8;

var[2]= abuffer[i][j+2];

var[2]= var[2]<<16;

var[3]= abuffer[i][j+3];

var[3]= var[3]<<24;

WriteData[k++]=var[0]+var[1]+var[2]+var[3];

} }

(18)

En la Figura 6.10. se puede observar que el segundo bucle for no comienza desde 0 sino que comienza desde 1, esto se debe a que la imagen capturada por la tarjeta Genesis tiene la primera columna llena de ceros, provocando un error, ya que se considera esta línea vertical como parte del objeto a analizar. Por esta razón, los buffers de display tienen un ancho de 101 (= co), para eliminar la primera columna de la imagen original y poder enviar a la tarjeta Aristotle una imagen con un ancho 100 columnas (debido al diseño del algoritmo hardware).

Una vez realizado el empaquetado se procede a la transferencia de datos entre el host y la tarjeta Aristotle. Para esta transferencia se realizó una función que habilitaba dos hilos, uno para escritura y otro para lectura (ver Figura 6.5.). Esta función es llamada de la siguiente manera:

do_transfer(RCI_DEV_VPE, RCI_DEV_VPE);

Después de realizarse la transferencia, los datos procedentes de la tarjeta Aristotle están presentes en la variable ReadData. Estos datos tienen que ser desempaquetados para poder obtener unos resultados legibles. El módulo de desempaquetado realiza esta función:

-142- //Módulo de desempaquetado for (i=0,r=0;i<fi-2; i++) //fi = 144 {

for( j=0; j<co-1; j=j+4) //co = 101 {

abuffer2[i][j]=ReadData[r];

abuffer2[i][j+1]=ReadData[r]>>8;

abuffer2[i][j+2]=ReadData[r]>>16;

abuffer2[i][j+3]=ReadData[r]>>24;

r++;

} }

MbufPut2d(MilImageDisp2,0,0,co-1,fi,abuffer2);

Figura 6.11. Módulo de desempaquetado

(19)

Es importante notar que en el módulo de desempaquetado se recorren 100 columnas y 144 – 2 filas, las dos filas que no se recorren se debe a que no son datos válidos, debido a la convolución. La última línea carga el array bidimensional en el buffer de display, MilImageDisp2, este buffer está asignado a un display que mostrará el resultado obtenido por el procesado hardware.

Antes de finalizar el bucle while() es necesario realizar un reset a la tarjeta Aristotle. Esto se hace con la siguiente función:

RciResetDevice(hDevice, RCI_RST_DSP | RCI_RST_VPE);

Para contar aproximadamente cuántas imágenes se procesan por segundo se ha utilizado el siguiente segmento de código, el cual muestra por pantalla la cantidad de fps (fotogramas por segundo) que se están llevando a cabo.

cont = cont + (tiempoTotal2 - tiempoTotal1);

frames++;

if(cont > 1000) {

printf("\r%d fps",frames);

cont = 0;

frames = 0;

}

Este código actualiza el valor en pantalla sólo cuando ha transcurrido aproximadamente un segundo. Para contar un segundo (aproximadamente) se ha tomado un tiempo al principio del bucle while() y otro al final (justo antes del código que hay sobre estas líneas), la diferencia entre ambos tiempos ofrece un valor de tiempo en milisegundos, este valor se ha almacenado en una variable (cont).

Cada vez que se realiza el procesado la variable cont incrementa su valor, cuando esta valor supera los 1000 ms (1 segundo) se imprime por pantalla el valor del contador (frames) que incrementa su valor en cada paso del bucle.

El código C/C++ para el procesado de la interfaz Laplace quedaría de la siguiente forma:

//Bucle de procesado while (!kbhit())

{ tiempoTotal1 = GetTickCount();

//Captura imagen en continuo

MdigGrabContinuous(MilDigitizer, MilImageOnBoard);

//Procesado con MIL

MbufCopy(MilImageOnBoard, MilImageDisp);

MimBinarize(MilImageDisp,MilImageDisp3,M_GREATER ,200,M_NULL);

MimConvolve(MilImageDisp3,MilImageDisp1,M_LAPLACIAN_EDGE);

//Módulo de empaquetado ...

//Transferencia de datos

do_transfer(RCI_DEV_VPE, RCI_DEV_VPE);

//Módulo de desempaquetado ...

//Reset de Aristotle

RciResetDevice(hDevice, RCI_RST_DSP | RCI_RST_VPE);

//Retiene la captura MdigHalt(MilDigitizer);

tiempoTotal2 = GetTickCount();

//Cuenta los fps

cont = cont + (tiempoTotal2 - tiempoTotal1);

frames++;

if(cont > 1000) {fps = frames;

printf("\r%d fps",fps);

cont = 0;

frames = 0;

} }

(20)

6.6.4.2. Módulo de procesado para la Interfaz Perimetro

El procesado para esta interfaz se ha realizado obteniendo una sola imagen, a diferencia del algoritmo anterior que obtenía imágenes en modo continuo. Para la captura de una sola imagen las librerías MIL ofrecen la siguiente función:

MdigGrab(MilDigitizer, MilImageOnBoard);

Para el cálculo del perímetro con las librerías MIL, se ha utilizado el análisis de objetos (blobs). Antes de realizar el cálculo del perímetro de un objeto con el análisis de blobs, es necesario binarizar la imagen original de la misma forma que se realiza en el núcleo de procesado hardware, sino el perímetro calculado será muy distinto en ambos procesados. El código utilizado es el mismo que se utilizó en el algoritmo anterior:

MbufCopy(MilImageOnBoard, MilImageDisp);

MimBinarize(MilImageDisp, MilImageDisp1, M_GREATER, 200, M_NULL);

Una vez binarizada la imagen se procede al análisis de blobs, obteniendo como característica del objeto el perímetro del mismo.

Esto se realiza de la siguiente manera:

-144-

(21)

MblobAllocFeatureList(MilSystem, &FeatureList);

MblobAllocResult(MilSystem, &BlobResult);

MblobSelectFeature(FeatureList, M_PERIMETER);

MblobCalculate(MilImageDisp1,M_NULL, FeatureList, BlobResult);

MblobGetResult(BlobResult, M_PERIMETER+M_TYPE_LONG, perimeter);

Para imprimir por pantalla el resultado obtenido se ha procedido de la siguiente forma:

Printf(“\nPerimetro obtenido con MIL: %ld”,perimeter[1]);

La variable perimeter[2], es un array de dos elementos y por lo tanto está formado por perimeter[0] y perimeter[1]. Como se observará en los resultados dentro de este capítulo, la variable perimeter[0]

contiene el valor del perímetro del primer objeto que encuentra, siendo éste el error que se mencionó antes de la primera columna de píxeles en negro.

El empaquetado de la imagen se realiza de la misma forma que en la interfaz Laplace (ver Figura 6.10.). La transferencia de datos también, pero el desempaquetado no. Recordar que ahora los datos tienen un tamaño de 16 bits y no de 8 bits como en el caso del anterior algoritmo. El código que se ha utilizado para el desempaquetado de datos de 16 bits es el que se muestra en la Figura 6.13.

Una vez desempaquetados los datos en un array unidimensional (abuffer4) el resultado buscado se encuentra en la última posición del array, para ver el resultado se ha procedido de la siguiente manera:

cont=(fi-2)*(co-1);

printf("\nPerimertro obtenido con Aristotle:

%d",abuffer4[cont-1]);

El código C/C++ para el procesado del Algoritmo Perimetro quedaría de la siguiente forma:

-145- //Módulo de desempaquetado(2) for (i=0,r=0;r<(fi-2)*(co-1)/2; r++) {

abuffer4[i]=ReadData[r];

i++;

abuffer4[i]=ReadData[r]>>16;

i++;

}

Figura 6.13. Módulo de desempaquetado(2) //Módulo de procesado

//Captura una sola imagen

MdigGrab(MilDigitizer, MilImageOnBoard);

//Procesado con MIL

MbufCopy(MilImageOnBoard, MilImageDisp);

MimBinarize(MilImageDisp,MilImageDisp1,M_GREATER ,200,M_NULL);

MblobAllocFeatureList(MilSystem, &FeatureList);

MblobAllocResult(MilSystem, &BlobResult);

MblobSelectFeature(FeatureList, M_PERIMETER);

MblobCalculate(MilImageDisp1,M_NULL, FeatureList, BlobResult);

MblobGetResult(BlobResult, M_PERIMETER+M_TYPE_LONG, perimeter);

//Muestra perímetro MIL

printf("\nPerimetro obtenido con MIL: %ld",perimeter[1]);

//Módulo de empaquetado ...

//Transferencia de datos

do_transfer(RCI_DEV_VPE, RCI_DEV_VPE);

//Módulo de desempaquetado(2) ...//Muestra perímetro Aristotle cont=(fi-2)*(co-1);

printf(“\nPerimetro obtenido con Aristotle: %d”,abuffer4[cont-1]);

}

(22)

6.6.5. Módulo de presentación de tiempos

El módulo muestra los tiempos de ejecución de código más significativos del programa. Para la medida de los tiempos de cómputo de cada uno de los módulos más significativos y susceptibles de generar retrasos en el sistema, se han utilizado variables de lectura del reloj del sistema en el momento de iniciar el módulo y al finalizar el módulo, la relación de las variables usada queda patente en la Tabla 6.2.

Tipo de

variable Nombre Descripción

DWORD tiempoD1 Instante temporal de inicio del módulo de captura.

DWORD tiempoD2 Instante temporal de finalización del módulo de captura.

DWORD tiempoM1 Instante temporal de inicio del módulo de procesado software.

DWORD tiempoM2 Instante temporal de finalización del módulo de procesado software.

DWORD tiempoEmp1 Instante temporal de inicio del módulo de empaquetado de datos

DWORD tiempoEmp2 Instante temporal de finalización del módulo de

-146-

(23)

empaquetado de datos

DWORD tiempoConf1 Instante temporal de inicio del módulo de selección del algoritmo.

DWORD tiempoConf2 Instante temporal de finalización del módulo de selección del algoritmo.

DWORD tiempoTransf

1 Instante temporal de inicio del módulo de transferencia, recepción y cómputo de datos

DWORD tiempoTransf

2 Instante temporal de finalización del módulo de transferencia, recepción y cómputo de datos

DWORD tiempoBorra

1 Instante temporal de inicio del borrado del dispositivo reconfigurable

DWORD tiempoBorra

2 Instante temporal de finalización del borrado del dispositivo reconfigurable

DWORD tiempoDese

m1 Instante temporal de inicio del módulo de desempaquetado de datos

DWORD tiempoDese

m2 Instante temporal de finalización del módulo de desempaquetado de datos

DWORD tiempoTotal1 Instante temporal de inicio del módulo de procesado de datos

DWORD tiempoTotal2 Instante temporal de finalización del módulo de procesado de datos

La resolución máxima de las variables de lectura del reloj es de 1ms.

El código C/C++ empleado en resolución del módulo se muestra en la Figura 6.15.

6.6.6. Módulo de finalización de la tarjeta Aritotle

Antes de finalizar el programa es necesario liberar la tarjeta Aristotle de los lazos que la unen con el sistema, además de parar los relojes que se iniciaron el la configuración de la misma. El código que se encarga de liberar el dispositivo se encuentra a continuación:

//Módulo de finalización de Aristotle status = RciCloseDevice(hDevice);

RciBootDevice(hDevice, RCI_DEV_VPE | RCI_DEV_DMA0, NULL);

RciSetDeviceClock(hDevice, RCI_CLK_VPE | RCI_CLK_OFF, 0);RciResetDevice(hDevice, RCI_RST_DSP | RCI_RST_VPE);

Figura 6.16. Módulo de finalización de Aristotle //Módulo de visualización

printf("Tiempos: Capt_dig= %d ms,Proc_Mil= %d ms,Empaquetado= %d ms, Conf_FPGA= %d ms\n", (tiempoD2-tiempoD1),

(tiempoM2-tiempoM1),(tiempoEmp2-tiempoEmp1),(tiempoConf2-tiempoConf1));

printf("Tiempos: Cómputo= %d ms,Borrado= %d ms, Desempa= %d ms\n", (tiempoTransf2- tiempoTransf1),(tiempoBorra2-tiempoBorra1),

(tiempoDesem2-tiempoDesem1));

printf("\n\nTiempo Total= %d ms\n\n",(tiempoTotal2-tiempoTotal1));

Figura 6.15. Código C/C++ del módulo de visualización de resultados.

Tabla 6.2.Descripción de las variables temporales utilizadas para la medición de tiempos de proceso.

(24)

6.6.7. Módulo de liberación de las MIL

Al igual que la tarjeta Aristotle, los tipos MIL_ID, también tienen que ser liberados, pero con la condición de hacerlo en sentido inverso al que se utilizó para crearlos, es decir, si primero se creo MilApplication, después MilSystem, etc., para liberarlos el último tiene que ser MilApplication, precedido de MilSystem, etc. En la Figura 6.17. se muestra el módulo de liberación de las MIL.

6.7. Validación de Resultados

En este apartado se van a poner en marcha los distintos sistemas explicados. Para comprobar el funcionamiento de los algoritmos se ha utilizado una figura impresa en una hoja de papel. La figura se presenta en un tono oscuro frente a un fondo mucho mas claro. La cámara se ha situado a unos 30 cm de la figura impresa. A continuación se muestran los resultados obtenidos por ambas arquitecturas, utilizando los dos algoritmos que se han presentado en los apartados anteriores.

6.7.1. Interfaz Laplace

El núcleo hardware con el que se configura la unidad de procesado hardware es “PRXFIL.BIT”. El código fuente de la interfaz software se ubica en el archivo “TestBinM.c”, dentro de la carpeta “Interfaz Laplace”.

-148-

//Módulo de liberación de las MIL MblobFree(BlobResult); //Algoritmo Perimetro

MblobFree(FeatureList); //Algoritmo Perimetro

MbufFree(MilImageOnBoard);

MbufFree(MilImageDisp3);

//Algoritmo Laplace MbufFree(MilImageDisp2);

//Algoritmo Laplace MbufFree(MilImageDisp1);

MbufFree(MilImageDisp);

MdispFree(MilDisplay2); //Algoritmo Laplace

MdispFree(MilDisplay1);

MdispFree(MilDisplay);

MdigFree(MilDigitizer);

MsysFree(MilSystem);

MappFree(MilApplication);Figura 6.17. Módulo de liberación de las MIL

(25)

La interfaz realiza la captura de imágenes desde una cámara analógica monocroma, las procesa a través de librerías de procesado software (MIL) y mediante un procesado hardware (Aristotle). El procesado consiste en tomar una imagen en escala de grises, binarizarla con un umbral de 200 y hacer una convolución con una máscara de Laplace, para la detección de bordes. Este procesamiento es continuo, es decir, una vez procesada una imagen se vuelve o tomar otra que será procesada seguidamente, y así hasta que se le indique al programa que debe dejar de procesar.

Los datos más relevantes de esta interfaz se muestran en la siguiente figura:

El resultado de ejecutar el “TestBinM.exe” se muestra en la Figura 6.19. En el display #0, se encuentra la imagen original, en el display #1, la imagen procesada por las MIL, y el display #2, muestra el resultado de procesar la imagen original con la tarjeta Aristotle.

Datos Relevantes

Núcleo a examinar: Algoritmo de detección de bordes. Archivo “PRXFIL.BIT”

Archivo fuente: “TestBinM.c”

Ejecutable: TestBinM.exe

Tamaño de la Imagen: 100x144 Umbral de binarización= 200.

Máscara:

0 1 0

1 4 1

0 1 0

Frecuencia máxima: 35MHz

Resultado: 100x144 datos de 8 bits

Figura 6.18. Datos relevantes de la interfaz Laplace.

Display #0 Display #1 Display #2

(26)

La cantidad de imágenes por segundo que se han podido procesar se muestran en la ventana de comandos, para este caso se ha llegado hasta 9 fps (fotogramas por segundo). En la figura 6.20. se muestra la ventana de comandos, en la que se puede ver la cantidad de fps que se están procesando y además el tiempo que han necesitado, en la última imagen procesada, de los diferentes módulos que se necesitan para el procesado.

En la tabla 6.3. se muestran los tiempos obtenidos en este procesado:

Tiempos de procesado: Imagen 144x100x8bit Interfaz Laplace (Detección de bordes)

Tiempo (ms) MIL Aristotle

Configuración 0 121

Captura 40 40 (MIL)

Procesado 30 0

Empaquetado 0 0

Desempaquetado 0 0

Finalización 0 10

Fotogramas/s (fps) 9

Procesado total 70 40

Realizando sólo un procesado hardware, es decir, sin hacer el procesado software, se pueden procesar hasta 13 imágenes por segundo. En la Figura 6.21. se muestran la ventana de comandos

para el mismo

algoritmo, pero

quitando el

-150-

Figura 6.19. Resultado de la detección de bordes con MIL y con algoritmo PRXFIL para Aristotle.

Figura 6.20. Ventana de comandos de la interfaz Laplace.

Tabla 6.3. Comparación entre tiempos de procesado sw/hw para el algoritmo de Laplace.

(27)

procesado por las MIL, para obtener una velocidad de procesamiento mayor.

En la tabla 6.4. se muestran los tiempos que se ha necesitado para realizar el proceso hardware, sin realizar el procesado software:

6.7.2. Interfaz Perímetro

El núcleo hardware con el que se configura la unidad de procesado hardware es “PERIM.BIT”. El código fuente de la interfaz software se ubica en el archivo “TestPerim.c”, dentro de la carpeta “Interfaz Perímetro”.

La interfaz realiza la captura de una imágen desde una cámara analógica monocroma, la procesa a través de librerías de procesado software (MIL) y mediante un procesado hardware (Aristotle). El procesado consiste en tomar la imagen en escala de grises, binarizarla con un umbral de 200, hacer una convolución con una máscara de Laplace, para la detección de bordes y contar los píxeles que forma dicho borde, obteniéndose así el perímetro de la imagen.

Los datos más relevantes de este algoritmo se muestran en la siguiente figura:

Tiempos de procesado: Imagen 144x100x8bit Algoritmo Laplace (Detección de bordes)

Tiempo (ms) Aristotle

Configuración 120

Captura 40 (MIL)

Procesado 10

Empaquetado 0

Desempaquetado 0

Finalización 10

Fotogramas/s (fps) 13

Procesado total 50

Figura 6.21. Ventana de comandos para Algoritmo Laplace sin procesado MIL.

Tabla 6.4. Tiempos de procesado hw para la interfaz Laplace.

(28)

El resultado de ejecutar el “TestPerim.exe” se muestra en la Figura 6.23.

Obsérvese que además del cálculo del perímetro mediante las MIL y Aristotle, se ha obtenido, como en la interfaz anterior, el tiempo que tardan los distintos módulos que realizan el procesado. También hay que notar que el resultado obtenido por los dos modos de procesamiento, dan un valor distinto, esto puede ser debido a estimaciones que internamente hacen las librerías MIL.

En la Tabla 6.5. se pueden observar los distintos tiempos que ha necesitado cada módulo para llevar a cabo el procesado:

Tiempos de procesado: Imagen 144x100x8bit

-152-

Figura 6.22. Datos relevantes de la interfaz Perímetro.

Datos Relevantes

Núcleo a examinar: Algoritmo de cálculo de perímetro. Archivo “PERIM.BIT”

Archivo fuente: “TestPerim.c”

Ejecutable: TestPerim.exe

Tamaño de la Imagen: 100x144 Umbral de binarización= 200.

Máscara:

0 1 0

1 4 1

0 1 0

Frecuencia máxima: 35MHz Resultado: Un dato de 16 bits

Figura 6.23. Ventana de comandos para la interfaz Perímetro.

(29)

Algoritmo Perímetro (Cálculo Perímetro)

Tiempo (ms) MIL Aristotle

Configuración 0 190

Captura 200 200 (MIL)

Procesado 20 10

Empaquetado 0 0

Desempaquetado 0 0

Finalización 0 0

Procesado total 220 210

Tabla 6.5. Comparación entre tiempos de procesado sw/hw para el algoritmo de Perímetro.

Referencias

Documento similar

Ciaurriz quien, durante su primer arlo de estancia en Loyola 40 , catalogó sus fondos siguiendo la división previa a la que nos hemos referido; y si esta labor fue de

Cedulario se inicia a mediados del siglo XVIL, por sus propias cédulas puede advertirse que no estaba totalmente conquistada la Nueva Gali- cia, ya que a fines del siglo xvn y en

El nuevo Decreto reforzaba el poder militar al asumir el Comandante General del Reino Tserclaes de Tilly todos los poderes –militar, político, económico y gubernativo–; ampliaba

The part I assessment is coordinated involving all MSCs and led by the RMS who prepares a draft assessment report, sends the request for information (RFI) with considerations,

Products Management Services (PMS) - Implementation of International Organization for Standardization (ISO) standards for the identification of medicinal products (IDMP) in

This section provides guidance with examples on encoding medicinal product packaging information, together with the relationship between Pack Size, Package Item (container)

D) El equipamiento constitucional para la recepción de las Comisiones Reguladoras: a) La estructura de la administración nacional, b) La su- prema autoridad administrativa

b) El Tribunal Constitucional se encuadra dentro de una organiza- ción jurídico constitucional que asume la supremacía de los dere- chos fundamentales y que reconoce la separación