Manual de usuario

Ver.1.0
 visión artificial
_______________________________________________________________

Nota preliminar
Sherlock constituye una herramienta estándar de ejecución de aplicaciones de
visión artificial orientado a entornos industriales.

Infaimon pretende con este manual facilitar el acceso y la utilización de

Sherlock a cualquier persona con interés e iniciativa para la configuración de
sistemas de visión de forma sencilla y ágil.

Este manual se completa con los manuales originales suministrados por los
fabricantes del producto y con la información distribuida por Infaimon en
conjunto con este manual de usuario.

Asimismo, ponemos a su disposición nuestro equipo técnico para cualquier

duda o consulta al respecto de este manual y de Sherlock mediante el correo
electrónico stecnic@infaimon.com.

INFAIMON (Spain) INFAIMON(Spain) INFAIMON (Portugal) INFAIMON México

Vergós, 55 Ribera del Loira, 46 Rua Sra. do Alamo, 48 Av. Insurgentes Sur, 600 - 301
E-08017 Barcelona E-08042 Madrid Esgueira 3800-262 Col. Del Valle
España España Aveiro - (Portugal) 03100 México D.F.
Tel. (+34) 93 252 5757 Tel. (+34) 902 463 246 Tel. (+351) 234 312 034 Tel. (+52) 55 1107 0814
Fax. (+34) 93 252 5758 Fax. (+34) 91 503 0090 Fax.(+351) 234 312 035 Fax. (+52) 55 1107 1904 ext. 121

_____________________www.infaimon.com____________________ 3
 visión artificial
_______________________________________________________________
INDICE
nº de página

1. Instalación del Software..................................................................... 6

2. Compativilidad con Hardware.............................................................7
3. Licencias.............................................................................................8
4. Herramientas......................................................................................9
4.1. ROIs.............................................................................................9
4.1.1.ROIs Área............................................................................ 9
4.1.2.ROIs Línea.........................................................................10
4.2. Preproceso.................................................................................13
4.2.1.[1x3,1x5, 1x7, 3x1, 3x3, 5x1, 5x5 y 7x1] ..........................14
4.2.2.Constant.............................................................................14
4.2.3.Dice....................................................................................14
4.2.4.Dilate y Erode ...................................................................15
4.2.5.Equalize............................................................................. 15
4.2.6.Proceso First......................................................................15
4.2.7.Proceso Flip.......................................................................16
4.2.8.Gain Offset.........................................................................16
4.2.9.Procesos Gausianos .........................................................16
4.2.10 Gradient........................................................................... 17
4.2.11 Procesos Highpass..........................................................17
4.2.12 Procesos Aridméticos...................................................... 17
4.2.13 Invert................................................................................18
4.2.14 Procesos .........................................................................18
4.2.15 Median............................................................................. 18
4.2.16 Noise................................................................................19
4.2.17 Normalize.........................................................................19
4.2.18 Outline..............................................................................20
4.2.19 Procesos de Gradiente.................................................... 20
4.2.20 Project H, Project V..........................................................20
4.2.21 Random............................................................................21
4.2.22 Rotate...............................................................................21
4.2.23 Sharpen............................................................................21
4.2.24 Skeleton...........................................................................21
4.2.25 Smooth.............................................................................22
4.2.26 Procesos de Binarización................................................ 22
4.3. Algorithms..................................................................................22
4.4. Herramientas monocromo.........................................................22
4.4.1. Inside Caliper y Outside Caliper....................................... 23
4.4.2. Edge Count.......................................................................24
4.4.3. First Edge..........................................................................25
4.4.4. Conectivity.........................................................................26
4.4.5. Barcode.............................................................................27
4.4.6. Search...............................................................................28
4.4.7. OCR Gray Scale............................................................... 33
4.5. Herramientas de color...............................................................37
4.5.1. Color Presece Meter.........................................................37
4.5.2. Spot Meter.........................................................................40

_____________________www.infaimon.com____________________ 4
 visión artificial
_______________________________________________________________

nº de página

4.5.3. Color Mapping ..................................................................46

5. Calibración.......................................................................................51
5.1. Calibración Software, método 1: Puntos...................................52
5.2. Calibración Software, método 2: Valores de Transf................. 55
6. Landmarks y Alineació.....................................................................59
7. GUI...................................................................................................66
7.1. Interfaz.......................................................................................66
7.1.1. La barra de herramientas..................................................68
7.1.2. El menú principal...............................................................68
7.2. Ventana de imagen (image Windows)...................................... 70
7.2.1. La barra de herramientas de la ventana de imagen.........71
7.3. ROIs, Algoritmos y Preprocesos...............................................72
7.3.1. ROIs Área.........................................................................73
7.3.2. ROIs Línea.......................................................................74
7.3.3. Algoritmos........................................................................ 76
7.3.4. Pre-procesadores.............................................................77
7.3.5. Posicionados de ROIs......................................................80
7.3.6. Propiedades de las ROI...................................................82
7.4. Programa, Readings y Variables...........................................87
7.5. Variables................................................................................91
7.6. Instrucciones..........................................................................94
7.6.1. Instrucciones de flujo del programa.................................96
7.6.2. Subrutinas......................................................................100
7.7. Monitor and Reporter...........................................................105
7.8. Depuración (Debugging)..................................................... 107
7.8.1. Ejecución del modo paso a paso...................................107
7.8.2. Ejecución en Modo ralentizado......................................107
7.8.3. Modo de Instrucciones Resaltadas................................108
7.8.4. Breakpoints.................................................................... 108
7.9. Imágenes.............................................................................110
7.10. Progamación con JavaScript...............................................113
8. Controles ActiveX........................................................................117
8.1. Introducción.........................................................................117
8.1.1. Ejemplos.........................................................................117
8.2. Arquitectura GUI de usuario................................................118
8.3. Implementación de la GUI...................................................119
ADENDUM...........................................................................................122

_____________________www.infaimon.com____________________ 5
 visión artificial
_______________________________________________________________

1. Instalación del Software

Sherlock debe ser instalado en sistemas operativos Windows 2000 o Windows
XP desde el CD-ROM de Sherlock. En el caso de que el CD-ROM no arranque
automáticamente, haga clic en “Inicio” de Windows, seleccione ejecutar, e
introduzca setup.exe de la unidad donde esté el CD.

Se recomienda realizar el proceso de instalación por defecto, o bien utilizar el

explorador de Windows, para navegar en el CD-ROM, y hacer un doble-clic en
el archivo setup.exe del CD-ROM. Se abrirá una pantalla de instalación en la
que se debe seleccionar el sistema operativo y el sofware a instalar. Una vez
seleccionados los campos, deberá ir a la opción “Install Sofware”, y seleccionar
la dirección donde se deberá instalar el programa, tras el proceso de
instalación, Sherlock aparecerá automáticamente en el menú Inicio de
Windows.

Para utilizar Sherlock 7 como software de captura, deberá asegurarse de tener

instalados alguno o varios de los siguientes softwares de adquisición (en
dependencia del tipo de cámara a utilizar para la adquisición) previamente al
proceso de instalación:

1. Sapera LT Runtime (6.0 o superior).

2. IFC Runtime (5.9 o superior).
3. CI1394 para cámaras AVT.

Por último deberá instalar el Software Sentinel si su licencia de software está

ligada a una llave externa USB o puerto paralelo.

_____________________www.infaimon.com____________________ 6
 visión artificial
_______________________________________________________________

2. Compatibilidad con Hardware

Sherlock puede funcionar con imágenes bmp, jpeg o gif guardadas en el disco
duro o bien con imágenes de cámaras capturadas con:

• Plataforma frame grabber Librerías IFC / SAPERA LT:

Las librerías IFC y Sapera, y sus utilidades para configurar cámaras

funcionan de forma separada del Sherlock. Sherlock puede funcionar sin
necesidad de estas librerías. Las librerías runtime y los drivers están
incluidos en el CD-ROM de Sherlock.

Sherlock necesita las librerías Sapera o IFC, para capturar imágenes de

los frame grabbers de Coreco.

Frame grabbers basados en:

IFC SAPERA LT

Pc2Vision X64
PcVision Bandit II
PcVisionplus
PcCamlink
PcDig
PcRGB
VA21
VA31
VA40/41
VA50/51

• Plataforma cámara digital IEEEa.

Las CI1394 son un subconjunto de las librerías IFC, con ellas podrá
capturar con cámaras AVT, accediendo a todas sus funcionalidades.

_____________________www.infaimon.com____________________ 7
 visión artificial
_______________________________________________________________

3. Licencias
Sherlock requiere de una licencia que puede estar ligada a una llave externa
(Mochila USB o puerto paralelo) o al “Frame Grabber” de DALSA Coreco.

Sherlock 7 no funciona con licencias de Sherlock 6.x o inferior.

Sherlock, sin licencia, funcionará en modo DEMO, pudiendo realizar todas las
funciones exceptuando la adquisición de imagen.

Para poder instalar las licencias de llave externa (USB o puerto paralelo), se
deberá instalar el software Sentinel, una vez ya esté instalado el software
Sherlock.

Sentinel se utiliza para monitorizar las licencias y define si se esta trabajado en

(Full o Demo mode).

La utilidad “License Manager” de Sherlock 7 se utiliza para supervisar las

licencias instaladas. El programa “License Manager” se encuentra en:

Start –> Programs –> ipd ... –> Sherlock –> License Manager.

_____________________www.infaimon.com____________________ 8
 visión artificial
_______________________________________________________________

4. Herramientas
En Sherlock 7 los procesos o preprocesos que se utilizan en las herramientas
de área, línea o multilínea, los tendremos que clasificar en dos grupos:
monocromo y color. Esta separación se realiza ya que no serán los mismos
procesos y preproceso que podamos utilizar, dependiendo de si la imagen es
en color o en blanco y negro.

A una imagen colorse le pueden aplicar todos los preprocesos y procesos, ya

que se puede convertir en monocromo y trabajar posteriormente con ella.

4.1. ROIs
Una ROI (región de interés) define el área de píxels a procesar. Una ventana
de imagen puede contener tantas ROI como sean necesarias.

Hay dos tipos de ROIs: área y línea.

4.1.1. ROIs de Área

En las ROI de Área se procesan los píxels interiores del área incluyendo los
contenidos en los bordes.
Rectángulo Anillo Polígono Toroide Área Circular

Las ROIs de Área se utilizan para procesar grupos de píxeles de dos

dimensiones.

Lectura de un código de barras con un ROI rectangular

_____________________www.infaimon.com____________________ 9
 visión artificial
_______________________________________________________________

Realización de un análisis Blob con una ROI anular

Cuando la ROI anular procesa sus píxels, los redistribuye en un

rectángulo, y puede tener cierta distorsión. Los cuadrados rojos que enmarcan
los botones de los ROI polígonos, toroides y círculos significan que procesan
sus píxeles en el lugar, sin remapearlos en un rectángulo, por tanto no ocurre
distorsión.

4.1.2. ROIs de Línea

Los ROIs de tipo línea procesan los píxels a lo largo de la línea. Hay dos tipos
de ROIs de línea: Simple y Múltiple.

Simple
Punto Línea Poli-línea Arco Circunferencia

Múltiple
Rastrillo Radial Arco iris Ojo de Buey

Las ROI circunferencia, arco iris y ojos de buey procesan los píxels a lo
largo de sus líneas, no dentro o entre ellas.

_____________________www.infaimon.com____________________ 10
 visión artificial
_______________________________________________________________
Para añadir una ROI a una ventana de imagen, hay que hacer clic en el botón
ROIs, en la barra de herramientas de la ventana, y después hay que hacer clic
en la ventana de imagen para definir la posición y tamaño de la misma.

Diferentes ROIs requieren diferentes números de clic para definir su tamaño y

posición.

Punto Un Clic.
Línea Dos clics, uno para cada extremo de la línea.
Poli-línea n clics, uno para cada vértice de la línea; doble clic izquierdo
para completar la línea.
Arco Tres clics, uno para cada límite del arco, uno que define la
curvatura.
Circunferencia Dos clic, uno para el centro y otro que define el radio.
Rastrillo Dos clic, uno para cada esquina del rectángulo que lo define.
Radial Tres clics, uno para situar el centro de la “rueda”, dos más
(Spoke) para situar el inicio y el fin del radio.
Arco Iris Cuatro clics, uno para cada extremo del arco iris, uno para
definir la curvatura del arco interior o exterior y uno para definir
la concentricidad del arco interno o externo.
Ojo de Buey Tres clics, uno para posicionar el centro del ojo de buey, uno
para definir el radio del círculo interno o externo y otro para
definir el otro radio interior o exterior.
Rectángulo Dos clics, uno para cada esquina opuesta.
Anillo Cuatro clics, uno para cada extremo del arco, uno para definir
el arco interno o externo y otro para definir el arco externo o
interno.
Polígono n clics, uno para cada vértice del polígono y hacer doble clic
izquierdo para completar el polígono.
Toroide Tres clics, uno para posicionar el centro del círculo, uno para
definir el radio interno o externo del círculo y uno para definir el
radio externo o interno del círculo.

Se asignan nombres por defecto a las ROIs que indican su tipo y orden de
creación: RectA, TorusA, RectB, RectC, SpokeA, etc. Para renombrar una
ROI, haga doble clic en ella dentro de la ventana de imagen o dentro del panel
de Programa abriendo el dialogo Edit.

Con la versión 7 de Sherlock se pueden realizar 7 preprocesos y 3 procesos

por ROI. Estos preprocesos y procesos los definimos en la pestaña
‘Processing’:

_____________________www.infaimon.com____________________ 11
 visión artificial
_______________________________________________________________

En la pestaña “Position” se definen las coordenadas del ROI y el ángulo del

mismo. En esta pestaña se puede fijar ROI para que no sea movida
involuntariamente:

De la misma forma, se pueden variar las coordenadas y el ángulo de forma

precisa o centrar la ROI respecto a la imagen.

En la última pestaña ‘Properties’, se puede observar el Histograma y la

intensidad de la imagen además de realizar el proceso de alineación al cual
nos referiremos en el punto 6 de este manual.

_____________________www.infaimon.com____________________ 12
 visión artificial
_______________________________________________________________

A continuación se enumeran los preprocesos y los procesos más significativos

tanto para imágenes color como para imágenes monocromo.

4.2. Preproceso:
A continuación se enumeran todos los prepocesos existentes. Dependiendo del
tipo de ROI seleccionado y de si la imagen es Monocromo o Color, se activarán
unos u otros. Son los siguientes:

1x3, 1x5, 1x7, 3x1, 3x3, 5x1, 5x5, 7x 1, Constant, Dice, Dilate, Equalize, Erode,
Fill, First DiffX, First Diff XY, First Diff Y, Flip H, Flip HV, Flip V, Gain Offset,
Gaussian, Gaussian 5x5, Gradient, Highpass, Highpass 5x5, Image Add, Image
AND, Image Extract, ImageInject, Image Max, Image Min, Image OR, Image
Retrieve, Image save, Image Sub AB, Image Sub Abs, Image Sub BA, Image
Windows, Image XOR, Invert, Laplace, Laplace 5x5, Median, Noise, Normalize,
Outline, Prewitt X, Prewitt XY, Prewitt Y, Project H, Project V, Random,
Roberts, Roberts Down, Roberts Up, Rotate, Second Diff X, Second Diff XY,
Second Diff Y, Sharpen, Skeleton, Smooth, Sobel X, Sobel XY, Sobel Y,
Treshold, Treshold Adaptive, Treshold Band, Treshold Down, Treshold Down
Masked, Treshold Local Adaptive, Threshold Up y Threshold Up Masked.

Pasamos a agrupar los diferentes Preprocesos por su funcionalidad

Como muestra, empleamos la siguiente imagen original.

_____________________www.infaimon.com____________________ 13
 visión artificial
_______________________________________________________________

4.2.1. Preprocesos convolutivos [1x3, 1x5, 1x7, 3x1,

3x3, 5x1, 5x5 y 7x1]
Todos estos preprocesos no son más que diferentes tipos de convoluciones.
Una convolución consiste en multiplicar una matriz dada, en este caso la
imagen, considerada también como una matriz de niveles de gris, por una
matriz creada por el usuario.

Estas herramientas servirán para crear filtros de usuario, ya que la mayoría de

filtros que se aplican a la imagen, se basan en convoluciones.

4.2.2. Constant

Este preproceso convierte todos los pixels dentro de la ROI, en un valor

predeterminado por el usuario.

4.4.3. Dice
Este preproceso proyecta sobre la imagen una cuadricula, que se puede definir
por el usuario y que definirá el tamaño de el rectángulo que cortará la imagen
separando los cuadros entre ellos. Este preproceso se emplea para segmentar
la imagen en n subimágenes.

_____________________www.infaimon.com____________________ 14
 visión artificial
_______________________________________________________________

4.2.4. Dilate y Erode

Con este preproceso se dilata o erosiona los objetos binarios (blobs) que se
encuentren en la ROI. La suma de un dilate más un erode tendrá como
consecuencia un Open, y la suma de un erode más un dilate tendrá como
consecuencia un Close, que servirán para separar o juntar blobs sin variar su
forma.

4.2.5. Equalize

Este preproceso varía el nivel de gris de todos los pixels del ROI, toma el valor
mínimo en nivel de gris de todos los pixels de la ROI y lo convierte 0. Realiza la
misma operación para el valor máximo convirtiéndolo en 255, de modo que
realiza un escalado de valores según este máximo y mínimo obteniendo una
imagen mucho más contrastada.

4.2.6. Preprocesos First [First DiffX, First Diff XY y First

Diff Y]

Encuentra la primera diferencia o salto en nivel de gris en el eje que se

especifique.

_____________________www.infaimon.com____________________ 15
 visión artificial
_______________________________________________________________

4.2.7. Preprocesos Flip [Flip H, Flip HV y Flip V]

Con este grupo de preproceso se obtiene una imagen especular colocando el

eje de simetría del espejo en V-vertical, H- Horizontal y HV- en los dos ejes.

4.2.8. Gain Offset

Este filtro actuará como si se variara la ganancia de la cámara sobre la ROI

seleccionada, aumentando la intensidad en todos los pixels de la ROI.

4.2.9. Preprocesos Gausianos. Gaussian y Gaussian

5x5

Con este preproceso se realiza un filtro de suavizado, que aplicará una

Gaussiana pudiendo variar la distribución de la Gaussiana.

_____________________www.infaimon.com____________________ 16
 visión artificial
_______________________________________________________________

4.2.10. Gradient

Realiza un Gradiente de la línea.

4.2.11. Preprocesos Highpass. Highpass y Highpass

5x5

Aplica un filtro paso alto, dejando pasar las frecuencias altas dentro de la
imagen. Lo que equivale a marcar los detalles, como el perfil de las formas.

4.2.12. Preprocesos Aritméticos. [Image Add, Image

AND, Image Extract, ImageInject, Image Max, Image
Min, Image OR, Image Retrieve, Image save, Image Sub
AB, Image Sub Abs, Image Sub BA, Image Windows y
Image XOR]

Este grupo de funciones trabajará directamente sobre la imagen, restando,

sumando o realizando funciones lógicas con una o más imágenes
seleccionadas.

_____________________www.infaimon.com____________________ 17
 visión artificial
_______________________________________________________________
4.2.13. Invert

Con esta función se invierte el valor de los pixels de toda la ROI pasando el 0 a
255, el 1 a 254 y así todos los pixels respectivamente.

4.2.14. Preprocesos Laplacianos. Laplace y Laplace 5x5

Con este preproceso se realiza un filtro de contorno que aplicará una

Laplaciana pudiendo variar la distribución de la misma.

4.2.15. Median

Este filtro realiza el filtro de mediana con una matriz de 3x3. Eliminando ruido
aleatorio de la imagen.

_____________________www.infaimon.com____________________ 18
 visión artificial
_______________________________________________________________

4.2.16. Noise

Con este preproceso se aplicará a la ROI seleccionada ruido aleatorio, esto

puede servir al realizar las pruebas, para determinar la robustez del proceso
posterior.

4.2.17. Normalize

Esta herramienta es parecida al equalize pero funciona de forma ligeramente

distinta. Normalizar la imagen es tomar un porcentaje de máximo y de mínimo y
reconvertirlo en el valor máximo y mínimo y escalar el resto de valores.

Ej. Tomamos un 10% al máximo y al mínimo. Esto convertirá los valores entre
0 y 25 en 0. Entre 240 y 255 en 255 y los demás los reescalará.

_____________________www.infaimon.com____________________ 19
 visión artificial
_______________________________________________________________

4.2.18. Outline

Para poder utilizar este preproceso es necesario que la imagen este binarizada
previamente, para ello anteriormente se debe realizar un preproceso de
Threshold. Esta herramienta definirá la línea perimetral de los blobs.

4.2.19. Preprocesos de Gradiente [Prewitt X, Prewitt XY

, Prewitt Y, Roberts, Roberts Down, Roberts Up, Sobel
X, Sobel XY , Sobel Y, Second Diff X, Second Diff XY y
Second Diff Y]
Este grupo de preprocesos permite marcar los cambios de intensidad en la
imagen, encuentra el gradiente de la imagen y marca los puntos máximos. Se
utiliza para ver contornos.

4.2.20. Project H y Project V

Realiza la suma de todos los pixels de la línea o columna. Existe la posibilidad

de ecualizar la ventana en la misma herramienta.

_____________________www.infaimon.com____________________ 20
 visión artificial
_______________________________________________________________
4.2.21. Random

Crea una imagen dentro del ROI sin tener en cuentra lo que hay previamente y
de forma aleatoria le da valor a los pixels.

4.2.22. Rotate
Este preproceso rotará la imagen un ángulo predefinido.

4.2.23. Sharpen

Esta herramienta incrementa el enfoque de la imagen y a la vez crea ruido

aleatorio en la misma.

4.2.24. Skeleton
Para poder utilizar este preproceso es imprescindible realizar primero un
threshold para binarizar la imagen. Esta herramienta erosiona los puntos
periféricos del blob hasta encontrar la línea media del blob y deja un esqueleto
del mismo.

_____________________www.infaimon.com____________________ 21
 visión artificial
_______________________________________________________________

4.2.25. Smooth
Suaviza la imagen para eliminar ruido, pero a la vez atenúa los cambios de
nivel de gris.

4.2.26. Preprocesos de Binarización. [Threshold,

Threshold Adaptive, Threshold Band, Threshold Down,
Threshold Down Masked, Threshold Local Adaptive,
Threshold Up y Threshold Up Masked]
Este grupo de preprocesos convierten la imagen en binaria, es decir en 0 y 1,
utilizando diferentes métodos de corte. De la misma forma, alguno de estos
filtros modifica únicamente parte de la imagen procesada.

4.3. Algoritmos
Sherlock realiza una separación de algoritmos dependiendo de la herramienta
empleada.

Los algorítmos de línea son: Detect Edges, First edges, Inside Caliper, Max
Edge, Min Max, Outside Caliper.

Los Algoritmos de área disponibles son: Average, Barcode 1D, Barcode Data
Matrix, Barcode QR, Centroid, Connectivity, Count, Extrema, HVLine, Image
Extract, Inspect, MinMax, OCR Plus, Search-Correlation, Search-Geometric,
Search-LineBased, Statistics, Average(Channel), Color Correction Coefs, Color
Map, Color Presence Meter, Count(channel), Count(color), MinMax(channel),
Spot Meter-Block y Spot Meter-Statistical.

4.4. Herramientas Monocromo

A continuación citamos algunos de los algoritmos más comunes relacionados
con la herramienta a la cual están asignados.

Herramientas de Línea:
A continuación se describen los procesos más utilizados en ROI de Líneas.

_____________________www.infaimon.com____________________ 22
 visión artificial
_______________________________________________________________
4.4.1. INSIDE CALIPER y OUTSIDE CALIPER

Este algoritmo se emplea para encontrar un cambio de intensidad del nivel de

gris en la línea. Funciona buscando dos cambios, desde dentro hacia fuera o
desde fuera hacia dentro. Se utiliza para localizar los dos lados de un objeto,
utilizando uno u otro, dependiendo de donde sea más fácil encontrar ruido o
cambios no deseados de la imagen, fuera o dentro.

De esta forma podemos realizar mediciones lineales dentro de nuestra imagen.

La diferencia entre Inside Caliper y

Outside Caliper es desde donde
empieza a buscar el gradiente. En
Inside Caliper lo buscará del centro de
la línea hacia fuera, mientras que en
Outside Caliper lo buscará de los
extremos hacia dentro.

Cada Proceso dispone de unas

propiedades a las que podemos
acceder haciendo clic sobre el botón
“parameters”.

En el cuadro de diálogo Parameters,

están incluidas las variables de cada
parámetro:

• Edge Type.
• Edge sharpness threshold.
• Edge strenght treshold.
• Smooth filter size.

Los resultados obtenidos de este

Proceso son:

• Edge Ponint: las coordenadas

de los dos puntos.
• Gradiente de los dos puntos.
• Sharpress: la derivada del
gradiente.

_____________________www.infaimon.com____________________ 23
 visión artificial
_______________________________________________________________
4.4.2. EDGE COUNT
El algoritmo Edge Count cuenta el número de saltos de oscuro a claro o de
claro a oscuro, en una línea.

Para parametrizar la herramienta

se deben tener en cuenta los
siguientes parámetros:

• Número máximo de
transiciones a contar.
• Nivel mínimo de la
transición.
• Número de píxels entre
transiciones.
• Dirección de detección.

Los resultados obtenidos del

Edge Count son:

• El número de transi-
ciones de oscuro a claro.
• El número de transi-
ciones de claro a oscuro.
• Las coordenadas de
transiciones.

Herramientas Multilínea:
A continuación se describen los procesos más utilizados en ROI de tipo
Multilíneas.

_____________________www.infaimon.com____________________ 24
 visión artificial
_______________________________________________________________

4.4.3 FIRST EDGE:

El algoritmo first Edge detecta el primer punto de transición bajo unas

condiciones determinadas.

Para parametrizar la herramienta

se deben tener en cuenta estos
parámetros:

• Nivel mínimo de la
transición.
• Dirección de la transición.

Los resultados que se obtienen

son:
• un vector con la posición
de todas las transiciones
en cada linea.
• Un vector con el nivel de
gris de cada transición.
• Un vector con las coor-
denadas de cada punto.

Herramientas Área:

Quizás la ROI más usada de todas en Sherlock es la de Área debido a sus

múltiples aplicaciones y posibilidades.

A continuación se detallan los Procesos más usados en la ROI de área.

_____________________www.infaimon.com____________________ 25
 visión artificial
_______________________________________________________________

4.4.4. Conectivity
Conectivity es un proceso que siempre debe ir precedido por un preproceso de
threshold (binarización). Con Connectivity se obtiene información de los blobs
que aparecen en la imagen, segmentados previamente por un proceso de
binarización.

Los posibles parámetros a

modificar son Constraints, Results y
Display:

• Constraints permite para-

metrizar los valores que se
desean obtener, por ejemplo
limitando el tamaño máximo
o mínimo de área de los
blobs, o si se desea
encontrar blobs blancos o
negros.
• Result permite discriminar el
número de blobs obtenidos
dependiendo de las condi-
ciones de la imagen.
• Display modifica los
resultados que se obtienen
en la pantalla.

_____________________www.infaimon.com____________________ 26
 visión artificial
_______________________________________________________________

En el cuadro de diálogo de la
izquierda se aprecian las distintas
medidas que se pueden obtener
con Conectivity.

Entre las distintas medidas

obtenidas se destacan las
siguientes::

• Count- determina el número

de blobs encontrados
• Centroid[ ]- Muestra las coor-
denadas del centro de los
blobs.
• Área[ ]- Muestra las áreas de
los blobs.
• Width[ ]- muestra el ancho
de los blobs.
• Height[ ]- muestra la longitud
de los blobs.

4.4.5. Barcode
En Sherlock 7 los Barcode se han unido en tres: Barcode 1D, Barcode 2D y
Barcode QR.

BARCODE 1D

La herramienta de Barcode 1D
es realmente fácil de usar, de
modo automático, indica el tipo
de código y lo lee.

Si se necesita ahorrar tiempo de

proceso o el código está en muy
malas condiciones, entonces se
debe parametrizar manualmente
la herramienta, y de esta forma
se obtienen mejores resultados.

Barcote 1D lee los siguientes

códigos:
Code39, Code 128, UPC-A,
UPC-E, EAN-8, EAN-13, ITF,
BC-412 y Codebar.

_____________________www.infaimon.com____________________ 27
 visión artificial
_______________________________________________________________

BARCODE 2D (Datamatrix Code).

Barcote 2D DataMatrix es
una herramienta que se
utiliza habitualmente en
modo automático.

En el caso de que se
quisiera ganar tiempo, se
debería ajustar manual-
mente los parámetros
para reducir el tiempo de
proceso.

BARCODE QR

Este código de barras se utiliza de forma específica en mercados verticales.

4.4.6. SEARCH (Pattern Matching)

El algoritmo de search es uno de los más típicos a realizar en visión artificial.
Consiste en buscar una determinada estructura en la imagen. Por ejemplo,
verificar que una parte (resistencia, etiqueta, blister,…) está en el lugar
adecuado, o determinar el desplazamiento de una estructura con respecto al
lugar donde debería estar.

En Sherlock, todos los algoritmos de SEARCH se utilizan de la misma forma:

Paso 1. Entrenar la estructura a buscar, en una imagen donde se encuentre la

estructura perfectamente definida.
Paso 2. Definir los parámetros y el área de búsqueda.
Paso 3. Buscar la estructura en una nueva imagen y, si se encuentra, devolver
su posición y la calidad del resultado.

Dependiendo del tipo de estructuras se encontrarán mejor con un tipo u otro de

algoritmo de búsqueda. Algunas estructuras tienen bordes muy marcados, pero

_____________________www.infaimon.com____________________ 28
 visión artificial
_______________________________________________________________
rangos de intensidad de píxels muy bajos. Otras no tienen los límites
marcados, pero una gran variedad de rangos de intensidad en sus píxels. En
algunas imágenes nos encontramos con ambas características. Por este
motivo, existen distintos algoritmos de búsqueda.

4.4.6.1. Búsqueda – Correlación (Search – Correlation)

El algoritmo Search – Correlation crea un mapa con todas las intensidades de

los píxels de la ROI, y después utiliza la correlación de escalas de gris para
encontrar la mayor coincidencia en el área buscada. Cuanto mayor sea la
variación de intensidades en la estructura, más robusta será la búsqueda.

Cuando se selecciona el algoritmo de la

lista de algoritmos de la ROI, la
estructura se entrena automáticamente.

La misma ROI se expande para

definir el área de búsqueda.

Cuando se ejecuta la búsqueda, se

retorna la localización, la calidad
del resultado de la estructura
encontrada y el número de objetos
encontrados con las mismas
características.

_____________________www.infaimon.com____________________ 29
 visión artificial
_______________________________________________________________

En este caso se ha encontrado una

coincidencia inferior a la perfecta y
por tanto la calidad del resultado es
menor.

Se puede controlar como ejecutar el algoritmo modificando los parámetros del

cuadro de diálogo Parameters. Para ver con detalle las diferentes opciones de
los parámetros, ver la ayuda en línea para la herramienta Search –
Correlation.

La búsqueda por correlación funciona

correctamente incluso cuando la imagen
donde buscar está desenfocada o tiene
cambios de iluminación. (Sin embargo
en un ambiente estable estos cambios no
deberían ocurrir)

Search – Correlation no funciona con estructuras que tengan una

rotación superior a unos pocos grados con respecto a la posición entrenada,
excepto si versiones rotadas de la estructura han sido generadas mediante el
parámetro use rotation poniéndolo en True.

Search - Correlation puede, opcionalmente, encontrar múltiples instancias de

una estructura, y devolver matrices conteniendo las posiciones y niveles de
calidad de las instancias clasificadas por su mejor o peor coincidencia.

_____________________www.infaimon.com____________________ 30
 visión artificial
_______________________________________________________________

4.4.6.2. Búsqueda – Geométrica (Search – Geometric)

El algoritmo de Search – Geometric aprende los bordes más prominentes de

una ROI, después encuentra la mayor coincidencia en el área de búsqueda.

Los bordes más prominentes en la

ROI se han identificado y
entrenado. Estos bordes son la
estructura, (pixels verdes) que no
pertenecen a los bordes se ignoran.
Los bordes a considerar se pueden
eliminar don’t care points)
manualmente.

Se puede controlar la
ejecución del algoritmo
modificando los pará-
metros de su cuadro de
diálogo Parameters.
Aquí el valor por
defecto 20 de min
contour length se ha
cambiado por 100, y se
ha entrenado la
estructura (execution
mode = train). Los
contornos que tienen
menos de 20 píxels de
longitud se han
eliminado.

La misma ROI se expande para definir el

área de búsqueda.

Cuando se ejecuta la búsqueda, se

devuelve la localización y nivel de calidad
del resultado.

_____________________www.infaimon.com____________________ 31
 visión artificial
_______________________________________________________________
Search – Geometric puede localizar un
patrón con rotación. El ángulo de rotación
se devuelve en radianes.

Para ver más detalles acerca de los parámetros de este algoritmo, ver la ayuda
en línea de Search – Geometric.

Search - Geometric puede opcionalmente encontrar múltiples instancias de

una estructura, y devolver las posiciones y niveles de calidad de las estructuras
clasificadas por su mayor o menor coincidencia.

4.4.6.3. Búsqueda – Línea (Search – Line)

El algoritmo Search – Line aprende las líneas rectas más intensas en una ROI,
y después encuentra la mayor coincidencia en el área de búsqueda.

El valor por defecto 20

del parámetro min
contour length se ha
cambiado por 100, y la
estructura se ha
entrenado de nuevo
(mode = train).

El parámetro view hace

que el patrón se
visualice (pattern) o no
se visualice (none).

Visualizar los bordes puede ayudar para ajustar los parámetros correctamente
cuando se está entrenando un patrón. Sin embargo, mostrar los bordes

_____________________www.infaimon.com____________________ 32
 visión artificial
_______________________________________________________________
requiere un cierto tiempo, por tanto es conveniente poner view en none
cuando se realice la búsqueda

Search – Line puede localizar un

patrón con cualquier rotación. El
ángulo de rotación se devuelve
en radianes.

Search – Line encuentra solo la mayor coincidencia con la estructura

entrenada, por tanto no se puede utilizar en patrones múltiples.

Para conocer más detalles acerca de los parámetros de este algoritmo puede
consultar la ayuda en línea Search – Line.

Después de entrenar una estructura con cualquiera de los algoritmos

de búsqueda, debe recordar expandir la ROI para definir el área de búsqueda.

Si se modifica algún parámetro en mode de entrenamiento train,

después de modificar el parámetro, asegúrese de cambiar el mode a run antes
de realizar la búsqueda. Sino, cada ejecución del algoritmo será un
entrenamiento y no una búsqueda.

4.4.7. OCR Gray Scale

De la misma forma que las herramientas de búsqueda de patrones, otra de las
más típicas funciones que se realizan en visión artificial son los OCR
(Reconocimiento Óptico de Caracteres) en la imagen.

Todos los algoritmos de OCR se utilizan de la misma manera:

Paso 1. Entrenar la estructura a leer en una imagen donde se encuentre la

estructura de caracteres óptimamente definidos.
Paso 2. Definir los parámetros y el área de búsqueda.

_____________________www.infaimon.com____________________ 33
 visión artificial
_______________________________________________________________
Paso 3. Leer la estructura en una nueva imagen, y si se encuentra, devolver
su posición, la calidad del resultado y el string asociado.

Dependiendo del tipo de estructuras, se encontrarán mejor con un tipo u otro

de algoritmo de Lectura. En Sherlock encontraremos dos herramienta OCR,
el OCR Plus y el OCR Gray Scale.

Algunas estructuras tienen bordes muy marcados, pero rangos de intensidad

de píxel muy bajos. Otras no tienen los límites marcados, pero una gran
variedad de rangos de intensidad en sus píxels y algunas tienen ambas
características. En cada caso utilizaremos el algoritmo OCR óptimo para la
lectura.

OCR Gray Scale

El algoritmo OCR Gray Scale crea un mapa con todas las intensidades de los
píxels de la ROI, después utiliza la correlación de escalas de gris para
encontrar la mayor coincidencia en el área buscada. Cuanto mayor sea la
variación de intensidades en la estructura, más robusta será la búsqueda.

Los algoritmos de OCR

funcionan de forma muy
parecida a los de Search, se les
crea una base de datos con
diferentes figuras aprendidas
relacionadas con un carácter.

En esta imagen podemos

apreciar el interface donde
creamos el patrón y le damos
una etiqueta (label). Tan solo
debemos marcar la zona que
queremos aprender, asignar una
letra y darle a Train ROI. Esta
pantalla también nos servirá
para realizar un test y ver lo que
lee la herramienta una vez
realizado el aprendizaje.

_____________________www.infaimon.com____________________ 34
 visión artificial
_______________________________________________________________
Todos los elementos mostrados
en la pantalla anterior, quedan
registrados en esta base de
datos, donde se puede apreciar
la imagen enseñada las
características y el carácter
asignado.
Estas bases de datos se pueden
guardar para ser importardas en
posteriores OCR. Además se
puede modificar el carácter
asignado mediante el botón
Rename y eliminar una o todos
los elementos. También se
puede habilitar o deshabilitar los
elementos con la opción Toggle
Enable.

Cuando se ejecuta el OCR, se

retorna la localización y la
calidad del resultado de la
estructura encontrada.

En Settings se encuentran
todas las características que se
pueden modificar .

Lo primero que encontramos es

el número máximo de
caracteres que leerá.

El Acceptance level es el
porcentaje mínimo de similitud
para encontrar un patrón.

El time Out es el tiempo

máximo de espera antes de dar
un mensaje de error, si se pone
valor 0, se deshabilitará.

_____________________www.infaimon.com____________________ 35
 visión artificial
_______________________________________________________________

Los resultados que nos devuelve el OCR

Gray Scale son el array de strings que
esta leyendo, el procentage de similitud
respecto al que tiene aprendidos y la
suma de todo los caracteres en un solo
String.

OCR Gray Scale está pensado para leer caracteres con un contraste
elevado y que las diferencias entre el patrón y la imagen no sean muy
elevados. Para sistemas como podría ser la micropercusion u otras técnicas
que puedan deformar mucho los caracteres existen la herraienta OCR Plus con
una configuración más avanzada que permite leer OCR’s más complejos. La
herramienta OCR Plus tiene un coste adicional al de software Sherlock.

_____________________www.infaimon.com____________________ 36
 visión artificial
_______________________________________________________________
4.5. Herramientas de Color
Sherlock dispone de una serie de herramientas de color. La utilización de una u
otra herramienta dependerá de las necesidades del usuario.

4.5.1. Color Presence Meter

Color Presence Meter es la herramienta que determina que color de una base
de datos previamente configurada aparece con más frecuencia en una ROI.
Está disponible en cualquier ROI de tipo Área.

Para añadir colores a la base de datos de algoritmos deben seguirse los

siguientes pasos:

1. Seleccionar un color en la ROI.

2. Hacer clic en el botón del algoritmo Parameters para mostrar el cuadro
de diálogo Parameters.
3. Introducir el nombre del color.
4. Posicionar el run mode en Train. El promedio de color en la ROI se
calcula y se añade a la base de datos cuando se selecciona este modo;
no es necesario hacer clic en el botón Apply.
5. Volver a run mode y posicionarlo en Run. No olvide este paso!!!!
6. Hacer clic en el botón OK.
7. Mover la ROI hasta otro color, y volver al paso 2.

4, 5

Color Presence Meter color training

_____________________www.infaimon.com____________________ 37
 visión artificial
_______________________________________________________________
Cuando se ejecuta la investigación con este algoritmo, los píxels de la ROI se
comparan uno a uno con los colores de la base de datos. Si un píxel coincide
con uno de los colores, el contador del color se incrementa. Después de
analizar todos los píxels de la ROI, se devuelve la información del color con el
mayor índice de coincidencia.

En el siguiente ejemplo se entrenan los colores pink, blue, cyan, orange y

mustard .

Cuando se ejecuta el algoritmo de la

investigación, el reading coverage
contiene el porcentaje de todos los píxels
de la ROI que coinciden con el color con
mayor porcentaje. En este ejemplo, el 8%
de los píxels de la ROI RectA son blue.

Una ROI como esta tendrá como

resultado un mayor coverage (26%).

_____________________www.infaimon.com____________________ 38
 visión artificial
_______________________________________________________________
Recuerde que Color Presence Meter devuelve
información sólo acerca del color con la mayor
presencia. No se devuelve información de los
puntos de color naranja. Si los puntos naranjas no
estuvieran presentes en la ROI el valor de
mustard seguiría siendo de un 12%.

El parámetro used bits determina cuantos bits de color por plano se utilizan
durante el entrenamiento y el análisis. Este parámetro debe ser el mismo
durante el entrenamiento (run mode = Train) y durante el análisis (run mode =
Run). Una vez seleccionado, no se puede cambiar durante el entrenamiento o
el análisis.

El parámetro max recognition distance determina cuanto puede variar el color

de un píxel analizado con respecto a un color de la base de datos. Cuanto
mayor es el número, mayor rango de variación tenemos para determinar el
color del píxel.

Una base de datos de colores creados con este algoritmo puede importarse en
otra ROI ejecutando Color Presence Meter en la misma investigación. No se
puede importar a otra investigación. Aquí una ROI importa la base de datos
creada por RectA.

Una base de datos importada de una ROI en otra es compartida, no

copiada. Un cambio en la base de datos en una ROI afectará cualquier otra
ROI que utilice esa base de datos.

_____________________www.infaimon.com____________________ 39
 visión artificial
_______________________________________________________________

4.5.2. Spot Meters

Un spot meter es un clasificador que compara el promedio de color de los
píxels en una ROI, con los colores de una base de datos. Diferentes spot
meters utilizan diferentes modelos matemáticos del espacio, alrededor de un
único punto en el espacio de tres dimensiones RGB, para definir una base de
datos de distribución de color o “rango de inclusión”. Estos diferentes modos
afectan a la velocidad, precisión y tamaño de la base de datos.

Spot Meter - Block

Spot Meter – Block sacrifica cierta precisión en el modelado de color para

conseguir mayor velocidad de ejecución.

Para añadir colores a la base de datos de algoritmos debe seguir los siguientes
pasos:

1. Seleccionar un color con la ROI.

2. Hacer clic en el botón del algoritmo Parameters para mostrar el cuadro
de diálogo de parámetros.
3. Hacer clic en el botón Teach/Run para poner el algoritmo en modo
aprendizaje.
4. Escribir el nombre del color.
5. Hacer clic en el botón Add New. El nombre del color se añade a la lista,
pero el color aún no ha sido aprendido.
6. Hacer clic en el botón Teach. Se calcula el color promedio de la ROI y
se asigna el nombre del color.
7. Hacer clic en el botón OK.
8. Mover la ROI hasta otro color y repetir el proceso desde el paso 2.

_____________________www.infaimon.com____________________ 40
 visión artificial
_______________________________________________________________

4
6

Spot Meter – Block color training

El mismo nombre de color puede entrenarse con diferentes colores. Cada

instancia del mismo color se asigna a Point # (1 of 3, 2 of 3, etc.). Los colores
aprendidos con el mismo nombre pueden ser de diferentes tonalidades del
mismo color, no colores que sean muy diferentes unos de otros.

Run Distance se utiliza para controlar la distribución de color alrededor de un

punto. Cuanto mayor es la distancia, mayor es la distribución de color. Esta
distancia se aplica de igual forma a todos los colores en la base de datos; no se
pueden definir diferentes distancias para diferentes colores.

Configuration Bit resolution determina cuantos bits por píxels, en los planos
de color se utilizan, cuando se hace el aprendizaje o cuando se analizan los
píxels. Cuanto menor sea el número, menos precisa será la coincidencia de
colores. La resolución debe ser ajustada (haciendo clic en el botón Change)
antes de entrenar cualquier color. Una vez ajustado no se puede cambiar
durante el periodo de entrenamiento o análisis.

_____________________www.infaimon.com____________________ 41
 visión artificial
_______________________________________________________________

Spot Meter – Statistical

Spot Meter – Statistical Esta herramienta sacrifica velocidad de ejecución en

favor de una mayor precisión en el modelo de color.

Para añadir colores a la base de datos de algoritmos debe seguir los siguientes
pasos:

1. Seleccionar un color con la ROI.

2. Hacer clic en el botón del algoritmo Parameters para mostrar el cuadro
de diálogo de parámetros.
3. Hacer clic en el botón Teach/Run para poner el algoritmo en modo
aprendizaje.
4. Escribir el nombre del color.
5. Hacer clic en el botón Add New. El nombre de color se añade a la lista,
pero el color aún no ha sido aprendido.
6. Hacer clic en el botón Teach. Se calcula el color promedio de la ROI y
se asigna el nombre del color.
7. Hacer clic en el botón OK.
8. Mover la ROI hasta otro color y repetir el proceso desde el paso 2.

_____________________www.infaimon.com____________________ 42
 visión artificial
_______________________________________________________________

4
6

3
Spot Meter – Statistical color training

Si se entra el mismo nombre para colores distintos, el color resultante es un

punto en el cubo de espacios RGB de color, que está en algún lugar entre los
colores entrenados. Si los colores seleccionados están muy distantes en el
cubo de color, el color resultante puede que no sea ninguno de los colores
entrenados. Por esta razón, este algoritmo se debe utilizar entrenando áreas
uniformes cercanas del mismo color.

La opción Run Threshold controla la distribución de colores alrededor de un

punto. Cuanto mayor es el threshold, mayor es la distribución de colores. Este
threshold se aplica solo al color actual seleccionado, pudiendo definir diferentes
thresholds para diferentes colores.

Configuration Used channels and Bit resolution determina cuantos bits por
píxels, en los planos de color, se utilizan cuando se hace el aprendizaje o
cuando se analizan los píxels. Cuanto menor sea el número, menos precisa
será la coincidencia de colores. La resolución se debe ajustar (haciendo clic en
el botón Change) antes de entrenar cualquier color. Seleccionando los canales
utilizados, se puede entrenar y analizar los tres, solo dos o solo uno de los
planos de color. Una vez ajustados estos parámetros no se pueden cambiar
durante el periodo de entrenamiento o análisis.

_____________________www.infaimon.com____________________ 43
 visión artificial
_______________________________________________________________
Una base de datos de color creada por este algoritmo, puede exportarse a un
archivo con extensión .ucc, que a su vez se puede importar a otra ROI
ejecutando Spot Meter – Statistical, tanto en la misma investigación como en
investigaciones distintas.

Funcionalidades comunes de Spot Meter

• Selección de ROI dentro de la ventana imagen

Cuando se entrena un color para una base de datos, se puede seleccionar un

subgrupo de píxels en la ROI de la ventana de imagen, para calcular su valor
promedio.

En la imagen adjunta, sólo los píxels del rectángulo verde se utilizarán para
calcular el valor promedio para el color brown (marrón) en la base de datos de
color.

• Modificación de la distribución del color

Se puede marcar el check box Show, para ver qué píxels, en el cuadro de
dialogo de la ventana de visualización, son reconocidos como los colores
seleccionados en la lista de colores. Se puede cambiar los parámetros
Distance (Block) o Threshold (Statistical) para incrementar o reducir la
distribución de colores reconocidos. Esta funcionalidad sirve para debuggar y
solo está disponible en modo Run, y solamente desde el cuadro de diálogo,
durante la creación de la base de datos. No es accesible durante la ejecución
de la investigación.

_____________________www.infaimon.com____________________ 44
 visión artificial
_______________________________________________________________
En las siguientes imágenes, el área verde muestra qué píxels están incluidos
en la distribución del color red (rojo). En la imagen de la derecha, el Spot
Meter – Block’s Distance se ha incrementado, y por tanto se incluyen un
mayor número de píxels.

• Grabación de base de datos de color

Una base de datos de color creada por uno de estos algoritmos, puede
exportarse a un archivo, que a su vez puede importarse a otras ROIs. Esto es
posible ejecutando el mismo algoritmo, en la misma investigación o en otras
investigaciones. Para Spot Meter – Block, la extensión del archivo es .lst;
para Spot Meter – Statistical, la extensión del archivo es .ucc.

Exportar un Spot Meter – Block color database

_____________________www.infaimon.com____________________ 45
 visión artificial
_______________________________________________________________

Importar un Spot Meter – Block color database

Una base de datos exportada desde una ROI ejecutando Spot Meter –
Block o Spot Meter – Statistical, e importada a otra ROI ejecutando el mismo
algoritmo no se comparte, incluso en la misma investigación, será una base de
datos distinta. Un cambio en la base de datos para una ROI no afectará la base
de datos para otra.

Las bases de datos de color creadas por Spot Meter – Block y Spot
Meter – Statistical son incompatibles, porque utilizan diferentes modelos
matemáticos. Una base de datos de color exportada desde Spot Meter –
Block no se puede importar en Spot Meter – Statistical, y viceversa.

4.5.3. Color mapping

A pesar de darnos información necesaria en muchas aplicaciones, para
muchos otros procesos de visión artificial, el color es irrelevante, y solo
introduce un nivel de complejidad que puede hacer incomoda la ejecución del
control de los procesos.

Considere una aplicación donde se deban encontrar los centros de las

siguientes estructuras: rojas, verdes y azules, de esta imagen, y un color cada
vez.

_____________________www.infaimon.com____________________ 46
 visión artificial
_______________________________________________________________

Para separar las estructuras en tres clases, se deberá definir tres thresholds
dimensionales en el espacio de color RGB para separar rojo de verde y de
azul, y después aplicar un algoritmo de análisis blob que funcione en color. El
centro de las estructuras no depende del color de estas, por tanto será más
fácil convertir cada color a un valor de nivel de gris, y después aplicar el
preproceso de segmentación (thresholding) y el algoritmo de análisis de blob
binario.

El algoritmo Color Map convierte un color en un valor de nivel de gris, entre 0 y

255.

Para añadir colores a la base de datos debe seguir la siguiente secuencia:

1. Seleccionar un color de la ROI.

2. Hacer clic en el botón del algoritmo Parameters para mostrar el cuadro
de diálogo Parameters.
3. Introducir el nombre del color.
4. Activar run mode en modo Train. Se calculará el promedio de color de
la ROI y se añadirá a la base de datos, tan pronto como se seleccione
este modo. No es necesario hacer clic en el botón Apply.
5. Activar run mode en modo Run. No olvide este paso !!!!!!!
6. Hacer clic en el botón OK .
7. Mover la ROI a otro color, y volver a empezar desde el punto 2.

_____________________www.infaimon.com____________________ 47
 visión artificial
_______________________________________________________________

4, 5

Color Map training

Al añadir cada color en la base de datos, se asigna el siguiente número en la

secuencia {0, 1, 2, 3,…, 255}. La asignación de número es automática, no se
puede cambiar el orden de asignación de los números, ni seleccionar un
número en concreto para un color.

El siguiente paso consiste en crear una imagen de niveles de gris de la imagen

de color, basada en el mapa de color. Se puede hacer el mapa de cualquier
sección rectangular o de toda la imagen.

Para hacer el mapa de la

imagen entera, hacer clic
en el botón Fit to image,
en la pestaña Position,
del cuadro de diálogo
Parameters, correspon-
diente a la ROI de la
imagen origen. Es
recomendable activar el
checkbox Lock position.

Crear una imagen destino, y añadirle una ROI.

_____________________www.infaimon.com____________________ 48
 visión artificial
_______________________________________________________________
En el cuadro de
diálogo Options
de la imagen
destino, seleccione
Reading como
imagen origen, y el
mapa de color
creado por el
algoritmo Color
Map como el
reading.

Los colores en la imagen origen – verde, rojo y azul – se han representado con
los valores 0, 1 y 2, respectivamente. Para analizar solo las estructuras verdes,
debe seleccionar el preprocesador Threshold Band, poner los parámetros
threshold low y threshold high en el mismo valor (en este caso 0), in value a
0, y out value a 255. Esto segmentará todos los píxels desde threshold low a
threshold high. Para realizar el algoritmo que cuente elementos, se ha de
seleccionar el proceso Connectivity – Binary. (Por defecto, el algoritmo
Connectivity – Binary procesará los pixels negros [0].)

_____________________www.infaimon.com____________________ 49
 visión artificial
_______________________________________________________________
En esta imagen se utiliza una
ROI de tipo rectángulo en la
imagen destino y se ha confi-
gurado como Fit to image.

Cuando se ejecuta la
investigación, la imagen de
niveles de gris es segmentada,
de forma que solo los píxels
verdes (Valor 0) son
representados en negro. El
algoritmo Connectivity –
Binary devuelve el centro y el
recuadro envolvente de las
estructuras verdes.

Para analizar las estructuras rojas, poner los parámetros de Threshold Band,
threshold low y threshold high a 1 y 1; para azul, 2 y 2. Para analizar las
estructuras verdes y rojas a la vez, poner threshold low y threshold high a 0
y 1.

En el cuadro de diálogo Parameters, color id determina qué valores de niveles

de gris son pasados del mapa de colores a la imagen destino. Un valor de 255
significa que se pasan todos los valores. Si color id se pone en cualquier otro
valor, solo se pasa este nivel de gris. Por ejemplo, si color id se pone a 1, solo
se representan los píxels de valor1 – rojo, en este ejemplo – y se pasarán a
la imagen destino.

Max distance controla la distribución del color en el cubo de color 3D. Cuanto
mayor es max distance, mayor es el rango de colores que coincidirán en la
base de datos.

_____________________www.infaimon.com____________________ 50
 visión artificial
_______________________________________________________________
5.-Calibración
Cualquier software de visión industrial, por defecto, realiza las medidas en
píxels. Sherlock dispone de un sistema que permte calibrar la imagen para
pasar los datos de pixels a un rango espacial.

Para medir la anchura de

la pantalla de la PDA, se
crean dos ROIs de tipo
línea que ejecutan el
algoritmo First Edge, y
los puntos de los bordes
encontrados se pasan
como entradas para la
instrucción
Geometric:PtToPtDist.

La pantalla tiene una

anchura de 311.58 píxel.

Para medir en unidades reales, se debe calibrar la ventana de imagen para

correlacionar los píxel de la ventana de imagen con la posición en coordenadas

_____________________www.infaimon.com____________________ 51
 visión artificial
_______________________________________________________________
reales. Una ventana de imagen puede calibrarse mediante software o de forma
interactiva.

5.1 Calibración Software, método 1: puntos

Para realizar esta calibración, debe seguir los siguientes pasos:

1. Identificar cuatro puntos en una ventana de imagen donde se conozcan

las distancias reales entre ellos.
2. Crear una transformación de correlación entre los puntos de la ventana
de imagen a localizaciones del mundo real.
3. Crear un objeto de calibración y rellenarla con la transformación.
4. Aplicar el objeto de calibración a una ventana de imagen.

Paso 1. Identificar cuatro puntos

En esta ventana de imagen se utilizan 4 ROIs tipo radial (spoke)

(spokeUpperLeft, spokeUpperRight, spokeLowerLeft, spokeLowerRight), y
se ejecuta el algoritmo First Edge, en cuatro círculos de la imagen de
calibración. En esta imagen, la distancia entre los centros de los círculos es de
1 pulgada.

_____________________www.infaimon.com____________________ 52
 visión artificial
_______________________________________________________________

La matriz de puntos de
los bordes encontrados
en cada ROI radial se
pasa como entrada a la
instrucción
Geometric:PtsToBestCi
rcle.

Uno de los readings de

esta instrucción es el
punto center del círculo
calculado.

Paso 2. Correlacionar los cuatro puntos

Los cuatro readings center devueltos por

las cuatro instrucciones PtsToBestCircle
se pasan como entradas a la instrucción
IO:Calibration:Calibrate Using Points.
Las posiciones reales del centro de los
puntos se entran como entradas en el
mismo orden que los centros de los
puntos.
Upper-left circle center: (0.00, 0.00)
Upper-right circle center : (4.00, 0.00)
Lower-left circle center: (0.00, 3.00)
Lower-right circle center: (4.00. 3.00)

El centro del circulo superior derecho está

a cuatro unidades a la derecha del centro
del circulo superior izquierdo. Las unidades
de medida no se introducen.

Las “posiciones reales” de los centros de

los puntos son relativos. El centro del
círculo superior izquierdo podrían haber
sido entradas como (2.125, 7.500), y los
otros centros de los círculos ajustados
apropiadamente.

_____________________www.infaimon.com____________________ 53
 visión artificial
_______________________________________________________________
Paso 3. Crear y rellenar un objeto calibrado

Se puede entrar una calibración vacía, en cada ventana de imagen, en el

diálogo Options y en la pestaña Calibration.

Clic en el botón
Add para crear un
objeto de
calibración vacío

Al mismo tiempo, en la instrucción

Calibrate Using Points, haga doble
clic en la entrada HDL <Empty> para
mostrar los handles de los objetos
calibrados. Seleccione un objeto
(CalibrationA) para guardar la
transformada de calibración.

Como la subrutina aún no ha sido ejecutada, la transformación aún no ha sido

creada, y el objeto calibración está vacío todavía. Para crear la transformación
y llenar el objeto de calibración, ejecute la subrutina pulsando la tecla F11.

Paso 4. Aplicar el objeto calibración

Los objetos calibración, se aplican a ventanas de imagen individualmente. En la

ventana de imagen deberá ir al cuadro de diálogo Options, y a la pestaña
Calibration, y seleccionar el objeto calibración de la lista desplegable.

De este modo se permiten utilizar distinas calibraciones dentro de una misma

investigación Sherlock.

_____________________www.infaimon.com____________________ 54
 visión artificial
_______________________________________________________________

En este caso, cuando se hacen medidas punto a punto, en la ventana de

imagen calibrada, las distancias se medirán en unidades reales. La pantalla de
la PDA mide 2,59 pulgadas de anchura.

5.2. Calibración Software, método 2 : valores de

transformación
Para realizar este tipo de calibración, deberá seguir los siguientes pasos:

1. Determinar el origen y factores de escala de la imagen.

2. Crear una transformación utilizando el origen y factor de escala del paso
1.
3. Crear un objeto calibración y rellenarlo con la transformación.
4. Aplicar el objeto calibración a la ventana de imagen.

_____________________www.infaimon.com____________________ 55
 visión artificial
_______________________________________________________________
Este método requiere que se conozcan o se puedan calcular las relaciones
entre las distancias horizontales y verticales de la ventana de imagen con
respecto a las distancias en unidades reales; estas se suministran como
factores de escala a la instrucción IO:Calibration:Calibrate Using
Transformation Values.

En esta subrutina de Calibration, el

factor de escala horizontal se calcula
dividiendo, la anchura en unidades
reales del campo de visión de la
cámara, 3.3125 pulgadas, entre la
resolución horizontal de la cámara
648 píxels (factor de magnificación).
Un cálculo similar se realiza para el
factor de escala vertical (2.5 pulgadas
dividido entre 492 píxels). En la
subrutina no hay ventana de imagen,
ya que se proveen explícitamente, los
valores de la transformación.

Los dos factores de escala se pasan

como entradas a la instrucción de
Calibrate Using Transformation
Values. El origen de coordenadas
(0,0), se sitúa en la esquina superior
izquierda de la imagen; no se aplica
rotación.

_____________________www.infaimon.com____________________ 56
 visión artificial
_______________________________________________________________
Una vez ejecutada la subrutina de calibración Calibration, pulsando la tecla
F11, las medidas de distancia punto a punto hechas en otra ventana de imagen
donde se aplica la calibración CalibarationA, tendrán como resultado unidades
calibradas.

_____________________www.infaimon.com____________________ 57
 visión artificial
_______________________________________________________________
Calibración Manual

Los métodos de calibración descritos pueden

realizarse también de forma manual, haciendo
clic en Direct calibration (valores de
transformación), o Point calibration (puntos) en
el cuadro de diálogo Options, en la pestaña
Calibration de la ventana de imagen.

El hecho de calibrar una ventana de imagen depende del tipo de análisis

que se deba realizar sobre ella. Por ejemplo, si una ventana de imagen
contiene solo una ROI tipo rectángulo, donde se leerá un código de barras, las
dimensiones reales del código de barras, probablemente no tengan ninguna
importancia. Sin embargo, el proceso de calibración es absolutamente
necesario en las aplicaciones de metrología o de detección de defectos.

No todas las ventanas de imagen deben tener la misma calibración

aplicadas sobre ellas. En un sistema multicámara, las ventanas de imagen
adquiridas por diferentes cámaras, probablemente necesitarán diferentes
calibraciones.

Las medidas de áreas, como el reading área[] devuelto por el

algoritmo Connectivity – Binary, siempre devuelven píxels.

_____________________www.infaimon.com____________________ 58
 visión artificial
_______________________________________________________________
6. Landmarks y Alineación
Una aplicación típica de visión artificial requiere el análisis de las mismas
estructuras en una serie de imágenes. Debido a la naturaleza de los equipos de
control del movimiento y de adquisición de imagen, o del propio objeto a
analizar en si mismo, las estructuras a analizar, raramente se encuentran en el
mismo sitio en cada imagen. Dado que una ROI, simplemente analiza los píxels
presentes, no hay forma de que conozca donde están los píxels correctos, un
desplazamiento o una rotación de los píxels a analizar pueden dar como
resultado un falso rechazo.

Para esta problemática se aplica la utilidad Landmark que consiste en un

reposocionamiento de las herramientas en respuesta a herramientas fijas
previamente procesadas.

En la imagen siguiente se ha definido una ROI rectangular, para leer un código

de barras en un libro, con el algoritmo Barcode 1D.

_____________________www.infaimon.com____________________ 59
 visión artificial
_______________________________________________________________
Si el libro se desplaza de captura en captura, el código de barras puede que no
se encuentre dentro de la ROI, y por tanto no podrá ser leído.

Para asegurarse que la ROI analiza los píxels correctos, se puede crear un
esquema de alineación, para mover la ROI, con relación a uno o más puntos,
que pueden encontrarse en cada una de las imágenes a analizar.

Si los píxels a analizar pueden desplazarse solo en dirección horizontal y/o

vertical, un punto es suficiente para conocer la cantidad de desplazamiento.

_____________________www.infaimon.com____________________ 60
 visión artificial
_______________________________________________________________
Si los píxels a analizar pueden sufrir rotación además de desplazamiento, son
necesarios dos puntos para calcular la rotación y el desplazamiento.

El primer paso para crear un esquema de alineación es identificar el punto o

puntos – landmarks – que pueden encontrarse en cada imagen.

En la imagen del libro, el borde izquierdo de la etiqueta del código de barras,

puede encontrarse con una ROI tipo línea, ejecutando el algoritmo First Edge.
Se ha escogido el valor 100 para el parámetro edge strength después de
analizar la magnitud y polaridad del cambio en la intensidad de los píxels en el
borde de la etiqueta, que se puede ver cuando se muestra el Profile de la ROI.

Se crea un esquema de alineación en la página Alignment de una ventana de

imagen en el cuadro de diálogo Options.

_____________________www.infaimon.com____________________ 61
 visión artificial
_______________________________________________________________

Haga clic en el botón Create alignment para crear un esquema de alineación

vacío. Por defecto los esquemas de alineación adoptan los siguientes nombres
alignmentA, alignmentB, etc. En este ejemplo, el esquema de alineación se
ha renombrado como alignLeftEdge.

Todos los readings de punto simple son candidatos como entradas de

esquema de alineación. El punto encontrado por el algoritmo First Edge se ha
arrastrado desde la ventana Point readings a alignLeftEdge, y ahora es un
landmark.

Un esquema de alineación por sí mismo no hace nada más que determinar el

desplazamiento del landmarks con respecto a su posición original. Se debe
aplicar a una ROI para que ésta se mueva y analice los píxels correctos.

Los esquemas de alineación se aplican a ROIs individuales. Para aplicar un

esquema de alineación a una ROI, abrir su cuadro de diálogo Edit y hacer clic
en la pestaña Properties. La lista desplegable de Alignment muestra todos
los esquemas de alineación en la investigación.

_____________________www.infaimon.com____________________ 62
 visión artificial
_______________________________________________________________

En el caso de que el libro se desplace en horizontal, el algoritmo First Edge de

la ROI de línea, encuentra el punto en el borde derecho de la etiqueta de
código de barras y calcula su desplazamiento con respecto a su posición
original. La ROI rectangular ejecuta el algoritmo Barcode 1D, moviéndolo con
relación a este landmark. La línea discontinua amarilla muestra la posición
original de la ROI rectangular.

En el ejemplo del libro, la ROI de línea mide solo los desplazamientos

horizontales. Si el libro se mueve verticalmente, el algoritmo First Edge de la
ROI devolverá las mismas coordenadas, y el esquema de alineación no moverá

_____________________www.infaimon.com____________________ 63
 visión artificial
_______________________________________________________________
la ROI rectangular que realice el algoritmo Barcode 1D. Si el libro se mueve a
mucha distancia en vertical, el código de barras puede salir de la región
ocupada por la ROI rectangular, y el algoritmo fallará.

Una forma útil de crear un landmark que pueda determinar los desplazamientos
horizontal y vertical, (sin rotación), consiste en aplicar una de las utilidades de
Búsqueda (Search), asumiendo que hay un solo patrón en el objeto que se
puede encontrar en cada imagen. En el libro, cada etiqueta tendrá los
caracteres “ISBN” debajo del código de barras, y se puede utilizar como
patrón, y el punto donde se encuentre el patrón puede utilizarse como
landmark.

Si el objeto puede rotar, se necesitará un esquema de alineación con dos

herramientas de Search como landmark. En el libro, “ISBN” y la esquina
superior derecha de la etiqueta, que incluye el último ‘0’ en ‘90000’, se usan
como patrones en dos ROIs rectangulares ejecutando el algoritmo Search –
Line Based. Los readings point de los dos algoritmos se convierten en los
puntos de los landmark añadiéndolos a alignRotate.

A la ROI que ejecuta el algoritmo 1D Barcode se le asigna el esquema de

alineación alignRotate. En este caso si el libro presenta rotación, la ROI del
código de barras rota con relación a los dos landmarks.

_____________________www.infaimon.com____________________ 64
 visión artificial
_______________________________________________________________

Es posible tener diferentes esquemas de alineación aplicadas a

diferentes ROI dentro de la misma ventana de imagen.

En sistemas con múltiples cámaras, cada cámara normalmente requiere

su propio esquema de alineación.

Es una práctica común poner las ROI que siguen a los landmark, para la
alineación, en una ventana de imagen distinta de la que contiene la ROI que
realice el trabajo real de la investigación.

_____________________www.infaimon.com____________________ 65
 visión artificial
_______________________________________________________________
7. GUI
Esta sección describe la Interfaz de usuario de Sherlock 7.

Diseñada para facilitar el uso del programa, esta Interfaz consta de menús,
barras de herramientas, ayuda en línea y ventanas de diálogo.

Para facilitar la asimilación por parte del usuario, todas estas entidades tienen
el mismo sistema de funcionamiento que las ventanas de Windows.

7.1. Interfaz
Sherlock es un Entorno de Desarrollo Integrado (EDI) completo. En él se puede
diseñar, probar, corregir y ejecutar aplicaciones de visión artificial.

Una Investigación (.ivs) en Sherlock está compuesta por:

• Una o más Ventanas de Imagen (Image Windows) donde se muestran
las imágenes.
• Una o más Regiones de Interés (ROIs) a procesar.
• El Programa (Program), la serie de pasos de adquisición y proceso de
imágenes.
• La Ventana de Instrucciones (Instruction), donde se seleccionan los
elementos a añadir al Programa.
• La Ventana de Variables, donde se crean y visualizan las variables del
Programa.
• La Ventana de Visualización (Watch), donde se muestran los datos
obtenidos.
• La ventana de generación de Informes (Reporter), donde se pueden
escribir las salidas de mensajes (definidas por el programador).
• El Monitor, donde se muestra la información en tiempo de ejecución.
• La Ventana Digital IO, donde se muestra el estado de las entradas y
salidas digitales.

_____________________www.infaimon.com____________________ 66
 visión artificial
_______________________________________________________________

Program

ROIs

Watch

A continuación pasamos a detallar las distintas partes del entorno Sherlock.

_____________________www.infaimon.com____________________ 67
 visión artificial
_______________________________________________________________

7.1.1. La Barra de Herramientas

La descripción de los botones de la barra de herramientas es la siguiente:

Abrir una nueva Investigación

Guardar/Guardar Como (La

Investigación actual) Ejecutar la Investigación
una vez /continuamente

Parar/Abortar
Copiar/Pegar Debugging
la Investigación
Elementos del programa

Abrir una Investigación

7.1.2. El menú principal

Seguidamente mostramos la descripción de las entradas del menú principal

Abrir y Cerrar varias ventanas GUI

(Program, Watch, etc.)
Controla el contenido y ejecución de
una an Image Window Controla la Ventana de Imagen

Controla la ejecución de una

aplicación Sherlock

_____________________www.infaimon.com____________________ 68
 visión artificial
_______________________________________________________________
Los botones de menús File, Edit y Run abren y guardan Investigaciones, copian
elementos del Programa y ejecutan la Investigación.

_____________________www.infaimon.com____________________ 69
 visión artificial
_______________________________________________________________

7.2.-Ventana Imagen (Image Window)

Una ventana de imagen contiene la imagen a procesar.

Una investigación tiene como mínimo una ventana de imagen. Puede tener
múltiples, no hay límite en el número de ventanas de imagen. Cada ventana de
imagen puede contener una sola imagen.

Para configurar una imagen hay que hacer doble clic en una ventana de
imagen con el objetivo de mostrar su cuadro de diálogo Options.

En este diálogo aparece la siguiente información:

• El nombre de la
ventana de imagen
(imgB)
• Posibles Fuentes de
imagen:

- Una cámara
- Una segunda ventana.
- Una composición de imá-
genes color de 24-bit
desde planos monocromos
de 8-bit
- Un archivo de imagen
- Una secuencia de ar-
chivos de imágenes, para
simular la captura real-time
de una entrada de cámara.

_____________________www.infaimon.com____________________ 70
 visión artificial
_______________________________________________________________
7.2.1. La barra de herramientas de la ventana de imagen
Mostramos a continuación la descripción de la barra de herramientas.

Zoom decreciente, escala 1:1, zoom creciente

Mostrar el
diálogo Iniciar/Parar captura de cámara para esta
Options ventana de imagen sin procesar

Añadir ROIs

Abrir imagen de un archivo

Guardar imagen en
un archivo
Guardar imagen en un
archivo con gráficos

Para añadir una ventana de imagen nueva, es necesario hacer click en el botón

en la barra de herramientas de programa. A las ventanas de imagen

se les asignarán por defecto los nombres imgA, imgB, imgC, etc.

Se puede renombrar una ventana de imagen en el diálogo Options

También es posible cambiar el nombre de una imagen en el panel de

programa. (Hacer clic-izquierdo sobre el nombre para cambiarlo).

_____________________www.infaimon.com____________________ 71
 visión artificial
_______________________________________________________________

Los nombres de las ventanas de imagen pueden contener espacios y

caracteres imprimibles: Camera #1, Bottle_side_view, Top of canister.

Para borrar una ventana de imagen, haga clic en su botón de cierre o

bien selecciónela en el programa y pulse la tecla suprimir del teclado.

Con estos pasos borrará completamente la ventana de imagen y su contenido.

Cualquier trabajo que haya realizado en la ventana se perderá. (Tenga mucho
cuidado! )

7.3.-ROIs, Algoritmos y Preprocesos

Una ROI (región de interés) define los píxels a procesar. Una ventana de
imagen puede contener tantas ROI como sean necesarias para la resolución de
la aplicación.

Hay dos tipos de ROIs: área y línea (simple y compuesta)

_____________________www.infaimon.com____________________ 72
 visión artificial
_______________________________________________________________
7.3.1. ROIs Área
En las ROI de Área se procesan los píxels interiores del área incluyendo los de
los bordes.

Existen los siguientes tipos de ROIs área:

Rectángulo Anillo Polígono Toroide Área Circular

Las ROIs de Área se utilizan para procesar grupos de píxels de dos

dimensiones.

Ejemplo: Lectura de un código de barras con una ROI rectangular

Ejemplo: Análisis Blob con una ROI anular

Cuando la ROI anular procesa sus píxels, los redistribuye en un

rectángulo, y puede tener cierta distorsión. Los cuadrados rojos que enmarcan
los botones de los ROI polígonos, toroides y círculos, significan que procesan
sus píxels en el lugar, sin remapearlos en un rectángulo, por tanto no ocurre
distorsión.

_____________________www.infaimon.com____________________ 73
 visión artificial
_______________________________________________________________

7.3.2. ROIs Línea

Las ROIs de tipo línea procesan los píxels a lo largo de la línea. Hay dos tipos
de ROIs de línea, Simple y Compuesta.

Simple
Punto Línea Poli-línea Arco Circunferencia

Compuesta
Rastrillo Radial Arco iris Ojo de Buey

Las ROI Circunferencia, Arco iris y Ojos de Buey, procesan los píxels a
lo largo de sus líneas, no dentro o entre ellas.

Para añadir una ROI a una ventana de imagen, debe hacer clic en el botón
ROI’s, en la barra de herramientas de la ventana, y después hacer clic en la
ventana de imagen, para definir la posición y tamaño de la misma. Diferentes
ROIs requieren diferentes números de clic para definir su tamaño y posición.

Punto Un Clic.
Línea Dos clic, uno para cada extremo de la línea.
Poli-línea n clics, uno para cada vértice de la línea y doble clic izquierdo
para completar la línea.
Arco Tres clics, uno para cada límite del arco y uno que define la
curvatura.
Circunferencia Dos clics, uno para el centro y otro que define el radio.
Rastrillo Dos clics, uno para cada esquina del rectángulo que lo define.
Radial Tres clics, uno para situar el centro de la “rueda”, y dos más
(Spoke) para situar el inicio y el fin del radio.
Arco Iris Cuatro clics, uno para cada extremo del arco iris, uno para
definir la curvatura del arco interior o exterior, y uno para
definir la concentricidad del arco interno o externo.
Ojo de Buey Tres clics, uno para posicionar el centro del ojo de buey, uno
para definir el radio del círculo interno o externo y uno para
definir el otro radio interior o exterior.

_____________________www.infaimon.com____________________ 74
 visión artificial
_______________________________________________________________
Rectángulo Dos clics, uno para cada esquina opuesta.
Anillo Cuatro clics, uno para cada extremo de un arco, uno para
definir el arco interno o externo y uno para definir el arco
externo o interno
Polígono n clics, uno para cada vértice del polígono y un doble clic
izquierdo para completar el polígono.
Toroide Tres clics, uno para posicionar el centro del círculo, uno para
definir el radio interno o externo del círculo y uno para definir el
radio externo o interno del círculo.

Se asignan nombres por defecto a las ROIs que indican su tipo y orden de
creación: RectA, TorusA, RectB, RectC, SpokeA, etc. Para renombrar una
ROI, deberá hacer doble clic en ella en la ventana de imagen o hacer clic sobre
la herramienta en el panel de Programa para abrir el dialogo Edit.

Se puede renombrar también la ROI directamente en el panel de programa.

(Para realizar este cambio hacer clic con el botón izquierdo una vez sobre el
nombre, espere, y haga clic izquierdo otra vez).

Para borrar una ROI, selecciónela en la ventana de imagen o en el panel de

programa, y pulse la tecla suprimir del teclado.

_____________________www.infaimon.com____________________ 75
 visión artificial
_______________________________________________________________
7.3.3. Algoritmos
Para analizar los píxels definidos por una ROI, es necesario seleccionar un
algoritmo del cuadro de diálogo Edit de las ROI. Un algoritmo extrae
información de los píxels de una ROI, pero no modifica su contenido.

Las ROI de Área y Línea contienen diferentes grupos de algoritmos:

La mayoría de algoritmos tienen parámetros que se pueden modificar para

controlar el funcionamiento del mismo. Por ejemplo, el algoritmo Count cuenta
el número de píxels de un valor específico. Para seleccionar el valor de los
píxels a contar, haga clic en el botón Parameters y se abrirá el cuadro de
diálogo Parameters de este algoritmo.

Cuando hacemos clic en la ventana de valores de parámetro, podemos

introducir un valor de parámetro directamente (N) o seleccionar una variable
que contiene el valor parámetro (var).

_____________________www.infaimon.com____________________ 76
 visión artificial
_______________________________________________________________

Cada ROI puede ejecutar hasta tres algoritmos distintos. Los algoritmos se
ejecutan de forma secuencial e independiente; la ejecución de un algoritmo no
tiene relación con otro, excepto si se pasan datos de salida de un algoritmo a la
entrada de otro.

El uso más común de la ROI línea es para encontrar los límites (edges). Estos
límites se emplean tanto para la detección de defectos como para la medida.

Encontrar límites (edges) con una ROI de línea

La mayoría de los algoritmos de las ROI de Línea que buscan límites tienen
parámetros para determinar que se interpreta como un límite.

7.3.4 Pre-procesadores (Preprocessors)

En ocasiones es necesario o deseable modificar los píxels de una ROI antes de
analizarla con un algoritmo. Un pre-procesador modifica los píxels en una ROI,
pero no extrae información de ella. Debido a las diferencias en el contenido de
las mismas, las ROI Área y Línea tienen grupos de pre-procesadores similares
pero no idénticos.

_____________________www.infaimon.com____________________ 77
 visión artificial
_______________________________________________________________

La mayoría de pre-procesadores tienen parámetros que se pueden ajustar para

determinar su forma de funcionamiento. Por ejemplo, el pre-procesador
Threshold ajusta cada píxel de una ROI a uno o dos valores, dependiendo si el
valor del píxel está por encima o por debajo del valor límite. Para ajustar el
threshold, valor inferior y valor superior, debe hacer clic en el botón
Parameters para mostrar el cuadro de dialogo Parameters del pre-procesador.

En algunos parámetros, cuando se hace clic en los valores de la ventana

puede escoger entre definirlas manualmente (N)

o bien seleccionar una variable que contiene el valor del parámetro (var).

Cada ROI puede ejecutar hasta siete pre-procesadores distintos. Los pre-
procesadores se ejecutan secuencialmente; las modificaciones de los píxels

_____________________www.infaimon.com____________________ 78
 visión artificial
_______________________________________________________________
realizados por un preprocesador previo afectan al siguiente, por tanto el orden
en algunas ocasiones es crítico.

En la siguiente imagen se puede

observar una ROI rectangular
sin ningún preproceso asignado.

La siguiente imagen muestra

esta misma ROI con un
preproceso Equalize seguido de
el preproceso PrewittXY .
(El preprocesador Equalize
hace una normalización
estadística de los valores de los
píxels de la ROI para maximizar
el rango dinámico.
El preprocesador PrewittXY
realza los límites.

Por el contrario en la siguiente

imagen se puede ver la ROI con
el preproceso PrewittXY
seguido del preproceso
Equalize. Como podemos
apreciar, el resultado es distinto
dependiendo del orden de los
preprocesos realizados.

Nota:
Use el botón Use los botones
para para cambiar el
borrar un orden de ejecución
preproceso. de los preprocesos.

_____________________www.infaimon.com____________________ 79
 visión artificial
_______________________________________________________________
7.3.5 Posicionados de ROIs
Mediante la siguiente ventana es posible ajustar de forma precisa la posición
de una ROI, accediendo por la pestaña Position del cuadro de diálogo Edit.

Mover una de las

ROI definiendo las
coordenadas (ver
la siguiente tabla)

Mover la ROI al
centro de la
Mover la ventana de imagen
ROI en
cualquier Expandir la ROI
dirección para enmarcar la
ventana de imagen

Cambiar el número de líneas en la ROI* Cambiar el ángulo de la ROI

(solo rectángulo y rastrillo)

*opcional para las ROIs de línea múltiples.

En la siguiente tabla mostramos el índice de coordenadas que emplea

Sherlock para el acceso a las ROIs.

_____________________www.infaimon.com____________________ 80
 visión artificial
_______________________________________________________________

Índice Coordenada
0000 0001 0002 0003 Nota

Tipo ROI
Punto(Point) Punto
Línea (Line) Inicio Fin
Circunferencia Centro Punto en
(Circle) circunferencia
Arco (Arc) Inicio Fin Punto en
el arco
Rastrillo (Rake) Arriba Abajo
Izquierda Derecha
Radial (Spoke) Centro Punto de Punto
inicio de una final de
línea una línea
Arco iris (Rainbow) Inicio arco Fin de arco Punto en Punto en 1
arco arco
interior o interior o
exterior exterior
Ojo de Buey Centro Punto en Punto en 2
(Bullseye) circulo interior circulo
o exterior exterior o
interior
Rectángulo Arriba Abajo
izquierda derecha
Anillo (Annulus) Inicio de Fin de arco Punto en Punto en 1
arco arco arco
interior o exterior o
exterior interior
Toroide (Torus) Centro Punto en Punto en 2
circulo interior circulo
o exterior exterior o
interior
Área Circular (Circle Centro Punto en
Area) círculo
Polígono y Poli-línea Uno para cada vértice, incluyendo los puntos de inicio y fin.

Notas:

1. El punto 0002 debe estar en el arco interno y el punto 0003 debe estar en el
arco externo, o viceversa, dependiendo del modo de creación de la ROI.

2. El punto 0001 debe estar en el círculo interno y el punto 0002 debe estar en
el círculo externo, o viceversa, dependiendo del modo de creación de la ROI.

Para evitar que la ROI se mueva accidentalmente, podemos fijar su posición

con el checkbox Lock position.

_____________________www.infaimon.com____________________ 81
 visión artificial
_______________________________________________________________
Es importante reseñar que dentro del menú Edit de la ROIs, el botón Snap
adquiere una nueva imagen en la ventana de imagen, pero no aplica los pre-
procesadores o algoritmos de la ROI.

De la misma forma, el botón Apply ejecuta los pre-procesadores y algoritmos

de la ROI. Esto es una acción de una vez por imagen; debe adquirir una nueva
imagen antes de poder hacer clic en el botón Apply.

Cuando se hace clic en el botón Repeat, el botón Snap adquiere

repetidamente una nueva imagen en la ventana de imagen y ejecuta los pre-
procesos y algoritmos de la ROI. El botón Repeat se cambia al botón Stop.
Para parar, hacer clic en el botón Stop.

7.3.6. Propiedades de las ROI

_____________________www.infaimon.com____________________ 82
 visión artificial
_______________________________________________________________
Se puede extraer información acerca de los píxels en la ROI en la pestaña
Properties del cuadro de diálogo Edit.

Para una ROI de área monocromo, podemos visualizar su histograma haciendo

clic en el botón Histogram.

Esta información no es exportable al programa. Sin embargo, a partir de esta

gráfica se obtiene una idea de la distribución de los valores de los píxels. La
mayoría de los píxels del RectA tienen valores comprendidos entre 200 y 240.

Para una ROI del tipo línea simple en una imagen monocromo (línea, arco,
circunferencia, poli-línea), el botón Histogram se reemplaza por el botón
Profile. Cuando se hace clic en este botón, se muestran las gráficas de la
intensidad de los píxels y de su gradiente (rango de cambio).

_____________________www.infaimon.com____________________ 83
 visión artificial
_______________________________________________________________

Con este gráfico podemos interpretar que desde el píxel 0 hasta el píxel 20, la
intensidad de los píxels es de aproximadamente 200 (la intensidad de los píxels
a lo largo de la LineA esta justo por encima de 200). Sobre el píxel 21 (el borde
oscuro izquierdo), la intensidad cae a 75, después vuelve a subir a 150 (la zona
gris dentro de la cruz). Después vuelve a bajar a 75 en el píxel 57 (el borde
oscuro derecho), y después vuelve a subir aproximadamente a 200 hasta el
final de la línea.

La gráfica del gradiente no muestra el valor absoluto de la intensidad de los

píxels, sino el índice y polaridad del cambio. El primer cambio significativo
ocurre en la transición del fondo gris claro al borde oscuro izquierdo, un
gradiente negativo (claro a oscuro). El siguiente cambio significativo ocurre en
la transición del borde oscuro a la zona gris interior de la cruz, un gradiente
positive (oscuro a claro), y así sucesivamente. Estas gráficas son útiles para
determinar lo marcados que son los bordes para ser localizados por los
algoritmos de detección de bordes.

_____________________www.infaimon.com____________________ 84
 visión artificial
_______________________________________________________________
Para las imágenes de color, el histograma muestra la distribución de los planos
de color rojo, verde y azul de los píxels contenidosen dicha ROI.

En las imágenes color, con el botón Color se muestra la distribución de los

colores de los píxels en un cubo de color 3D, en un espacio RGB.

_____________________www.infaimon.com____________________ 85
 visión artificial
_______________________________________________________________
Tanto para imágenes monocromo como color, el botón Intensity muestra un
mapa de intensidad 3D de los píxels de la ROI.

Se puede rotar el gráfico 3D con el ratón. Estos gráficos pueden ser útiles para
hacer informes aunque esta información no es exportable al programa.

El checkbox Outline permite visualizar o no el contorno de la ROI. El hecho de

hacer visible o no el contorno no afecta ni al proceso lógico ni a la velocidad.

Outline on Outline off

_____________________www.infaimon.com____________________ 86
 visión artificial
_______________________________________________________________

_____________________www.infaimon.com____________________ 87
 visión artificial
_______________________________________________________________
7.4. Programa, Readings y Variables
A medida que se añaden ROIs a una ventana de imagen y se definen
algoritmos y pre-procesos en las ROIs, aparecen nuevas entradas en el panel
Program. Cuando se ejecuta la investigación, los elementos del programa se
ejecutan de forma secuencial y en orden descendente, de arriba abajo. Este
modo de ejecución no cambia a menos que se añadan instrucciones que
cambien este orden.

Ejemplo:

• Cuando se ejecuta la investiga-

ción en modo Continuo, en la
ventana de imagen imgA se
adquiere una imagen.

• En la ROI RectA se ejecuta el

pre-proceso Threshold, después
el pre-proceso Median, y luego el
algoritmo Connectivity

• Por último, se devuelven los

valores desde count a ellipse
roundness[]. Estos valores se
extraen del proceso realizado por
el algoritmo Connectivity.

• La investigación vuelve al inicio y

repite el proceso.

Notas:

• Cada algoritmo retorna como mínimo un valor o “reading”.

• Hay cinco tipos de readings: Número ( N ), Booleano ( B ), Cadena
(String) ( S ) Punto ( P ), y Línea ( L ).
• Los readings pueden ser unitarios ( N ) o vectores o matrices ( N[ ]).
• En el programa anterior, el algoritmo Connectivity devuelve un solo
número count (el número de objetos encontrados por el algoritmo), un
solo punto centroid[0] (la coordenada del centroide del primer objeto),

_____________________www.infaimon.com____________________ 88
 visión artificial
_______________________________________________________________
una matriz de puntos centroid[] (las coordenadas de los centroides de
todos los objetos), una matriz de números area[] (las áreas de todos los
objetos), etc.

Para ver el contenido de un

reading (después de ejecutar
la investigación al menos una
vez), desplace el puntero del
ratón sobre el reading.

Para mayor comodidad, es posible

visualizar los readings en el panel
Watch. Para mostrar un reading,
arrástrelo desde el panel Program.
(Si el panel Watch no está visible
seleccio-ne ViewWatch del menú
principal.) Los valores de los
readings se actualizarán cada vez
que cambien. No se puede ver el
contenido completo de los readings
tipo matriz, en caso de ser
necesaria la visualización de toda la
matriz, se tendrá que crear una
variable con el contenido a
visualizar.

Reorganizar los elementos de un programa

Como se van añadiendo elementos a un programa, es posible que necesite

reorganizar estos elementos durante su construcción. Se pueden mover los
elementos arrastrándolos con el ratón.

_____________________www.infaimon.com____________________ 89
 visión artificial
_______________________________________________________________

Paso 1. Para mover la ROI Paso 2. arrastrelo Paso 3. Suelte el botón

LineA antes de RectA, encima de RectA. del ratón.
selecciónela, pulse el botón
izquierdo del ratón.

Copiar elementos de un programa

Se pueden copiar elementos individualizados dentro de un mismo programa.

Cuando se crea una copia de un elemento, el nuevo elemento adopta las
propiedades del elemento fuente. Se asigna un nuevo nombre, ya que dos
elementos no pueden tener el mismo nombre.

Paso 1. Para hacer

una copia de RectA,
seleccionarlo con el
ratón, hacer clic con Paso 2. Seleccionar el Paso 3. El nuevo elemento
el botón derecho del elemento posterior donde se tomará el nombre RectA_A.
ratón, y seleccionar desea incluir la copia, hacer
Copy del menú clic en el botón derecho del
desplegable. ratón, y seleccionar Paste
(Selected only) .

Después de hacer la copia de un elemento, se puede editar para cambiar su

nombre y funcionalidad. Los cambios que se hacen a un elemento copiado no
afectan al elemento origen y viceversa.

También existe la posibilidad de copiar secciones enteras de un programa.

_____________________www.infaimon.com____________________ 90
 visión artificial
_______________________________________________________________

Paso 1. Para hacer una

Paso 2. Seleccionar el
copia de imgA y todos
elemento posterior donde
sus elementos,
se desea incluir la copia,
seleccionar los elementos
hacer clic en el botón
con el ratón, hacer clic
derecho del ratón, y
con el botón derecho del
seleccionar Paste
ratón, y seleccionar Copy
(Selected only) del menú
del menú desplegable.
desplegable.
Paso 3. Se creará una
nueva ventana de imagen
que contiene una copia de
todos los elementos de la
ventana de imagen origen.

Si ha seleccionado Paste (Selected only), imgA_A Habrá sido creada, pero

no contendrá RectA_A, LineA_A, o RakeA_A.

Los comandos Copy, Paste y Delete están también disponibles en el menú

principal Edit.

_____________________www.infaimon.com____________________ 91
 visión artificial
_______________________________________________________________
7.5. Variables
De la misma forma que en cualquier otro entorno de programación, las
variables en Sherlock, se usan como contenedores temporales de datos. Los
tipos de variables que se pueden crear son del mismo tipo que los de los
algoritmos readings generados: Numérico, Booleano, String, Punto y Línea
(individuales o matrices para todos los tipos).

Para crear una variable, seleccionar

el tipo deseado en el panel de
Variables. (Si el panel de
Variables no está abierto,
seleccionar ViewVariables del
menú principal.) . A las variables se
les asignan nombres y valores Hacer un doble clic izquierdo en una
iniciales por defecto. variable para mostrar su diálogo de
edición. Se pueden renombrar las
variables y asignarles valores iniciales.
Se aconseja que los nombres de las
variables tengan sentido, por ejemplo,
arrObjectAreas en lugar de varB, esto
facilita el seguimiento del programa.

No se pueden modificar directamente los readings, por ejemplo, no puede

borrar elementos de una matriz de números devueltos como readings desde un
algoritmo.

Sin embargo, es posible modificar datos en variables, por tanto, uno de los
usos más comunes de las variables, es como asignación de nuevos valores de
los readings.

_____________________www.infaimon.com____________________ 92
 visión artificial
_______________________________________________________________
Para guardar el valor de
un reading en una
variable, hay que hacer
doble clic en el reading
para mostrar su cuadro de
diálogo de edición. La lista
Store in variable muestra
solo las variables del
mismo tipo que el reading.
(arrObjectAreas y varD
son ambos de tipo N[ ] )

También puede hacer clic

derecho en el reading para
mostrar el menú Connect
value.

Cuando ejecute la investigación, las

variables conectadas a readings se
llenarán con los datos de los readings.
Para ver los componentes de una
variable, se tiene que hacer clic en el
botón izquierdo del mouse sobre su
nombre.

_____________________www.infaimon.com____________________ 93
 visión artificial
_______________________________________________________________

Para borrar una variable, se ha de

seleccionar en el panel de variables y
pulsar la tecla suprimir del teclado.

Nota: Tenga cuidado cuando borre una

variable, ya que puede utilizarse como
valor de entrada en cualquier otra parte
del programa.

_____________________www.infaimon.com____________________ 94
 visión artificial
_______________________________________________________________
7.6. Instrucciones
Las Instrucciones se utilizan para múltiples tareas; manipular los datos, hacer
cálculos, controlar el flujo del programa, leer en los puertos de entrada y
escribir en los puertos de salida, abrir y escribir archivos y realizar operaciones
adcionales de programación.

Para mostrar la lista de instrucciones, seleccione ViewInstructions del menú

principal. Las instrucciones se dividen en grupos funcionales.

Para añadir funciones en el programa, hay que hacer lo siguiente:

Paso 1. Seleccionar una instrucción

del panel Instructions.

Una ventana desplegable muestra la

funcionalidad de las instrucciones,
entradas y salidas.

Paso 2. Arrastrar la instrucción a la

parte superior del programa,
después de donde quiera que
aparezca. (En este ejemplo, la
instrucción MeanArr se desplazó por
encima de RectA. Los pre-procesos
y algoritmos son propiedades de
RectA, no son elementos del
programa en si mismos.)
Los triángulos rojos que apuntan a la
izquierda indican entradas. Los
triángulos verdes que apuntan a la
derecha indican salidas.

_____________________www.infaimon.com____________________ 95
 visión artificial
_______________________________________________________________

Paso 3. Hacer clic con

el botón derecho y
entrar para mostrar su
menú Connect value.
Solo se muestran las
variables y readings del
tipo correcto.
Seleccionar la entrada.

Esta instrucción calcula el

promedio del ancho de los
objetos encontrados por el
algoritmo Connectivity de
RectA. El resultado aparece
como avg.

Paso 4. Para ver la salida,

arrastrar el contenido de la
misma hasta el panel Watch.

Nota: Se puede definir una

entrada arrastrando un
candidato válido desde cualquier
lado al progra-ma. En este
ejemplo width[] ha sido
arrastrado desde
RectA.Connectivity y se ha
situado encima de la entrada.

Para renombrar una instrucción,

hacer clic izquierdo una vez,
espere brevemente, y después
hacer clic izquierdo otra vez.
Escribir el nuevo nombre (No se
pueden renombrar entradas o
salidas).

_____________________www.infaimon.com____________________ 96
 visión artificial
_______________________________________________________________

7.6.1. Instrucciones de flujo del programa

Con las instrucciones que aparecen dentro del
apartado General del Menú Instructions se puede
controlar el flujo del programa. Estas instrucciones
están disponibles también en la barra de
herramientas del panel Program.

Las instrucciones If y If-Else ejecutan condicionalmente otras

instrucciones basadas en la evaluación de una expresión lógica.

Cuando se añade una instrucción If o If-Else y se hace doble clic izquierdo en

ella, se muestra el cuadro de diálogo Edit conditional expression.

Es posible crear una expresión

lógica desde operadores lógicos y
aritméticos, números, readings y
variables.

_____________________www.infaimon.com____________________ 97
 visión artificial
_______________________________________________________________

Si el resultado de la expresión
lógica es cierta, cuando la
instrucción se ejecute, se seguirá la
rama “If” de If-Else. Si el resultado
es falso, se seguirá la rama “Else”.
(Display error message y Display
success message son instancias
de la instrucción IO:Reporter:Print.

(Una instrucción If no tiene una

rama “Else”.)

_____________________www.infaimon.com____________________ 98
 visión artificial
_______________________________________________________________

La instrucción While ejecuta repetidamente, las instrucciones que

contiene, tantas veces como su expresión condicional sea cierta. Es útil, entre
otras cosas, para extraer y analizar valores en una matriz.

La instrucción While utiliza el mismo cuadro

de diálogo de expresión condicional que las
instrucciones If y If-Else.
En este caso, una variable tipo número
intIndex se crea para acceder a elementos
individuales de RectA.Connectvity.area[].
Mientras intIndex es menor que el número
de elementos en la matriz (el contaje de
objetos encontrados), el bucle While ejecuta
las instrucciones internas. (Los índices de la
matriz se inician en cero).
(Tenga en cuenta que [RectA.Connectivity
– Binary.count] no realiza una resta, es el
valor del reading count del algoritmo
RectA’s Connectivity – Binary.)
Initialize intIndex to 0 es una instancia
renombrada de la instrucción Numeric
SetNumeric.
Get Connectivity.area[intIndex] es una
instancia renombrada de la instrucción
Array:Number GetAt. El elemento
Connectivity. area[intIndex] se extrae y
guarda en la variable intArea. Después
de realizarse algún análisis (More
instructions), intIndex se incrementa
con una instancia de la instrucción
Numeric Add. Se alcanza el final del
bucle, (Display message está fuera del
bucle), por tanto el control vuelve a la
parte superior del bucle. Cuando
intIndex es igual a count, se sale del
bucle, y se ejecuta Display message.

Nota: Hay que tener cuidado con los bucles while para evitar bucles infinitos.

Algunas veces es necesario interrumpir el flujo normal del programa,

normalmente cuando ocurre alguna condición aberrante. Para ello, utilizar las

instrucciones Jump y Label .

_____________________www.infaimon.com____________________ 99
 visión artificial
_______________________________________________________________
Una Label es
una instrucción
“haz nada” que
se puede in-
sertar en cual-
quier parte y
renombrarse
como nada.
El cuadro de
diálogo de la
instrucción
Jump muestra
todos los Label.

En este ejemplo dentro del

bucle While, si un elemento
de la matriz
Connectivity.area[] es menor
de 5, se saldrá del bucle
inmediatamente si incrementa
el valor de IntIndex.

La combinación Jump/Label se debe utilizar solo cuando es

absolutamente necesario. Si no se va con cuidado con esta combinación
pueden ocurrir problemas inesperados y de difícil diagnóstico. De hecho, es
siempre posible escribir programas donde no es necesario la combinación
Jump/Label. Los ejemplos anteriores se pueden reescribir sin utilizar la
combinación Jump/Label como muestra la siguiente secuencia:

La expresión lógica While se ha reescrito para ver si intIndex está dentro del
rango de la matriz y si la última área leída es igual o mayor que 5. Si ambas
cláusulas se evalúan como falsas se saldrá del bucle. (intArea se ha
inicializado con un valor alto, para asegurarse que la primera vez que se evalúa
la expresión lógica, la cláusula [intArea]>=5 se evalúa como True.)

_____________________www.infaimon.com____________________100
 visión artificial
_______________________________________________________________

Una instrucción Jump puede saltar a una Label solo si las dos
instrucciones están en la misma subrutina.

Las Labels pueden utilizarse también para introducir comentarios breves en los
programas.

7.6.2. Subrutinas
Para facilitar el seguimiento del programa, a menudo es conveniente o
necesario dividirlo en subrutinas.

Una subrutina se crea cuando se arrastra la instrucción Subroutine del panel

Instruction, o se hace clic en el botón Sub de la barra de

herramientas del panel Program. Esta subrutina vacía que tiene un nombre por
defecto (SubA, SubB, etc.). Se puede y debe renombrar la subrutina haciendo
clic sobre ella, esperando un momento y volviendo a hacer clic.

El código de la rama “If” de la

instrucción If-Else se ha
copiado y pegado desde la
rutina Main a una subrutina
denominada Average width
too low. (Se ve que ha sido
copiada y pegada porque se ha
añadido _A a la instrucción
Display error message).

Volviendo a la rutina Main, las

instrucciones Display error
message y Stop se borran y se
reemplazan con una instrucción

Call . Al hacer doble clic

izquierdo en la instrucción Call,
su diálogo muestra todas las
subrutinas del programa.
Seleccione la subrutina a la que
se desea pasar el control.

_____________________www.infaimon.com____________________101
 visión artificial
_______________________________________________________________
En esta estructura de
programa, cuando ejecute esta
investigación en modo
continuo:

• ImgA adquiere una

imagen.
• RectA ejecuta sus pre-
procesos y algoritmos.
• MeanArrA calcula el
promedio de los valores
en width[].
• Si el promedio es menor
de 10, se llama a la
subrutina Average
width too low; en caso
contrario se ejecuta
Display success
message.
• La investigación vuelve
al principio y repite el
proceso.

La instrucción Return causa la vuelta inmediata desde una rutina a su

llamada desde el programa principal.

Al final de una subrutina, el control se

devuelve automáticamente al lugar
donde se ha hecho la llamada. La
instrucción Return no es necesaria
(pero no sobra).

_____________________www.infaimon.com____________________102
 visión artificial
_______________________________________________________________
Sin embargo, el caso de este ejemplo,
la instrucción Return es necesaria si
no se quiere la prueba de anchura
cuando la de altura falla. (No importa
si ésta es un buena o mala subrutina,
solo es un ejemplo!)

Las subrutinas pueden anidarse tanto como sea necesario – Main puede
llamara a SubA, ésta puede llamar a SubB, que puede llamar a SubC, etc. –
pero para clarificar el programa no es conveniente anidar más de dos o tres
niveles de subrutinas distintas.

Todas las variables creadas por Sherlock son globales. No se puede

crear un variable que exista solo dentro de una subrutina. Dado que los
nombres de elementos son únicos:

La ejecución del programa siempre empieza en la rutina Main. No se

puede renombrar la rutina Main, ni borrarla.

Una instrucción Return en la rutina Main causa una vuelta automática

al inicio del programa.

Las subrutinas pueden llamarse automáticamente como respuestas a un

evento.

Supongamos que se quiere escribir en un archivo el promedio de anchuras en

lugar de ejecutar la instrucción Display success message. Se tendrían que
realizar los siguientes pasos:

Paso 1. Añadir la instrucción

IO:File Open al programa.

_____________________www.infaimon.com____________________103
 visión artificial
_______________________________________________________________
Cada archivo abierto debe
asociarse con un “file handle”. Se
pueden activar hasta 10 handles
(0 – 9). Se debe especificar un
nombre de archivo valido
previamente creado en nuestro
sistema.

Paso 2. Reemplazar la instrucción

Display good width message por
la instrucción IO:File Write.
Paso 3. Seleccionar el mismo “file
handle” con que se ha abierto el
archivo.

Cuando se define una cadena de

caracteres a escribir, el hecho de
que el nombre de la variable esté
entre corchetes [ ] significa que el
valor de la variable es accesible.
No se puede acceder a readings,
solo a variables, así la salida avg
de MeanArrA se guarda en la
variable widthAverage.

Con esta configuración, cuando la

investigación se ejecuta en modo
continuo:

• Se abre el archivo
C:\Test\Width.txt
• ImgA adquiere una imagen
• RectA ejecuta sus
preprocesos y algoritmos
• MeanArrA calcula el promedio
de los valores en width[]
• Si el promedio es menor de 10,
se llama a la subrutina
Average width too low; sinó
el promedio se escribe en el
archivo.
• La investigación vuelve al inicio
y repite el proceso.

Esta configuración es válida, sin embargo, no tiene sentido abrir el fichero cada
vez que se pasa por el inicio del programa. (De hecho el programa funcionará

_____________________www.infaimon.com____________________104
 visión artificial
_______________________________________________________________
correctamente, pero cada ejecución de Open después de la primera generará
un warning en tiempo de ejecución).

Para abrir el archivo una sola

vez, la instrucción Open se
tiene que mover a una nueva
subrutina de la siguiente forma:
Hacer doble clic izquierdo en el
nombre de la subrutina para
mostrar su cuadro de diálogo
de opciones, seleccionar
Execute after loading o
Execute before continuous
investigation.

Si se selecciona Execute
before continuous
investigation, la subrutina se
llama automáticamente cada
vez que se haga clic en el
botón Run continuously de la
barra de herramientas
principal.

Si se selecciona Execute after

loading, la subrutina se llama
automáticamente cuando se
seleccione FileOpen desde
el menú principal y se ejecuta
la investigación.

Como el fichero se abre automá-

ticamente después de cargar la
investigación, la instrucción IO:File
Open en la rutina Main no es
necesaria.

El archivo se cierra automáticamente

cuando se termina la investigación.
(Se puede añadir código para cerrar
explícitamente el archivo con una
instrucción IO:File Close basándose
en algunas condiciones, como el
número de pasadas por el programa,
una condición de error, etc.).

_____________________www.infaimon.com____________________105
 visión artificial
_______________________________________________________________

7.7. Monitor and Reporter

Las ventanas Monitor y Reporter muestran información de la ejecución
del programa.

Ventana Monitor
Muestra información en tiempo de ejecución, tal como mensajes de alerta,
errores y tiempos de proceso. Para ver el Monitor, seleccione ViewMonitor
del menú principal.

A continuación mostramos las funcionalidades de la ventana monitor:

Guardar Seleccionar
Abrir / Cerrar
Limpiar contenido en
reporting Monitor archivo opciones
display visualización Puede seleccionar para ver
solamente la información que
es de su interés.

Observar tiempos de ejecución le puede ayudar a ver las limitaciones en el

proceso realizado.

_____________________www.infaimon.com____________________106
 visión artificial
_______________________________________________________________

Ventana Reporter

Reporter es una ventana de texto donde puede escribir con la instrucción

IO:Reporter Print. Para mostrar el Reporter, seleccione ViewReporter del
menú principal.

Guardar contenido en un
Borrar
Archivo
contenido

En este ejemplo, el área de cada

objeto encontrado por el algoritmo
Connectivity se escribe en el
Reporter dentro del bucle While.
La instrucción IO:Reporter Print
escribe una línea seguida por un
salto de línea.

Cuando se define una cadena de caracteres a escribir, si la variable lleva

corchetes [ ] significa que se imprimirá el valor de la variable. No se puede
imprimir la instrucción readings, solo se pueden imprimir variables.

IO:Reporter Clear borra el panel Reporter.

_____________________www.infaimon.com____________________107
 visión artificial
_______________________________________________________________
7.8. Depuración (Debugging)
Cuando se desarrolla y prueba una investigación, es deseable – necesario en
muchos casos - ir paso a paso en la ejecución del programa, o muy
lentamente, para encontrar la fuente de un posible problema de programación.

Se pueden utilizar distintas opciones del debug de Sherlock, como por ejemplo
breakpoints, modo slow, y otras opciones de ejecución.
Modo ejecución Resaltar
paso a paso instrucciones
ejecutadas

Ejecutar una Ralentizar la

sola ejecución
instrucción

7.8.1. Ejecución en Modo paso a paso

Hacer clic en el botón single-step.

Hacer clic en el botón run once.

Hacer clic repetidamente en el botón single instruction para ejecutar

una línea cada vez.

7.8.2 Ejecución en Modo ralentizado

Hacer clic en el botón slow down.

Hacer clic una vez en el botón run once.

La investigación se ejecuta una vez a velocidad lenta. Es más fácil ver la

actualización de los paneles Watch, Variables, Monitor, y Reporter.

_____________________www.infaimon.com____________________108
 visión artificial
_______________________________________________________________

(En ambos modos, paso a paso y lento, haciendo un clic en el botón run
continuously tiene el mismo efecto que hacer clic en el botón run once; la
investigación se ejecuta una sola vez.)

7.8.3. Modo de Instrucciones Resaltadas

Hacer clic en el botón highlight.

Hacer clic en el botón run once o run continuously.

La investigación se ejecutará a velocidad normal, pero las instrucciones se

resaltarán cuando se ejecuten. (Las instrucciones se resaltan por defecto en
modo paso simple, lento y modo breakpoint.)

7.8.4. Breakpoints
Un breakpoint marca una instrucción en la que la ejecución se para cuando
llega a ella.

Para añadir un
breakpoint, hay que
hacer clic derecho
en la instrucción, y
hacer clic en el
menú desplegable
Toggle Breakpoint.

Se marca el
breakpoint con un
punto rojo.

Cuando se hace clic en el botón Run once o Run continuously, el programa

se ejecuta hasta el primer breakpoint. La investigación se pone
automáticamente en modo paso a paso, y los botones Run once y Run
continuously se desactivan. Para continuar la ejecución hasta el próximo
breakpoint, se tiene que volver a hacer clic en el botón single step. Para
ejecutar una instrucción cada vez, haga clic en el botón single instruction.

Para borrar un breakpoint, es necesario hacer clic otra vez en Toggle

Breakpoint, o hacer clic en Remove all Breakpoints.

Se pueden tener tantos breakpoints en un programa como se desee.

_____________________www.infaimon.com____________________109
 visión artificial
_______________________________________________________________

Para finalizar la ejecución mientras se está en estado debug, es suficiente con

hacer clic en el botón Abort.

_____________________www.infaimon.com____________________110
 visión artificial
_______________________________________________________________
7.9. Imágenes
En Sherlock podemos trabajar de distinta forma con las fuentes de imagen.

Podemos utilizar una imagen capturada previamente y que tengamos

guardada en el disco duro. Para ello deberemos marcar la casilla de File y
buscar la imagen en nuestro ordenador.

Esto nos cargará una imagen sobre la que podremos trabajar con Sherlock sin
ningún tipo de limitación.

Otra posibilidad es
trabajar con una
secuencia de imá-
genes, de forma que
podamos simular el
funcionamiento del
programa de forma
automática.

Para ello deberemos

marcar la casilla
Sequence y loca-
lizar en el ordenador
la secuencia de
condiciones de
imagen requerida.

En el caso de que deseemos capturar imagen directamente desde un hardware

de visión, en primer lugar, dependiendo del hardware, deberemos utilizar un
archivo u otro para configurar la cámara. Una vez tengamos configurada la
cámara con la plataforma adecuada, obtendremos un archivo TXT. En el caso
de los sistemas basados en IFC y un archivo ccf en los sistemas basados en
SAPERA.

_____________________www.infaimon.com____________________111
 visión artificial
_______________________________________________________________
Una vez tengamos estos archivos de configuración ya creados, deberemos ir a
la opción Sherlock/options/adquisition del menú principal y cuando hagamos
clic en acquisition se abrirá la siguiente ventana, y para acceder al hardware
debemos seguir los siguientes pasos:

Paso 1. En primer lugar se

debe habilitar “configure
driver loading” poniendo a
Enabled la plataforma con
la que hemos configurado
las cámaras.

Paso 2. Una vez realizado

este cambio, debemos
especificar dónde se
encuentra el fichero en
Driver configuración.

Con esto ya tendremos

seleccionada la cámara
con la que deseamos
trabajar.

Paso 3. En esta misma

ventana podremos
configurar como deseamos
tener las entradas/salidas
digitales al iniciar el equipo.

Para modificar cualquier

salida tan solo deberemos
cambiar el Output que
deseemos.

Si volvemos al menú options de la imagen, observaremos que además de las

ya mencionadas “camera, file y sequence” existen tres opciones más:

• Img Windows:

Con esta opción podrá seleccionar cualquier imagen previamente creada en

el programa Sherlock, y en el caso que sea de color, trabajar
individualmente con cada canal RGB. De la misma forma, podremos hacer
configuraciones avanzadas como pasarla a Mono, coger solo la intensidad o
trabajar en otro espacio de color como son el YUV32 o el YUBCR32.

• Composed:

_____________________www.infaimon.com____________________112
 visión artificial
_______________________________________________________________
Composed nos permite cambiar los canales tanto de RGB, YUV32 o
YURBCR32 de orden y modificar la imagen. Esto nos puede ser de gran
utilidad con tarjetas no convencionales que gestionen de forma distinta los
canales RGB.

_____________________www.infaimon.com____________________113
 visión artificial
_______________________________________________________________

7.10. Progamación con JavaScript

JavaScript es un lenguaje scripting, desarrollado por Netscape, que permite a
los autores de Web diseñar páginas interactivas. Auque comparte muchas de
las estructuras del lenguaje Java, ha sido desarrollado independientemente.
JavaScrip es más fácil de utilizar que Java, y suficientemente potente para los
requerimientos de nuestros programas. JavaScript es un lenguaje abierto que
puede utilizar cualquiera sin necesidad de comprar una licencia.

En una investigación Sherlock, un módulo de código JavaScript puede

utilizarse para realizar tareas que el código nativo de Sherlock no puede
realizar fácilmente, o que simplemente no puede realizar en absoluto.

Para añadir un modulo JavaScript a un programa, hacer clic en el botón

Create script en la barra de herramientas de Program.

Hacer doble clic en el botón izquierdo en el

nombre del módulo del programa para
visualizar el cuadro de diálogo.

Para renombrar un módulo hacer clic

izquierdo una vez, esperar brevemente y
hacer clic izquierdo de nuevo.

Con este proceso aparecerá la siguiente ventana de configuración.

_____________________www.infaimon.com____________________114
 visión artificial
_______________________________________________________________

La ventana código

Las variables de Sherlock a las que

se tiene acceso en JavaScript.

Los parámetros JavaScript que

puede añadir al código.

El lenguaje JavaScript incluye todas las estructuras típicas de programación:

For, While, Do/While, If, If./Else, Switch. Existen además numerosos objetos
con propiedades y métodos: Math, Number, Vars, System, Sherlock, etc.

Para añadir parámetros a la ventana de código, se puede escribir sobre ella o

arrastrar desde la ventana Predefined Items. Cuando se añade un objeto y se
escribe un punto (.), las propiedades y métodos del objeto se muestran en la
lista desplegable.

Por ejemplo, a las variables de Sherlock se accede desde el objeto Vars. En el

cuadro de diálogo edit que se muestra a continuación, la variable Sherlock
intActiveShift puede accederse como Vars.intActiveShift.

_____________________www.infaimon.com____________________115
 visión artificial
_______________________________________________________________
Si se escribe Vars. (con el punto) en
la ventana, las variables se muestran
en una lista desplegable.
Si arrastra Vars desde la lista
Predefined items a la ventana code,
y después se escribe el punto, se
mostrará la misma lista.
Si arrastra una variable desde la
ventana variable, Vars. Automática-
mente estará pendiente.

Ejemplo:

Este código JavaScript

busca la hora actual (a
partir del objeto Date()), y
determina que turno de
ocho horas está traba-
jando. La variable
Sherlock intActiveShift
adopta el valor 1, 2 o 3, de
acuerdo con el resultado
obtenido.

:
• Un modulo JavaScript solo tiene acceso a variables Sherlock, no a
readings.
• Una investigación Sherlock no puede acceder a variables JavaScript.
• Un modulo JavaScript no puede llamar a una subrutina Sherlock,
tampoco interactuar de otra forma con una investigación (excepto
leyendo y escribiendo variables y llamando a Sherlock.Monitor).
• Archivos abiertos y manipulados por Sherlock con la instrucción IO:File
no pueden accederse simultáneamente con operaciones por el
JavaScript System (FileClose, FileAppend, etc.), y viceversa.

_____________________www.infaimon.com____________________116
 visión artificial
_______________________________________________________________

Para más información acerca de JavaScript, haga clic en Start 

Programs  ipd, a DALSA Coreco group  Sherlock  JavaScript Help.

_____________________www.infaimon.com____________________117
 visión artificial
_______________________________________________________________

8. Controles ActiveX

8.1. Introducción
En muchas de las aplicaciones Sherlock, se crea un interface gráfico mediante
entornos de programación VB, C++, C#. La mayoría de las veces, las GUI de
Sherlock son de VB, C++ o C# con ellas se controlan los procesos de Sherlock,
apagado / encendido, modificar variables / parámetros / valores, mostrar
resultados e imágenes.

En este documento se muestra como crear una GUI para Sherlock 7.

Si ha desarrollado una interfase gráfica para Sherlock 6, le serán muy

familiares la mayoría de consejos y ejemplos que a continuación explicaremos.
En general la arquitectura y la mayoría de los componentes permanecen
inalterados.

La mayoría de llamadas de la antigua API están contempladas en la nueva API.

La mayoría de los ejemplos están hechos para desarrollar una GUI usando
Visual Basic.

8.1.1. Ejemplos
El directorio de ejemplos contiene proyectos con Visual Studio para realizar una
Interface gráfica a medida del usuario. Podremos encontrar también ejemplos
con VB6, VB7 y C#.

Nota: La mayoría de los archivos de los proyectos están en “solo lectura”, para
poder modificarlos, tendremos que modificar este atributo del archivo.

_____________________www.infaimon.com____________________118
 visión artificial
_______________________________________________________________

8.2. Arquitectura GUI de usuario

Una GUI típica de Sherlock 7 estará formada por dos controles:

1. Sherlock Engine – IpeEngCtrl module

2. Sherlock Image control – IpeDspCtrl

IpeEngCtrl es el motor de procesamiento de la interfase de Sherlock,

permitiendo cargar programas, encender o parar la investigación, lectura y
escritura de variables, etc.

IpeDspCtrl es el control que va a permitir visualizar imágenes de Sherlock.

IpeDspCtrl proporciona todas las posibilidades del display como zoom,

desplazarse por la imagen y los eventos creados por el ratón.

IpeDspCtrl

Cystom GUI application (VB/C#/C++ or any language supporting COM/ActiveX)

IpeEngCtrl
Program IpeDspCtrl

IpeDspCtrl

_____________________www.infaimon.com____________________119
 visión artificial
_______________________________________________________________

8.3. Implementación de la GUI

Hay un pequeño número de funciones que son llamadas en cada GUI.

Las funciones que se deben utilizar en todos los GUIs son las siguientes:

• Inicialización de Sherlock.
• Finalización de Sherlock.
• Carga del programa de Sherlock.
• Creación de ventanas de demostración y conexión de ellos a ventanas
de imagen.
• Lectura y escritura de variables.

Paso 1. Cargar la aplicación.

Para cargar la aplicación emplearemos el siguiente código (ejemplo VB.net)

Private Sub CreateSherlockEngine()

Dim IpeEngCtrlType As Type
IpeEngCtrlType = Type.GetTypeFromProgID("IpeEngCtrl.Engine")
objIpeEngCtrl = Activator.CreateInstance(IpeEngCtrlType)
if objIpeEngCtrl.EngInitialize()
End Sub

Paso 2. Finaliza la aplicación.

Para finalizar la aplicación emplearíamos el siguiente código (ejemplo VB.net)

Private Sub HaltSherlockEngine(ByRef objEng As IpeEngCtrlLib.Engine)

objEng.InvModeSet(
IpeEngCtrlLib.I_MODE.I_EXE_MODE_HALT_AFTER_ITERATIO
N)

Dim mode As IpeEngCtrlLib.I_MODE

Do
objEng.InvModeGet(mode)
Application.DoEvents()
Loop While (mode <> IpeEngCtrlLib.I_MODE.I_EXE_MODE_HALT)
End Sub

La llamada a Application.DoEvents() es crucial, porque además de parar a

Sherlock Engine, podemos querer llamar el GUI, y si estas retrollamadas no
son procesadas en el momento adecuado, nos va a llevar a un callejón sin
salida.

_____________________www.infaimon.com____________________120
 visión artificial
_______________________________________________________________

Paso 3. Cargar el programa de Sherlock

Cuando se llama a Sherlock Engine para cargar un nuevo programa, la

aplicación tiene que estar parada (estado de HALT). Si la ruta a un programa
no esta especificada, Sherlock por defecto intentará cargar el programa del
directorio:

<SP7HOME>\Programs.

Para cargar el programa es necesario el siguiente código:

objIpeEngCtrl.InvLoad("Simple0.ivs")

Paso 4. Visualización de la imagen

Para visualizar una imagen es necesario llamar al siguiente código

'connect display
AxIpeDspCtrl1.ConnectEngine(objIpeEngCtrl.GetEngineObj())
AxIpeDspCtrl1.ConnectImgWindow("imgA")

objIpeEngCtrl – es el controlador de Sherlock.

“ImgA” es el nombre de Sherlock Image, la Ventana que existe en el programa
de Sherlock previamente.

Paso 5. Escritura y lectura de variables

Las variables constituyen una parte "de la cola" que une (conecta) las partes
diferentes del sistema. La GUI utiliza variables para recuperar resultados de
tratamiento y ajustar parámetros. Cualquier resultado y parámetros que una
GUI manipule / lea, tienen que estar unidas (conectadas) a variables. Los
resultados y parámetros de tratamiento pueden ser recuperados y ajustados
pero siempre se deben unir a variables previamente definidas.

Para la lectura/escritura de variables se tiene que emplear el siguiente código:

‘reading
objIpeEngCtrl.VarGetDouble("varA", v)

‘setting
objIpeEngCtrl.VarSetDouble("varA", 0.0)

_____________________www.infaimon.com____________________121
 visión artificial
_______________________________________________________________

Con estos pasos realizados tendremos el Sherlock en modo ejecución en una

ventana como muestra la siguiente imagen:

_____________________www.infaimon.com____________________122
 visión artificial
_______________________________________________________________
ADENDUM

Funciones accesibles desde el control GUI.

La siguiente lista muestra la totalidad de las funciones accesibles desde el
interface gráfico:

Public Member Functions

HRESULT GetEngineObj ([out, retval] LONG *pnEngObj)
HRESULT EngInitialize ([out, retval] I_ENG_ERROR *pRet)
HRESULT EngTerminate ([out, retval] I_ENG_ERROR *pRet)
HRESULT InvSave ([in] BSTR bstrFile,[out, retval] I_ENG_ERROR *pRet)
HRESULT InvLoad ([in] BSTR bstrFile,[out, retval] I_ENG_ERROR *pRet)
HRESULT InvModeSet ([in] I_MODE nMode,[out, retval] I_ENG_ERROR
*pRet)
HRESULT InvModeGet ([out] I_MODE *pnMode,[out, retval] I_ENG_ERROR
*pRet)
HRESULT CamCountGet ([out] long *pnVal,[out, retval] I_ENG_ERROR *pRet)
HRESULT CamSizeGet (long nCam,[out] long *pnWidth,[out] long
*pnHeight,[out, retval] I_ENG_ERROR *pRet)
HRESULT CamAcqAbort ([out, retval] I_ENG_ERROR *pRet)
HRESULT DigOutIOCountGet ([out] long *pnVal,[out, retval] I_ENG_ERROR
*pRet)
HRESULT DigOutIOSet (long nChannel, long nVal,[out, retval] I_ENG_ERROR
*pRet)
HRESULT DigOutIOGet (long nChannel,[out] long *pnVal,[out, retval]
I_ENG_ERROR *pRet)
HRESULT DigOutIOPulse (long nChannel, BOOL bHighPulse, long
nPulseWidth,[out, retval] I_ENG_ERROR *pRet)
HRESULT DigOutIOAsyncPulse (long nChannel, BOOL bHighPulse, long
nPulseWidth,[out, retval] I_ENG_ERROR *pRet)
HRESULT DigOutIOScheduleAsyncPulse (long nChannel, BOOL bHighPulse,
long nDelay, long nPulseWidth,[out, retval] I_ENG_ERROR *pRet)
HRESULT DigInIOCountGet ([out] long *pnVal,[out, retval] I_ENG_ERROR
*pRet)
HRESULT DigInIOGet (long nChannel,[out] long *pnVal,[out, retval]
I_ENG_ERROR *pRet)
HRESULT DigInIOWaitForState (long nChannel, BOOL bVal, long
nTimeout,[out] BOOL *bTimeoutDetected,[out, retval]
I_ENG_ERROR *pRet)
HRESULT DigInIOWaitForPulse (long nChannel, BOOL bHighPulse, long
nTimeout,[out] BOOL *bTimeoutDetected,[out, retval]
I_ENG_ERROR *pRet)
HRESULT VarSetDouble ([in] BSTR bstrName,[in] double val,[out, retval]
I_ENG_ERROR *pRet)
HRESULT VarGetDouble ([in] BSTR bstrName,[out] double *pval,[out, retval]
I_ENG_ERROR *pRet)

_____________________www.infaimon.com____________________123
 visión artificial
_______________________________________________________________
HRESULT VarSetBool ([in] BSTR bstrName,[in] VARIANT_BOOL val,[out,
retval] I_ENG_ERROR *pRet)
HRESULT VarGetBool ([in] BSTR bstrName,[out] VARIANT_BOOL *pval,[out,
retval] I_ENG_ERROR *pRet)
HRESULT VarSetString ([in] BSTR bstrName,[in] BSTR val,[out, retval]
I_ENG_ERROR *pRet)
HRESULT VarGetString ([in] BSTR bstrName,[out] BSTR *pval,[out, retval]
I_ENG_ERROR *pRet)
HRESULT VarSetPoint ([in] BSTR bstrName,[in, out]I_POINT *pval,[out, retval]
I_ENG_ERROR *pRet)
HRESULT VarGetPoint ([in] BSTR bstrName,[out] I_POINT *pval,[out, retval]
I_ENG_ERROR *pRet)
HRESULT VarSetLine ([in] BSTR bstrName,[in, out]I_LINE *pval,[out, retval]
I_ENG_ERROR *pRet)
HRESULT VarGetLine ([in] BSTR bstrName,[out] I_LINE *pval,[out, retval]
I_ENG_ERROR *pRet)
HRESULT VarSetDoubleArray ([in] BSTR bstrName,[in]
SAFEARRAY(double)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT VarGetDoubleArray ([in] BSTR bstrName,[out]
SAFEARRAY(double)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT VarSetBoolArray ([in] BSTR bstrName,[in]
SAFEARRAY(VARIANT_BOOL)*paval,[out, retval] I_ENG_ERROR
*pRet)
HRESULT VarGetBoolArray ([in] BSTR bstrName,[out]
SAFEARRAY(VARIANT_BOOL)*paval,[out, retval] I_ENG_ERROR
*pRet)
HRESULT VarSetStringArray ([in] BSTR bstrName,[in]
SAFEARRAY(BSTR)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT VarGetStringArray ([in] BSTR bstrName,[out]
SAFEARRAY(BSTR)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT VarSetPointArray ([in] BSTR bstrName,[in]
SAFEARRAY(I_POINT)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT VarGetPointArray ([in] BSTR bstrName,[out]
SAFEARRAY(I_POINT)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT VarSetLineArray ([in] BSTR bstrName,[in]
SAFEARRAY(I_LINE)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT VarGetLineArray ([in] BSTR bstrName,[out]
SAFEARRAY(I_LINE)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT SoCamSnap ([in] BSTR bstrSo,[out, retval] I_ENG_ERROR *pRet)
HRESULT SoGetSize ([in] BSTR bstrSo,[out] long *pnWidth,[out] long
*pnHeight,[out, retval] I_ENG_ERROR *pRet)
HRESULT SoLiveSet ([in] BSTR bstrSo, BOOL bEnable,[out, retval]
I_ENG_ERROR *pRet)
HRESULT SoCameraSet ([in] BSTR bstrSo, long nCam,[out, retval]
I_ENG_ERROR *pRet)
HRESULT SoCameraGet ([in] BSTR bstrSo,[out] long *pnCam,[out, retval]
I_ENG_ERROR *pRet)
HRESULT SoImageSave ([in] BSTR bstrSo, BSTR bstrFile,[out, retval]
I_ENG_ERROR *pRet)

_____________________www.infaimon.com____________________124
 visión artificial
_______________________________________________________________
HRESULT SoImageLoad ([in] BSTR bstrSo, BSTR bstrFile,[out, retval]
I_ENG_ERROR *pRet)
HRESULT SoSourceGet ([in] BSTR bstrSo,[out] BSTR *pbstrSource,[out,
retval] I_ENG_ERROR *pRet)
HRESULT SoTriggerSet ([in] BSTR bstrSo, BOOL bExtTrig,[out, retval]
I_ENG_ERROR *pRet)
HRESULT SoTriggerGet ([in] BSTR bstrSo,[out] BOOL *pbExtTrig,[out, retval]
I_ENG_ERROR *pRet)
HRESULT SoTimeoutSet ([in] BSTR bstrSo, long nTimeoutMs,[out, retval]
I_ENG_ERROR *pRet)
HRESULT SoTimeoutGet (BSTR bstrSo,[out] long *pnTimeoutMs,[out, retval]
I_ENG_ERROR *pRet)
HRESULT RoiMove ([in] BSTR bstrRoi, long nDx, long nDy,[out, retval]
I_ENG_ERROR *pRet)
HRESULT RoiCoordMove ([in] BSTR bstrRoi, long nCoordIndex, long nDx, long
nDy,[out, retval] I_ENG_ERROR *pRet)
HRESULT RoiCoordGet ([in] BSTR bstrRoi, long nCoordIndex,[out] long
*pnCoord0,[out] long *pnCoord1,[out, retval] I_ENG_ERROR *pRet)
HRESULT RoiCoordSet ([in] BSTR bstrRoi, long nCoordIndex, long nCoord0,
long nCoord1,[out, retval] I_ENG_ERROR *pRet)
HRESULT RoiCoordArrayGet ([in] BSTR bstrRoi,[out]
SAFEARRAY(long)*psanCoordsX,[out]
SAFEARRAY(long)*psanCoordsY,[out, retval] I_ENG_ERROR
*pRet)
HRESULT RoiCoordArraySet ([in] BSTR bstrRoi,[in, out]
SAFEARRAY(long)*psanCoordsX,[in, out]
SAFEARRAY(long)*psanCoordsY,[out, retval] I_ENG_ERROR
*pRet)
HRESULT RoiShowAnnotGet ([in] BSTR bstrRoi,[out] BOOL *pbFlag,[out,
retval] I_ENG_ERROR *pRet)
HRESULT RoiShowAnnotSet ([in] BSTR bstrRoi, BOOL bFlag,[out, retval]
I_ENG_ERROR *pRet)
HRESULT RoiShowOutlineGet ([in] BSTR bstrRoi,[out] BOOL *pbFlag,[out,
retval] I_ENG_ERROR *pRet)
HRESULT RoiShowOutlineSet ([in] BSTR bstrRoi, BOOL bFlag,[out, retval]
I_ENG_ERROR *pRet)
HRESULT RoiSelectedGet ([in] BSTR bstrRoi,[out] BOOL *pbFlag,[out, retval]
I_ENG_ERROR *pRet)
HRESULT RoiSelectedSet ([in] BSTR bstrRoi, BOOL bFlag,[out, retval]
I_ENG_ERROR *pRet)

Create/Terminate engine

Functions
HRESULT IEngine::EngInitialize ([out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::EngTerminate ([out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::GetEngineObj ([out, retval] LONG *pnEngObj)

_____________________www.infaimon.com____________________125
 visión artificial
_______________________________________________________________
Function Documentation
HRESULT IEngine::EngInitialize( [out, retval] I_ENG_ERROR * pRe ) [inherited]
t
EngInitialize Initializes the Engine.

Parameters:
pRet updated with I_OK on success
HRESULT IEngine::EngTerminate( [out, retval] I_ENG_ERROR * pRe ) [inherited]
t
EngTerminate Terminats the Engine

Parameters:
pRet updated with I_OK on success
HRESULT IEngine::GetEngineObj( [out, retval] LONG * pnEngOb ) [inherited]
j
GetEngineObj

This function is only used to connect Display OCX to engine when develiping
custom GUI

Returns:
Internal engine handle

Program management

Functions
HRESULT IEngine::InvLoad ([in] BSTR bstrFile,[out, retval] I_ENG_ERROR
*pRet)
HRESULT IEngine::InvModeGet ([out] I_MODE *pnMode,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::InvModeSet ([in] I_MODE nMode,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::InvSave ([in] BSTR bstrFile,[out, retval] I_ENG_ERROR
*pRet)

Function Documentation
HRESULT IEngine::InvLoad( [in] BSTR bstrFile,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
InvLoad Load program. Program name can contain full path, or just file name.
In the latter case engine will look for specified file in its program directory

Parameters:

_____________________www.infaimon.com____________________126
 visión artificial
_______________________________________________________________
bstrFile file name
pRet updated with I_OK on success See also:
InvModeSet
HRESULT IEngine::InvModeGet( [out] I_MODE * pnMode
,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
InvModeGet Get engine run mode.

Parameters:
pnMode current engine run mode
pRet updated with I_OK on success
See also:
InvModeSet
HRESULT ( [in] I_MODE
nMode,
IEngine::InvModeSet
[out, retval] I_ENG_ERROR * pRet
) [inherited]
InvModeSet Set engine run mode. Following modes are supported:
I_EXE_MODE_ONCE - run program once I_EXE_MODE_CONT - run program
continuously I_EXE_MODE_CALIB- execute subroutines marked with
calibration flag I_EXE_MODE_HALT - abort program immediately at any
instruction I_EXE_MODE_HALT_AFTER_ITERATION - halt running after
finishing current program iteration

When requesting I_EXE_MODE_HALT engine may halt after returning from this
call. It is necessary to loop processing events and wait until InvModeGet returns
I_EXE_MODE_HALT

Parameters:
nMode new run mode
pRet updated with I_OK on success See also:
InvModeGet
HRESULT IEngine::InvSave( [in] BSTR bstrFile,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
InvSave Save program

Parameters:
bstrFile file name
pRet updated with I_OK on success

Camera management

Functions
HRESULT IEngine::CamAcqAbort ([out, retval] I_ENG_ERROR *pRet)

_____________________www.infaimon.com____________________127
 visión artificial
_______________________________________________________________
HRESULT IEngine::CamCountGet ([out] long *pnVal,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::CamSizeGet (long nCam,[out] long *pnWidth,[out] long
*pnHeight,[out, retval] I_ENG_ERROR *pRet)

Function Documentation
HRESULT IEngine::CamAcqAbort( [out, retval] I_ENG_ERROR * pRe ) [inherited]
t
CamAcqAbort Abort camera acquisiton; Usefull to abort pending hardware
trigger acquisiton. All abort all penging acquisitions.

Parameters:
pRet updated with I_OK on success
HRESULT IEngine::CamCountGet( [out] long * pnVal,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
CamCountGet Get number of cameras on the system

Parameters:
pnVal updated with number of cameras
pRet updated with I_OK on success
HRESULT IEngine::CamSizeGet( long nCam,
[out] long * pnWidth,
[out] long * pnHeight,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
CamSizeGet Get given camera sensor size

Parameters:
nCam zero based camera index
pnWidth updated with camera width (pixels)
pnHeight updated with camera height (pixels)
pRet updated with I_OK on success

Digital IO management

Functions
HRESULT IEngine::DigInIOCountGet ([out] long *pnVal,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::DigInIOGet (long nChannel,[out] long *pnVal,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::DigInIOWaitForPulse (long nChannel, BOOL bHighPulse,
long nTimeout,[out] BOOL *bTimeoutDetected,[out, retval]
I_ENG_ERROR *pRet)

_____________________www.infaimon.com____________________128
 visión artificial
_______________________________________________________________
HRESULT IEngine::DigInIOWaitForState (long nChannel, BOOL bVal, long
nTimeout,[out] BOOL *bTimeoutDetected,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::DigOutIOAsyncPulse (long nChannel, BOOL bHighPulse,
long nPulseWidth,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::DigOutIOCountGet ([out] long *pnVal,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::DigOutIOGet (long nChannel,[out] long *pnVal,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::DigOutIOPulse (long nChannel, BOOL bHighPulse, long
nPulseWidth,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::DigOutIOScheduleAsyncPulse (long nChannel, BOOL
bHighPulse, long nDelay, long nPulseWidth,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::DigOutIOSet (long nChannel, long nVal,[out, retval]
I_ENG_ERROR *pRet)

Function Documentation
HRESULT IEngine::DigInIOCountGet( [out] long * pnVal,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
DigInIOCountGet Returns the number of inputs avialable.

Parameters:
pnVal pointer to a variable receiving number of inputs
pRet updated with I_OK on success
HRESULT IEngine::DigInIOGet( long nChannel,
[out] long * pnVal,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
DigInIOGet Returns current state of the given output.

Parameters:
nChannel input index
pnVal pointer to a variable receiving current input state
pRet updated with I_OK on success
HRESULT IEngine::DigInIOWaitForPulse( long nChannel,
BOOL bHighPulse,
long nTimeout,
[out] BOOL * bTimeoutDetected,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
DigInIOWaitForPulse Waits until a given input pulses in a requested way

Parameters:

_____________________www.infaimon.com____________________129
 visión artificial
_______________________________________________________________
nChannel input index
bHighPulse pulse we will wait for (TRUE: high->low, FALSE:
low->high)
nTimeout maximum wait time in miliseconds (-1 for an infinite
wait)
bTimeoutDetected set to TRUE is function timeout was detected
before detecting requested state
pRet updated with I_OK on success
HRESULT IEngine::DigInIOWaitForState( long nChannel,
BOOL bVal,
long nTimeout,
[out] BOOL * bTimeoutDetected,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
DigInIOWaitForState Waits until a given input enters requested state

Parameters:
nChannel input index
bVal input state that we will wait for
nTimeout maximum wait time in miliseconds (-1 for an infinite
wait)
bTimeoutDetected set to TRUE is function timeout was detected
before detecting requested state
pRet updated with I_OK on success
HRESULT IEngine::DigOutIOAsyncPulse( long nChannel,
BOOL bHighPulse,
long nPulseWidth,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
DigOutIOAsyncPulse Pulse a digital output

Note:
This is a asynchronous pulse, Sherlock investigation will continue
execution after starting a pulse. The actual pulse will be performed in
another thread of execution.
See also:
DigOutIOPulse DigOutIOScheduleAsyncPulse
Parameters:
nChannel channel index
bHighPulse pulse polarity (TRUE for high-sleep-low "_-_", false for
low-sleep-high "-_-")
nPulseWidth - pulse width in miliseconds
pRet updated with I_OK on success
HRESULT IEngine::DigOutIOCountGet( [out] long * pnVal,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
DigOutIOCountGet Get number of digital outputs

Parameters:

_____________________www.infaimon.com____________________130
 visión artificial
_______________________________________________________________
pnVal updated with output count
pRet updated with I_OK on success
HRESULT IEngine::DigOutIOGet( long nChannel,
[out] long * pnVal,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
DigOutIOGet Gets digital output

Parameters:
nChannel channel index
pnVal pointer to a variable receiving current output value
pRet updated with I_OK on success
HRESULT IEngine::DigOutIOPulse( long nChannel,
BOOL bHighPulse,
long nPulseWidth,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
DigOutIOPulse Pulse a digital output

Note:
This is a synchronous pulse, Sherlock investigation will pause until the
pulse is finished.
See also:
DigOutIOAsyncPulse
Parameters:
nChannel channel index
bHighPulse pulse polarity (TRUE for high-sleep-low "_-_", false for
low-sleep-high "-_-")
nPulseWidth - pulse width in miliseconds
pRet updated with I_OK on success
HRESULT IEngine::DigOutIOScheduleAsyncPulse( long nChannel,
BOOL bHighPulse,
long nDelay,
long nPulseWidth,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
DigOutIOScheduleAsyncPulse Schedule a digital output pulse

Note:
This function will schedule a synchronous pulse that will start a "nDelay"
number of miliseconds from the moment call is executed. Sherlock
investigation will continue execution after starting a pulse. The actual
pulse will be performed in another thread of execution.
See also:
DigOutIOPulse DigOutIOAsyncPulse
Parameters:

_____________________www.infaimon.com____________________131
 visión artificial
_______________________________________________________________
nChannel channel index
bHighPulse pulse polarity (TRUE for high-sleep-low "_-_", false for
low-sleep-high "-_-")
nDelay - delay before starting the pulse
nPulseWidth - pulse width in miliseconds
pRet updated with I_OK on success
HRESULT IEngine::DigOutIOSet( long nChannel,
long nVal,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
DigOutIOSet Set a digital output

Parameters:
nChannel channel index
nVal new value (0 or 1)
pRet updated with I_OK on success

Variable management

Functions
HRESULT IEngine::VarGetBool ([in] BSTR bstrName,[out] VARIANT_BOOL
*pval,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarGetBoolArray ([in] BSTR bstrName,[out]
SAFEARRAY(VARIANT_BOOL)*paval,[out, retval] I_ENG_ERROR
*pRet)
HRESULT IEngine::VarGetDouble ([in] BSTR bstrName,[out] double *pval,[out,
retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarGetDoubleArray ([in] BSTR bstrName,[out]
SAFEARRAY(double)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarGetLine ([in] BSTR bstrName,[out] I_LINE *pval,[out,
retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarGetLineArray ([in] BSTR bstrName,[out]
SAFEARRAY(I_LINE)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarGetPoint ([in] BSTR bstrName,[out] I_POINT *pval,[out,
retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarGetPointArray ([in] BSTR bstrName,[out]
SAFEARRAY(I_POINT)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarGetString ([in] BSTR bstrName,[out] BSTR *pval,[out,
retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarGetStringArray ([in] BSTR bstrName,[out]
SAFEARRAY(BSTR)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarSetBool ([in] BSTR bstrName,[in] VARIANT_BOOL
val,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarSetBoolArray ([in] BSTR bstrName,[in]
SAFEARRAY(VARIANT_BOOL)*paval,[out, retval] I_ENG_ERROR
*pRet)

_____________________www.infaimon.com____________________132
 visión artificial
_______________________________________________________________
HRESULT IEngine::VarSetDouble ([in] BSTR bstrName,[in] double val,[out,
retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarSetDoubleArray ([in] BSTR bstrName,[in]
SAFEARRAY(double)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarSetLine ([in] BSTR bstrName,[in, out]I_LINE *pval,[out,
retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarSetLineArray ([in] BSTR bstrName,[in]
SAFEARRAY(I_LINE)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarSetPoint ([in] BSTR bstrName,[in, out]I_POINT
*pval,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarSetPointArray ([in] BSTR bstrName,[in]
SAFEARRAY(I_POINT)*paval,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::VarSetString ([in] BSTR bstrName,[in] BSTR val,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::VarSetStringArray ([in] BSTR bstrName,[in]
SAFEARRAY(BSTR)*paval,[out, retval] I_ENG_ERROR *pRet)

Function Documentation
HRESULT IEngine::VarGetBool( [in] BSTR bstrName
,
[out] VARIANT_BOOL * pval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarGetBool

Parameters:
bstrName variable name
pval pointer to a variable receiving value
pRet updated with I_OK on success
HRESULT IEngine::VarGetBoolArray( [in] BSTR bstrName
,
[out] SAFEARRAY(VARIANT_BOOL)* paval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarGetBoolArray

Parameters:
bstrName variable name
paval pointer to a variable array
pRet updated with I_OK on success
HRESULT IEngine::VarGetDouble( [in] BSTR bstrName
,
[out] double * pval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarGetDouble

Parameters:

_____________________www.infaimon.com____________________133
 visión artificial
_______________________________________________________________
bstrName variable name
pval pointer to a variable receiving value
pRet updated with I_OK on success
HRESULT IEngine::VarGetDoubleArray( [in] BSTR bstrName
,
[out] SAFEARRAY(double)* paval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarGetDoubleArray

Parameters:
bstrName variable name
paval pointer to a variable array
pRet updated with I_OK on success
HRESULT IEngine::VarGetLine( [in] BSTR bstrName
,
[out] I_LINE * pval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarGetLine

Parameters:
bstrName variable name
pval pointer to a variable receiving value
pRet updated with I_OK on success
HRESULT IEngine::VarGetLineArray( [in] BSTR bstrName
,
[out] SAFEARRAY(I_LINE)* paval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarGetLineArray

Parameters:
bstrName variable name
paval pointer to a variable array
pRet updated with I_OK on success
HRESULT IEngine::VarGetPoint( [in] BSTR bstrName
,
[out] I_POINT * pval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarGetPoint

Parameters:
bstrName variable name
pval pointer to a variable receiving value
pRet updated with I_OK on success

_____________________www.infaimon.com____________________134
 visión artificial
_______________________________________________________________
HRESULT ( [in] BSTR bstrName
IEngine::VarGetPointArray ,
[out] SAFEARRAY(I_POINT)* paval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarGetPointArray

Parameters:
bstrName variable name
paval pointer to a variable array
pRet updated with I_OK on success
HRESULT IEngine::VarGetString( [in] BSTR bstrName
,
[out] BSTR * pval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarGetString

Parameters:
bstrName variable name
pval pointer to a variable receiving value
pRet updated with I_OK on success
HRESULT ( [in] BSTR bstrName
IEngine::VarGetStringArray ,
[out] SAFEARRAY(BSTR)* paval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarGetStringArray

Parameters:
bstrName variable name
paval pointer to a variable array
pRet updated with I_OK on success
HRESULT IEngine::VarSetBool( [in] BSTR bstrName
,
[in] VARIANT_BOOL val,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarSetBool

Parameters:
bstrName variable name
val new value
pRet updated with I_OK on success

_____________________www.infaimon.com____________________135
 visión artificial
_______________________________________________________________
HRESULT IEngine::VarSetBoolArray( [in] BSTR bstrName
,
[in] SAFEARRAY(VARIANT_BOOL)* paval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarSetBoolArray

Parameters:
bstrName variable name
paval pointer to a variable array
pRet updated with I_OK on success
HRESULT IEngine::VarSetDouble( [in] BSTR bstrName
,
[in] double val,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarSetDouble

Parameters:
bstrName variable name
val new value
pRet updated with I_OK on success
HRESULT ( [in] BSTR bstrName
IEngine::VarSetDoubleArray ,
[in] SAFEARRAY(double)* paval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarSetDoubleArray

Parameters:
bstrName variable name
paval pointer to a variable array
pRet updated with I_OK on success
HRESULT IEngine::VarSetLine( [in] BSTR bstrName
,
[in, out] I_LINE * pval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarSetLine

Parameters:
bstrName variable name
pval pointer to new value
pRet updated with I_OK on success

_____________________www.infaimon.com____________________136
 visión artificial
_______________________________________________________________
HRESULT IEngine::VarSetLineArray( [in] BSTR bstrName
,
[in] SAFEARRAY(I_LINE)* paval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarSetLineArray

Parameters:
bstrName variable name
paval pointer to a variable array
pRet updated with I_OK on success
HRESULT IEngine::VarSetPoint( [in] BSTR bstrName
,
[in, out] I_POINT * pval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarSetDouble

Parameters:
bstrName variable name
pval pointer to new value
pRet updated with I_OK on success
HRESULT IEngine::VarSetPointArray( [in] BSTR bstrName
,
[in] SAFEARRAY(I_POINT)* paval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarSetPointArray

Parameters:
bstrName variable name
paval pointer to a variable array
pRet updated with I_OK on success
HRESULT IEngine::VarSetString( [in] BSTR bstrName
,
[in] BSTR val,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarSetString

Parameters:
bstrName variable name
val new value
pRet updated with I_OK on success

_____________________www.infaimon.com____________________137
 visión artificial
_______________________________________________________________
HRESULT IEngine::VarSetStringArray( [in] BSTR bstrName
,
[in] SAFEARRAY(BSTR)* paval,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
VarSetStringArray

Parameters:
bstrName variable name
paval pointer to a variable array
pRet updated with I_OK on success

Image Window management

Functions
HRESULT IEngine::SoCameraGet ([in] BSTR bstrSo,[out] long *pnCam,[out,
retval] I_ENG_ERROR *pRet)
HRESULT IEngine::SoCameraSet ([in] BSTR bstrSo, long nCam,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::SoCamSnap ([in] BSTR bstrSo,[out, retval] I_ENG_ERROR
*pRet)
HRESULT IEngine::SoGetSize ([in] BSTR bstrSo,[out] long *pnWidth,[out] long
*pnHeight,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::SoImageLoad ([in] BSTR bstrSo, BSTR bstrFile,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::SoImageSave ([in] BSTR bstrSo, BSTR bstrFile,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::SoLiveSet ([in] BSTR bstrSo, BOOL bEnable,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::SoSourceGet ([in] BSTR bstrSo,[out] BSTR
*pbstrSource,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::SoTimeoutGet (BSTR bstrSo,[out] long *pnTimeoutMs,[out,
retval] I_ENG_ERROR *pRet)
HRESULT IEngine::SoTimeoutSet ([in] BSTR bstrSo, long nTimeoutMs,[out,
retval] I_ENG_ERROR *pRet)
HRESULT IEngine::SoTriggerGet ([in] BSTR bstrSo,[out] BOOL *pbExtTrig,[out,
retval] I_ENG_ERROR *pRet)
HRESULT IEngine::SoTriggerSet ([in] BSTR bstrSo, BOOL bExtTrig,[out, retval]
I_ENG_ERROR *pRet)

Function Documentation
HRESULT IEngine::SoCameraGet( [in] BSTR bstrSo,
[out] long * pnCam,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
SoCameraGet

_____________________www.infaimon.com____________________138
 visión artificial
_______________________________________________________________

Parameters:
bstrSo image window name (for example "imgA")
pnCam returns current camera
pRet updated with I_OK on success
HRESULT IEngine::SoCameraSet( [in] BSTR bstrSo,
long nCam,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
SoCameraSet

Parameters:
bstrSo image window name (for example "imgA")
nCam zero based camera index
pRet updated with I_OK on success
HRESULT ( [in] BSTR
bstrSo,
IEngine::SoCamSnap
[out, retval] I_ENG_ERROR * pRet
) [inherited]
SoCamSnap Acquire single image form the image window image source

Parameters:
bstrSo image window name (for example "imgA")
pRet updated with I_OK on success
HRESULT IEngine::SoGetSize( [in] BSTR bstrSo,
[out] long * pnWidth,
[out] long * pnHeight,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
SoGetSize Get image size of a given image window

Parameters:
bstrSo image window name (for example "imgA")
pnWidth pointer to a variable receiving width
pnHeight pointer to a variable receiving height
pRet updated with I_OK on success
HRESULT IEngine::SoImageLoad( [in] BSTR bstrSo,
BSTR bstrFile,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
SoImageLoad Sets image window image source to a given file.

Parameters:
bstrSo image window name (for example "imgA")
bstrFile file name
pRet updated with I_OK on success

_____________________www.infaimon.com____________________139
 visión artificial
_______________________________________________________________
HRESULT IEngine::SoImageSave( [in] BSTR bstrSo,
BSTR bstrFile,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
SoImageSave Saves current image window image to a given file.

Parameters:
bstrSo image window name (for example "imgA")
bstrFile file name
pRet updated with I_OK on success
HRESULT IEngine::SoLiveSet( [in] BSTR bstrSo,
BOOL bEnable,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
SoLiveSet Set/reset given image window into a "Live Acquisition" mode "Live
Acquisition" cases continuous image acquisiton when Sherlock Engine is in
HALT mode.

Parameters:
bstrSo image window name (for example "imgA")
bEnable TRUE to set "Live" mode, FALSE to turn it off
pRet updated with I_OK on success
HRESULT IEngine::SoSourceGet( [in] BSTR bstrSo,
[out] BSTR * pbstrSource,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
SoSourceGet Returns a string describing given image window's image source

Parameters:
bstrSo image window name (for example "imgA")
pbstrSource returned string
pRet updated with I_OK on success
HRESULT IEngine::SoTimeoutGet( BSTR bstrSo,
[out] long * pnTimeoutMs,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
SoTimeoutGet Gets image window hardware acquisition timeout value. If
acquisition takes more this value then time-out error is generated

Parameters:
bstrSo image window name (for example "imgA")
pnTimeoutMs timeout value
pRet updated with I_OK on success
HRESULT ( [in] BSTR
bstrSo,
IEngine::SoTimeoutSet
long nTimeoutMs,
[out, retval] I_ENG_ERROR * pRet
) [inherited]

_____________________www.infaimon.com____________________140
 visión artificial
_______________________________________________________________
SoTimeoutSet Sets image window hardware acquisition timeout value. If
acquisition takes more this value then time-out error is generated

Parameters:
bstrSo image window name (for example "imgA")
nTimeoutMs new timeout value
pRet updated with I_OK on success
HRESULT ( [in] BSTR
bstrSo,
IEngine::SoTriggerGet
[out] BOOL * pbExtTrig,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
SoTriggerGet Gets image window hardware trigger state.

Parameters:
bstrSo image window name (for example "imgA")
pbExtTrig trigger state
pRet updated with I_OK on success
HRESULT IEngine::SoTriggerSet( [in] BSTR bstrSo,
BOOL bExtTrig,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
SoTriggerSet Set image window hardware trigger state. It only affects camera
image sources.

Parameters:
bstrSo image window name (for example "imgA")
bExtTrig trigger state
pRet updated with I_OK on success

Region Of Interest management

Functions
HRESULT IEngine::RoiCoordArrayGet ([in] BSTR bstrRoi,[out]
SAFEARRAY(long)*psanCoordsX,[out]
SAFEARRAY(long)*psanCoordsY,[out, retval] I_ENG_ERROR
*pRet)
HRESULT IEngine::RoiCoordArraySet ([in] BSTR bstrRoi,[in, out]
SAFEARRAY(long)*psanCoordsX,[in, out]
SAFEARRAY(long)*psanCoordsY,[out, retval] I_ENG_ERROR
*pRet)
HRESULT IEngine::RoiCoordGet ([in] BSTR bstrRoi, long nCoordIndex,[out]
long *pnCoord0,[out] long *pnCoord1,[out, retval] I_ENG_ERROR
*pRet)
HRESULT IEngine::RoiCoordMove ([in] BSTR bstrRoi, long nCoordIndex, long
nDx, long nDy,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::RoiCoordSet ([in] BSTR bstrRoi, long nCoordIndex, long

_____________________www.infaimon.com____________________141
 visión artificial
_______________________________________________________________
nCoord0, long nCoord1,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::RoiMove ([in] BSTR bstrRoi, long nDx, long nDy,[out, retval]
I_ENG_ERROR *pRet)
HRESULT IEngine::RoiSelectedGet ([in] BSTR bstrRoi,[out] BOOL
*pbFlag,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::RoiSelectedSet ([in] BSTR bstrRoi, BOOL bFlag,[out,
retval] I_ENG_ERROR *pRet)
HRESULT IEngine::RoiShowAnnotGet ([in] BSTR bstrRoi,[out] BOOL
*pbFlag,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::RoiShowAnnotSet ([in] BSTR bstrRoi, BOOL bFlag,[out,
retval] I_ENG_ERROR *pRet)
HRESULT IEngine::RoiShowOutlineGet ([in] BSTR bstrRoi,[out] BOOL
*pbFlag,[out, retval] I_ENG_ERROR *pRet)
HRESULT IEngine::RoiShowOutlineSet ([in] BSTR bstrRoi, BOOL bFlag,[out,
retval] I_ENG_ERROR *pRet)

Function Documentation
HRESULT IEngine::RoiCoordArrayGet( [in] BSTR bstrRoi,
[out] SAFEARRAY(long)* psanCoordsX,
[out] SAFEARRAY(long)* psanCoordsY,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
RoiCoordArrayGet Gets current value of a ROI coordinates.

Parameters:
bstrRoi ROI name
psanCoordsX x values
psanCoordsY y values
pRet updated with I_OK on success
HRESULT IEngine::RoiCoordArraySet( [in] BSTR bstrRoi,
[in, out] SAFEARRAY(long)* psanCoordsX,
[in, out] SAFEARRAY(long)* psanCoordsY,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
RoiCoordArraySet Sets current values of a ROI coordinates.

Parameters:
bstrRoi ROI name
psanCoordsX x values
psanCoordsY y values
pRet updated with I_OK on success
HRESULT ( [in] BSTR
bstrRoi,
IEngine::RoiCoordGet
nCoordIndex
long
,
[out] long * pnCoord0,
[out] long * pnCoord1,
[out, retval] I_ENG_ERROR * pRet
) [inherited]

_____________________www.infaimon.com____________________142
 visión artificial
_______________________________________________________________
RoiCoordGet Gets current value of a given ROI coordinate.

Parameters:
bstrRoi ROI name
nCoordIndex coordinate index
pnCoord0 x value
pnCoord1 y value
pRet updated with I_OK on success
HRESULT ( [in] BSTR
bstrRoi,
IEngine::RoiCoordMove
nCoordIndex
long
,
long nDx,
long nDy,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
RoiCoordMove Moves given ROI coordinate by give x,y

Parameters:
bstrRoi ROI name
nCoordIndex coordinate index
nDx x shift value
nDy x shift value
pRet updated with I_OK on success
HRESULT IEngine::RoiCoordSet( [in] BSTR bstrRoi,
nCoordIndex
long
,
long nCoord0,
long nCoord1,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
RoiCoordSet Sets current value of a given ROI coordinate.

Parameters:
bstrRoi ROI name
nCoordIndex coordinate index
nCoord0 x value
nCoord1 y value
pRet updated with I_OK on success
HRESULT IEngine::RoiMove( [in] BSTR bstrRoi,
long nDx,
long nDy,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
RoiMove Moves given ROI by give x,y

Parameters:

_____________________www.infaimon.com____________________143
 visión artificial
_______________________________________________________________
bstrRoi ROI name
nDx x shift value
nDy x shift value
pRet updated with I_OK on success
HRESULT IEngine::RoiSelectedGet( [in] BSTR bstrRoi,
[out] BOOL * pbFlag,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
RoiSelectedGet Gets current state to "ROI Selected"

Parameters:
bstrRoi ROI name
pbFlag flag
pRet updated with I_OK on success
HRESULT IEngine::RoiSelectedSet( [in] BSTR bstrRoi,
BOOL bFlag,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
RoiSelectedlineSet Sets current state to "ROI Selected"

Parameters:
bstrRoi ROI name
bFlag flag
pRet updated with I_OK on success
HRESULT IEngine::RoiShowAnnotGet( [in] BSTR bstrRoi,
[out] BOOL * pbFlag,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
RoiShowAnnotGet Gets current state to "Show ROI annotations"

Parameters:
bstrRoi ROI name
pbFlag flag
pRet updated with I_OK on success
HRESULT IEngine::RoiShowAnnotSet( [in] BSTR bstrRoi,
BOOL bFlag,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
RoiShowAnnotSet Sets current state to "Show ROI annotations"

Parameters:
bstrRoi ROI name
bFlag flag
pRet updated with I_OK on success

_____________________www.infaimon.com____________________144
 visión artificial
_______________________________________________________________
HRESULT ( [in] BSTR
bstrRoi,
IEngine::RoiShowOutlineGet
[out] BOOL * pbFlag,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
RoiShowOutlineGet Gets current state to "Show ROI Outline"

Parameters:
bstrRoi ROI name
pbFlag flag
pRet updated with I_OK on success
HRESULT IEngine::RoiShowOutlineSet( [in] BSTR bstrRoi,
BOOL bFlag,
[out, retval] I_ENG_ERROR * pRet
) [inherited]
RoiShowOutlineSet Sets current state to "Show ROI Outline"

Parameters:
bstrRoi ROI name
bFlag flag
pRet updated with I_OK on success

Control Events

Public Member Functions

HRESULT RunCompleted (void)

Member Function Documentation

HRESULT ( void )
IpeEngCtrlLib::_IEngineEvents::RunCompleted
RunCompleted This event is generated every time investigation iteration is
finished. This is good point to retrieve variables etc.

IpeDspCtrl Rererence
All functions

Public Member Functions

void AboutBox ()
void ConnectEngine (LONG pEngine)
LONG ConnectImgWindow (BSTR
bstrImgWndName)

_____________________www.infaimon.com____________________145
 visión artificial
_______________________________________________________________
void DisconnectEngine (void)
void DisconnectImgWindow (void)
LONG GetWindow (void)
DOUBLE GetZoom (void)
LONG LoadImage (BSTR bstrFileName)
void SetFrameType (ULONG dwType)
void SetImage (LONG pImage)
void SetZoom (DOUBLE dZoom)
void ShowToolbar (LONG bShow)
LONG UpdateDisplay (void)

Member Function Documentation

void ( )
IpeDspCtrlLib::_DIpeDspCtrl::AboutBox

void IpeDspCtrlLib::_DIpeDspCtrl::ConnectEngine( LONG pEngin )

e
ConnectEngine Connects SherlockEngine

Parameters:
pEngine pointer to IpeEngCtrl object
LONG ( BSTR bstrImgWndNam )
IpeDspCtrlLib::_DIpeDspCtrl::ConnectImgWindow e
ConnectImgWindow Connects SherlockEngine image window to display

Parameters:
bstrImgWndName name of the image window in currently loaded
program in the IpeEngCtrl object
Returns:
always zero
void ( void )
IpeDspCtrlLib::_DIpeDspCtrl::DisconnectEngine
DisconnectEngine Disconnects currently connected IpeEngCtrl onject
void ( void )
IpeDspCtrlLib::_DIpeDspCtrl::DisconnectImgWindow
DisconnectImgWindow Disconnects currently connected SherlockEngine image
window
LONG IpeDspCtrlLib::_DIpeDspCtrl::GetWindow( void )
GetWindow

Returns:
pointer to an internal CScrollWnd that is used for display.
DOUBLE IpeDspCtrlLib::_DIpeDspCtrl::GetZoom( void )
GetZoom

Returns:
current zoom settings

_____________________www.infaimon.com____________________146
 visión artificial
_______________________________________________________________
LONG ( BSTR bstrFileNam )
IpeDspCtrlLib::_DIpeDspCtrl::LoadImage e
LoadImage Load an image for displaying

Parameters:
bstrFileName image file name
void ( ULONG dwTyp )
IpeDspCtrlLib::_DIpeDspCtrl::SetFrameType e
SetFrameType Controls type of the display control edge type

Note:
Combinations of the following flags can be used For more info look at
MSDN DrawEdge function #define BDR_RAISEDOUTER 0x0001
#define BDR_SUNKENOUTER 0x0002 #define BDR_RAISEDINNER
0x0004 #define BDR_SUNKENINNER 0x0008
Parameters:
dwType flags for control edge painting
void IpeDspCtrlLib::_DIpeDspCtrl::SetImage( LONG pImag )
e
SetImage Sets new display image

Parameters:
pImage pointer to the CIpeImage object
void ( DOUBLE dZoo )
IpeDspCtrlLib::_DIpeDspCtrl::SetZoom m
SetZoom

Note:
Image is not refresed by this call. If you want to see image with new
zoom setting please use UpdateDisplay
Parameters:
dZoom new zoom setting; -1 for stretch-to-fit
void IpeDspCtrlLib::_DIpeDspCtrl::ShowToolbar( LONG bSho )
w
ShowToolbar Shows or hides the display toolbar

Parameters:
bShow 0 or 1
LONG ( void )
IpeDspCtrlLib::_DIpeDspCtrl::UpdateDisplay
UpdateDisplay Repaints the image display

Returns:
always zero

Control Events

_____________________www.infaimon.com____________________147
 visión artificial
_______________________________________________________________

Public Member Functions

void LButtonDblClk (ULONG nFlags, LONG x, LONG y)
void LButtonDown (ULONG nFlags, LONG x, LONG y)
void LButtonUp (ULONG nFlags, LONG x, LONG y)
void MouseMove (ULONG nFlags, LONG x, LONG y)
void OverlayDraw (LONG hDC)
void RButtonDblClk (ULONG nFlags, LONG x, LONG y)
void RButtonDown (ULONG nFlags, LONG x, LONG y)
void RButtonUp (ULONG nFlags, LONG x, LONG y)

Member Function Documentation

Void ( ULONG
nFlags,
IpeDspCtrlLib::_DIpeDspCtrlEvents::LButtonDblClk
LONG x,
LONG y
)
LButtonDblClk

Parameters:
nFlags button flags
x pointer x position in IMAGE coordinates
y pointer y position in IMAGE coordinates
void ( ULONG
nFlags,
IpeDspCtrlLib::_DIpeDspCtrlEvents::LButtonDown
LONG x,
LONG y
)
LButtonDown

Parameters:
nFlags button flags
x pointer x position in IMAGE coordinates
y pointer y position in IMAGE coordinates
void ( ULONG
nFlags,
IpeDspCtrlLib::_DIpeDspCtrlEvents::LButtonUp
LONG x,
LONG y
)
LButtonUp

Parameters:
nFlags button flags
x pointer x position in IMAGE coordinates
y pointer y position in IMAGE coordinates

_____________________www.infaimon.com____________________148
 visión artificial
_______________________________________________________________
void IpeDspCtrlLib::_DIpeDspCtrlEvents::MouseMove( ULONG nFlags,
LONG x,
LONG y
)
MouseMove

Parameters:
nFlags button flags
x pointer x position in IMAGE coordinates
y pointer y position in IMAGE coordinates
void ( LONG hD )
IpeDspCtrlLib::_DIpeDspCtrlEvents::OverlayDraw C
OverlayDraw Callback to allow user to paint overlay

Parameters:
hDC HDC handle to overlay device context; needs to be cases to HDC
void ( ULONG
nFlags,
IpeDspCtrlLib::_DIpeDspCtrlEvents::RButtonDblClk
LONG x,
LONG y
)
RButtonDblClk

Parameters:
nFlags button flags
x pointer x position in IMAGE coordinates
y pointer y position in IMAGE coordinates
void ( ULONG
nFlags,
IpeDspCtrlLib::_DIpeDspCtrlEvents::RButtonDown
LONG x,
LONG y
)
RButtonDown

Parameters:
nFlags button flags
x pointer x position in IMAGE coordinates
y pointer y position in IMAGE coordinates
void ( ULONG
nFlags,
IpeDspCtrlLib::_DIpeDspCtrlEvents::RButtonUp
LONG x,
LONG y
)
RButtonUp

Parameters:

_____________________www.infaimon.com____________________149
 visión artificial
_______________________________________________________________
nFlags button flags
x pointer x position in IMAGE coordinates
y pointer y position in IMAGE coordinates

_____________________www.infaimon.com____________________150