Cámara Industrial IDS, conexión a Python

Introducción:

En este tutorial, aprenderemos cómo conectar y controlar una cámara IDS industrial utilizando el poderoso lenguaje de programación Python. IDS es una reconocida marca de cámaras industriales que ofrece una amplia gama de soluciones de visión artificial para aplicaciones industriales y científicas.

Python es un lenguaje de programación popular y versátil que proporciona una gran cantidad de bibliotecas y herramientas para el procesamiento de imágenes y la adquisición de datos. Combinar Python con una cámara IDS industrial nos permite aprovechar la calidad y confiabilidad de estas cámaras junto con la flexibilidad y facilidad de uso de Python.

A lo largo de este tutorial, exploraremos los pasos necesarios para establecer la conexión con una cámara IDS industrial, configurar parámetros de la cámara, capturar imágenes y almacenarlas. Cubriremos los conceptos básicos para que puedas comenzar a trabajar con tu cámara IDS y Python de manera efectiva.

Si estás interesado en aplicaciones de visión artificial, control de calidad, seguimiento de objetos, inspección automatizada o cualquier otra tarea relacionada, este tutorial te proporcionará los conocimientos esenciales para utilizar una cámara IDS industrial y Python como herramientas poderosas en tus proyectos.

Sin más preámbulos, ¡comencemos a explorar la conexión de una cámara IDS industrial con Python y desbloqueemos todo su potencial para el procesamiento de imágenes y la visión artificial!

Material:

Cámara IDS UI-1640LE-C-HQ
Objetivo HR F1.4/8mm

Código:

El siguiente código es funcional para cualquier cámara IDS uEye , tanto USB como Ethernet. Es importante tener instalados los controladores necesarios, los cuales vienen incluidos con la suite de uEye Cockpit e IDS Camera Manager.

Una vez con los materiales listos y los controladores y software instalado, deberemos instalar la librería que nos proporciona IDS para el trabajo con sus cámaras.

pip install pyueye

Una vez instalada la librería, procederemos a importarla en conjunto con numpy, cv2 y ctypes

from pyueye import ueye
import numpy as np
import cv2
from ctypes import c_int

Al tener solo una cámara conectada a la PC, deberemos utilizar el índice 0 para acceder a ella, por lo tanto, vamos a definir una variable que almacene dicho índice y posteriormente crearemos un handler para la cámara e instanciaremos multiples objetos que nos ayudarán a almacenar datos importantes, tales como información de la cámara, sensor, hasta la imagen misma.

hCam = ueye.HIDS(cameraId)
sInfo = ueye.SENSORINFO()
cInfo = ueye.CAMINFO()
pcImageMemory = ueye.c_mem_p()
MemID = ueye.int()
rectAOI = ueye.IS_RECT()
pitch = ueye.INT()
nBitsPerPixel = ueye.INT(8)
m_nColorMode = ueye.INT()
bytes_per_pixel = int(nBitsPerPixel / 8)

Ahora debemos inicializar la cámara y acceder a su información y a la información de su sensor

nRet = ueye.is_InitCamera(hCam, None)
if nRet != ueye.IS_SUCCESS:
    print("No se ha logrado inicializar la cámara")

nRet = ueye.is_GetCameraInfo(hCam, cInfo)
if nRet != ueye.IS_SUCCESS:
    print("No se ha logrado obtener la información del la cámara")

nRet = ueye.is_GetSensorInfo(hCam, sInfo)
if nRet != ueye.IS_SUCCESS:
    print("No se ha logrado obtener la información del sensor de la cámara")

Configuremos ahora el valor de ganancia por hardware y apliquémosle un boost.

new_gain = 1.0
ret = ueye.is_SetHardwareGain(hCam, int(new_gain * 100), ueye.IS_IGNORE_PARAMETER, ueye.IS_IGNORE_PARAMETER, ueye.IS_IGNORE_PARAMETER)
if ret != ueye.IS_SUCCESS:
    raise Exception("No se ha logrado configurar la ganancia")

ret = ueye.is_SetGainBoost(hCam,1)
if ret != ueye.IS_SUCCESS:
    raise Exception("No se ha logrado configurar la ganancia")

Qué crees, también podemos configurar la saturación, por supuesto, del color.

sat = c_int(80)
ret = ueye.is_SetSaturation(hCam, sat, sat)
if ret != ueye.IS_SUCCESS:
    raise Exception("No se ha logrado configurar la saturación")

Un paso importante es la configuración del modo de visualización de la cámara, en este caso se configurará para que la imagen capturada sea representada por un mapa de bits independiente del dispositivo, esto nos permitirá trabajar con la imagen de una manera mucho más flexible.

nRet = ueye.is_SetDisplayMode(hCam, ueye.IS_SET_DM_DIB)

El siguiente paso es comprobar el modo de color del sensor de la cámara, que en este caso es BAYER para un CMOS a color.

nRet = ueye.is_SetDisplayMode(hCam, ueye.IS_SET_DM_DIB)

if int.from_bytes(sInfo.nColorMode.value, byteorder='big') == ueye.IS_COLORMODE_BAYER:
    ueye.is_GetColorDepth(hCam, nBitsPerPixel, m_nColorMode)
    #calculamos el total de bytes por pixel
    bytes_per_pixel = int(nBitsPerPixel / 8)

Ahora obtendremos el área de interés que se encuentra actualmente configurado en la cámara, esto con el fin de saber las dimensiones finales de la imagen y poder separar la memoria necesaria para su almacenamiento.

nRet = ueye.is_AOI(hCam, ueye.IS_AOI_IMAGE_GET_AOI, rectAOI, ueye.sizeof(rectAOI))
if nRet != ueye.IS_SUCCESS:
    print("No se ha logrado configurar el area de interez")

width = rectAOI.s32Width
height = rectAOI.s32Height

Separamos la memoria y configuramos la cámara para que la utilice.

nRet = ueye.is_AllocImageMem(hCam, width, height, nBitsPerPixel, pcImageMemory, MemID)
if nRet != ueye.IS_SUCCESS:
    print("No se ha logrado separar la memoria")
else:
    nRet = ueye.is_SetImageMem(hCam, pcImageMemory, MemID)
    if nRet != ueye.IS_SUCCESS:
        print("No se ha logrado configurar la cámara para la utilización de la memoria")
    else:
        nRet = ueye.is_SetColorMode(hCam, m_nColorMode)

Es momento de capturar la imagen, para esto utilizaremos is_FreezeVideo y le pasaremos IS_WAIT para que la cámara espere a que se capture el total de la imagen antes de proseguir.

nRet = ueye.is_FreezeVideo(hCam, ueye.IS_WAIT)
if nRet != ueye.IS_SUCCESS:
    print("No se ha logrado capturar la imagen")

Si todo salió bien, en este punto ya podemos obtener información sobre la memoria de imagen que se asignó en la cámara uEye, podremos obtener las dimensiones de la imagen capturada, numeros de bits por pixel y el pitch.

nRet = ueye.is_InquireImageMem(hCam, pcImageMemory,MemID,width, height, nBitsPerPixel, pitch)
if nRet != ueye.IS_SUCCESS:
    print("No se ha podido consultar la memoria de imagen")

Obtenemos los datos de la imagen capturada y los formateamos para que sean compatibles con OpenCV

array = ueye.get_data(pcImageMemory, width, height, nBitsPerPixel, pitch, copy=False)
frame = np.reshape(array,(height.value, width.value, bytes_per_pixel))

Escribimos la imagen en el disco duro de la PC

cv2.imwrite("2.jpg", frame)

Liberamos la memoria de imagen utilizada y cerramos la cámara para liberar sus recursos.

ueye.is_FreeImageMem(hCam, pcImageMemory, MemID)
ueye.is_ExitCamera(hCam)

Conclusión:

Sin duda el proceso de adquisición de imágenes mediante una cámara industrial es mucho más complejo que mediante una webcam ordinaria, pero sin duda que los resultados siempre serán mejores y más aprovechables en la práctica, sobre todo tratándose de entornos industriales con 0 tolerancia a errores. Espero que este tutorial te ayude a implementar este tipo de cámaras en tus proyectos tanto personales como profesionales.

Te recordamos estar atento a nuestros próximos tutoriales y cursos especializados.