Dibujo

Flechas

Programa que muestra flechas superpuestas en la imagen que está capturando la Sentry2.

Después de inicializar la cámara y los módulos de visualización, se generan valores de coordenadas y valores de color aleatorios, y luego se utiliza el método image.draw_arrow para dibujar flechas superpuestas en la pantalla. Los resultados se ven en la pantalla de Sentry2.

# Rutina que muestra cómo dibujar flechas sobre una imagen.

import sensor, lcd, image, time, urandom

sensor.reset()                      # Reiniciar e inicializar Sentry2
sensor.set_pixformat(sensor.RGB565) # Formato de salida de la cámara RGB565 (también puede ser GRAYSCALE)）
sensor.set_framesize(sensor.QVGA)   # Tamaño de salida de la cámara QVGA (320x240)
sensor.skip_frames(time = 2000)     # Saltar fotogramas cada 2000ms
clock = time.clock()                # Crea un objeto reloj para calcular la frecuencia de imagen

lcd.init()                          # Inicialización de la pantalla
lcd.clear(lcd.RED)                  # Borra la pantalla y ponla de color rojo

while(True):
    clock.tick()                    # Actualizar el reloj que calcula la velocidad en fotogramas

    img = sensor.snapshot()         # Obtener una imagen

    # Generar valores aleatorios de coordenadas y valores RGB
    for i in range(10):
        x0 = (urandom.getrandbits(30) % (2*img.width())) - (img.width()//2)
        y0 = (urandom.getrandbits(30) % (2*img.height())) - (img.height()//2)
        x1 = (urandom.getrandbits(30) % (2*img.width())) - (img.width()//2)
        y1 = (urandom.getrandbits(30) % (2*img.height())) - (img.height()//2)
        r = (urandom.getrandbits(30) % 127) + 128
        g = (urandom.getrandbits(30) % 127) + 128
        b = (urandom.getrandbits(30) % 127) + 128

        # Dibujar flechas en imágenes
        img.draw_arrow(x0, y0, x1, y1, color = (r, g, b), size = 30, thickness = 2)

    lcd.display(img)                # Mostrar imagen en lcd
    print(clock.fps())  # imprimir frecuencia de imagen
    time.sleep(2) # Esperar dos segundos antes de repetir

Descargar el programa Flechas.py

Círculos

Programa que muestra círculos superpuestos a la imagen que está capturando la Sentry2.

Al igual que en el ejemplo "Flechas.py", se generan valores de coordenadas y valores de color aleatorios, y luego se utiliza el método image.draw_circle para dibujar círculos superpuestos en la pantalla.

# Rutina que muestra cómo dibujar circulos sobre una imagen.

import sensor, lcd, image, time, urandom

sensor.reset()                      # Reiniciar e inicializar Sentry2
sensor.set_pixformat(sensor.RGB565) # Formato de salida de la cámara RGB565 (también puede ser GRAYSCALE)）
sensor.set_framesize(sensor.QVGA)   # Tamaño de salida de la cámara QVGA (320x240)
sensor.skip_frames(time = 2000)     # Saltar fotogramas cada 2000ms
clock = time.clock()                # Crea un objeto reloj para calcular la frecuencia de imagen

lcd.init()                          # Inicialización de la pantalla
lcd.clear(lcd.RED)                  # Borra la pantalla y ponla de color rojo

while(True):
    clock.tick()                    # Actualizar el reloj que calcula la velocidad en fotogramas

    img = sensor.snapshot()         # Obtener una imagen

    # Generar valores aleatorios de coordenadas y valores RGB
    for i in range(10):
        x = (urandom.getrandbits(30) % (2*img.width())) - (img.width()//2)
        y = (urandom.getrandbits(30) % (2*img.height())) - (img.height()//2)
        radius = urandom.getrandbits(30) % (max(img.height(), img.width())//2)

        r = (urandom.getrandbits(30) % 127) + 128
        g = (urandom.getrandbits(30) % 127) + 128
        b = (urandom.getrandbits(30) % 127) + 128

        # Dibujar un círculo en una imagen
        img.draw_circle(x, y, radius, color = (r, g, b), thickness = 2, fill = False)

    lcd.display(img)   # Mostrar imagen en lcd
    print(clock.fps()) # imprimir frecuencia de imagen
    time.sleep(0.2)    # Esperar 200 milisegundos antes de repetir

Descargar el programa Circulos.py

Aspa o cruz

# Esta rutina muestra cómo dibujar una cruz sobre una imagen

import sensor, image, time, urandom

sensor.reset()                      # Reiniciar e inicializar Sentry2
sensor.set_pixformat(sensor.RGB565) # Formato de salida de la cámara RGB565 (también puede ser GRAYSCALE)）
sensor.set_framesize(sensor.QVGA)   # Tamaño de salida de la cámara QVGA (320x240)
sensor.skip_frames(time = 2000)     # Saltar fotogramas cada 2000ms
clock = time.clock()                # Crea un objeto reloj para calcular la frecuencia de imagen

while(True):
    clock.tick()                    # Actualizar el reloj que calcula la velocidad en fotogramas

    img = sensor.snapshot()         # Obtener una imagen

    # Generar valores aleatorios de coordenadas y valores RGB
    for i in range(10):
        x = (urandom.getrandbits(30) % (2*img.width())) - (img.width()//2)
        y = (urandom.getrandbits(30) % (2*img.height())) - (img.height()//2)
        r = (urandom.getrandbits(30) % 127) + 128
        g = (urandom.getrandbits(30) % 127) + 128
        b = (urandom.getrandbits(30) % 127) + 128

        # Dibujar cruces en una imagen
        img.draw_cross(x, y, color = (r, g, b), size = 10, thickness = 2)

    print(clock.fps()) # imprimir frecuencia de imagen
    # time.sleep(0.2)    # Esperar 200 milisegundos antes de repetir

Descargar el programa Cruz.py

Elipse

# Esta rutina muestra cómo dibujar elipses sobre una imagen

import sensor, image, time, urandom

sensor.reset()                      # Reiniciar e inicializar Sentry2
sensor.set_pixformat(sensor.RGB565) # Formato de salida de la cámara RGB565 (también puede ser GRAYSCALE)）
sensor.set_framesize(sensor.QVGA)   # Tamaño de salida de la cámara QVGA (320x240)
sensor.skip_frames(time = 2000)     # Saltar fotogramas cada 2000ms
clock = time.clock()                # Crea un objeto reloj para calcular la frecuencia de imagen

while(True):
    clock.tick()                    # Actualizar el reloj que calcula la velocidad en fotogramas

    img = sensor.snapshot()         # Obtener una imagen

    # Generar valores aleatorios de coordenadas y valores RGB
    for i in range(10):
        x = (urandom.getrandbits(30) % (2*img.width())) - (img.width()//2)
        y = (urandom.getrandbits(30) % (2*img.height())) - (img.height()//2)
        radius_x = urandom.getrandbits(30) % (max(img.height(), img.width())//2)
        radius_y = urandom.getrandbits(30) % (max(img.height(), img.width())//2)
        rot = urandom.getrandbits(30)

        r = (urandom.getrandbits(30) % 127) + 128
        g = (urandom.getrandbits(30) % 127) + 128
        b = (urandom.getrandbits(30) % 127) + 128

        # Dibujar elipses en una imagen
        img.draw_ellipse(x, y, radius_x, radius_y, rot,
                         color = (r, g, b), thickness = 2, fill = False)

    print(clock.fps())  # imprimir frecuencia de imagen

Descargar el programa Elipse.py

Color de relleno

En img.flood_fill(x, y, \ seed_threshold=0.05, floating_thresholds=0.05, \ color=(255, 0, 255), invert=False, clear_background=False) prueba distintas opciones de color y a poner en True las opciones invert y clear_background.

# Esta rutina muestra cómo rellenar de color zonas de una imagen

import sensor, image, time

sensor.reset()                      # Reiniciar e inicializar Sentry2
sensor.set_pixformat(sensor.RGB565) # Formato de salida de la cámara RGB565 (también puede ser GRAYSCALE)）
sensor.set_framesize(sensor.QVGA)   # Tamaño de salida de la cámara QVGA (320x240)
sensor.skip_frames(time = 2000)     # Saltar fotogramas cada 2000ms
clock = time.clock()                # Crea un objeto reloj para calcular la frecuencia de imagen

while(True):
    clock.tick()                    # Actualizar el reloj que calcula la velocidad en fotogramas

    img = sensor.snapshot()         # Obtener una imagen

    x = sensor.width() // 2
    y = sensor.height()

    # Rellenar imagen
    img.flood_fill(x, y, \
        seed_threshold=0.05, floating_thresholds=0.05, \
        color=(255, 0, 255), invert=False, clear_background=False)

    print(clock.fps())  # imprimir frecuencia de imagen

Descargar el programa Color_relleno.py

Dibujar una imagen sobre otra imagen

# Esta rutina muestra cómo poner una imagen miniatura sobre la imagen vista

import sensor, image, time

sensor.reset()                      # Reiniciar e inicializar Sentry2
sensor.set_pixformat(sensor.RGB565) # Formato de salida de la cámara RGB565 (también puede ser GRAYSCALE)）
sensor.set_framesize(sensor.QVGA)   # Tamaño de salida de la cámara QVGA (320x240)
sensor.skip_frames(time = 2000)     # Saltar fotogramas cada 2000ms
clock = time.clock()                # Crea un objeto reloj para calcular la frecuencia de imagen

while(True):
    clock.tick()                    # Actualizar el reloj que calcula la velocidad en fotogramas

    img = sensor.snapshot()         # Obtener una imagen

    small_img = img.mean_pooled(3, 3) # Generar una nueva imagen a partir de la original

    x = (img.width()//2)-(small_img.width()//2)
    y = (img.height()//2)-(small_img.height()//2)

    # Dibujar otra imagen sobre una imagen
    img.draw_image(small_img, x, y, x_scale=1, y_scale=1)

    print(clock.fps()) # imprimir frecuencia de imagen

Descargar el programa Dibujar_imagen_sobre_imagen.py

Imagen pequeña que rebota

# Imagen que rebota

import sensor, image, time

sensor.reset()
sensor.set_pixformat(sensor.RGB565) # o GRAYSCALE...
sensor.set_framesize(sensor.QVGA) # o QQVGA...
sensor.skip_frames(time = 2000)
clock = time.clock()

BOUNCE = True
RESCALE = True

SMALL_IMAGE_SCALE = 3

CYCLE_FORMATS = True
CYCLE_MASK = True

# Se utiliza cuando CYCLE_FORMATS o CYCLE_MASK es verdadero
value_mixer = 0

# Ubicación de la imagen pequeña
x = 100
y = 50

# Dirección del rebote
xd = 1
yd = 1

# Escalado de imágenes pequeñas
rescale = 1.0
rd = 0.1
max_rescale = 5
min_rescale = rd * 2

# Límite dentro del cual rebotar
xmin = -sensor.width() / SMALL_IMAGE_SCALE - 8
ymin = -sensor.height() / SMALL_IMAGE_SCALE - 8
xmax = sensor.width() + 8
ymax = sensor.height() + 8

while(True):
    clock.tick()

    status = ""
    value_mixer = value_mixer + 1

    img = sensor.snapshot()
    # Hace una copia a escala de la imagen que capta el sensor
    small_img = img.mean_pooled(SMALL_IMAGE_SCALE, SMALL_IMAGE_SCALE)

    status = 'rgb565'
    if CYCLE_FORMATS:
        image_format = (value_mixer >> 8) & 3
        # To test combining different formats
        if (image_format==1): small_img = small_img.to_bitmap(copy=True); status = 'bitmap'
        if (image_format==2): small_img = small_img.to_grayscale(copy=True); status = 'grayscale'
        if (image_format==3): small_img = small_img.to_rgb565(copy=True); status = 'rgb565'

    # Actualizar la ubicación de la imagen pequeña
    if BOUNCE:
        x = x + xd
        if (x<xmin or x>xmax):
            xd = -xd

        y = y + yd
        if (y<ymin or y>ymax):
            yd = -yd

    # Actualizar la ubicación de la imagen pequeña
    if RESCALE:
        rescale = rescale + rd
        if (rescale<min_rescale or rescale>max_rescale):
            rd = -rd

    # Encontrar el centro de la imagen
    scaled_width = int(small_img.width() * abs(rescale))
    scaled_height= int(small_img.height() * abs(rescale))

    apply_mask = CYCLE_MASK and ((value_mixer >> 9) & 1)
    if apply_mask:
        img.draw_image(small_img, int(x), int(y), mask=small_img.to_bitmap(copy=True), x_scale=rescale, y_scale=rescale, alpha=240)
        status += 'alpha:240'
        status += '+mask'
    else:
        img.draw_image(small_img, int(x), int(y), x_scale=rescale, y_scale=rescale, alpha=128)
        status += 'alpha:128'

    img.draw_string(8, 0, status, mono_space = False)

    print(clock.fps())

Descargar el programa Imagen_rebota.py

Pruebas con canal alfa

Alfa

En imágenes, el término "alfa" se refiere al canal alfa, que es una información adicional por píxel que determina su opacidad o nivel de transparencia. Este canal funciona como una máscara, donde los valores negros indican transparencia total, los blancos opacidad total y los grises valores intermedios de semitransparencia.

Este script prueba el rendimiento y la calidad del método draw_image() creando una paleta a la que se le van aplicado diferentes valores de alfa y por tanto de transparencia. Dicha paleta se irá moviendo superpuesta a la aimagen capturada por el sensor.

# Pruebas con canal alfa

import sensor, image, time

sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)

small_img = image.Image(size=(4, 4))
small_img.set_pixel(0, 0, (0,   0,   127))
small_img.set_pixel(1, 0, (47,  255, 199))
small_img.set_pixel(2, 0, (0,   188, 255))
small_img.set_pixel(3, 0, (0,   0,   127))
small_img.set_pixel(0, 1, (0,   176, 255))
small_img.set_pixel(1, 1, (222, 0,   0  ))
small_img.set_pixel(2, 1, (50,  255, 195))
small_img.set_pixel(3, 1, (86,  255, 160))
small_img.set_pixel(0, 2, (255, 211, 0  ))
small_img.set_pixel(1, 2, (83,  255, 163))
small_img.set_pixel(2, 2, (255, 211, 0))
small_img.set_pixel(3, 2, (0,   80,  255))
small_img.set_pixel(0, 3, (255, 118, 0  ))
small_img.set_pixel(1, 3, (127, 0,   0  ))
small_img.set_pixel(2, 3, (0,   144, 255))
small_img.set_pixel(3, 3, (50,  255, 195))

big_img = image.Image(size=(128, 128))
big_img.draw_image(small_img, 0, 0, x_scale=32, y_scale=32)

alpha_div = 1
alpha_value = 0
alpha_step = 2

x_bounce = sensor.width()//2
x_bounce_toggle = 1

y_bounce = sensor.height()//2
y_bounce_toggle = 1

clock = time.clock()
while(True):
    clock.tick()

    img = sensor.snapshot()
    img.draw_image(big_img, x_bounce, y_bounce,
                   rgb_channel=-1, alpha=alpha_value//alpha_div,
                   )

    x_bounce += x_bounce_toggle
    if abs(x_bounce-(img.width()//2)) >= (img.width()//2): x_bounce_toggle = -x_bounce_toggle

    y_bounce += y_bounce_toggle
    if abs(y_bounce-(img.height()//2)) >= (img.height()//2): y_bounce_toggle = -y_bounce_toggle

    alpha_value += alpha_step
    if not alpha_value or alpha_value//alpha_div == 256: alpha_step = -alpha_step

    print(clock.fps())

Descargar el programa Pruebas_canal_alfa.py

Puntos de referencia

Esta rutina muestra como dibujar puntos de referencia (Keypoints) sobre una imagen.

Normalmente puedes llamar a draw_keypoints() directamente pero también puedes llamarla pasando una tupla de 3 valores.

# Dibujar puntos de referencia (Keypoints) sobre una imagen

import sensor, image, time, urandom

sensor.reset()                      # Reiniciar e inicializar Sentry2
sensor.set_pixformat(sensor.RGB565) # Formato de salida de la cámara RGB565 (también puede ser GRAYSCALE)）
sensor.set_framesize(sensor.QVGA)   # Tamaño de salida de la cámara QVGA (320x240)
sensor.skip_frames(time = 2000)     # Saltar fotogramas cada 2000ms
clock = time.clock()                # Crea un objeto reloj para calcular la frecuencia de imagen

while(True):
    clock.tick()                    # Actualizar el reloj que calcula la velocidad en fotogramas

    img = sensor.snapshot()         # Obtener una imagen

    # Generar coordenadas aleatorias
    for i in range(20):
        x = (urandom.getrandbits(30) % (2*img.width())) - (img.width()//2)
        y = (urandom.getrandbits(30) % (2*img.height())) - (img.height()//2)
        rot = urandom.getrandbits(30) % 360

        r = (urandom.getrandbits(30) % 127) + 128
        g = (urandom.getrandbits(30) % 127) + 128
        b = (urandom.getrandbits(30) % 127) + 128

        # Dibujar puntos pasando una tupla [(x, y, rot)] de valores
        img.draw_keypoints([(x, y, rot)], color = (r, g, b), size = 20, thickness = 2, fill = False)

    print(clock.fps())  # imprimir frecuencia de imagen

Descargar el programa Puntos_referencia.py

Lineas

# Dibujar lineas sobre una imagen

import sensor, image, time, urandom

sensor.reset()                      # Reiniciar e inicializar Sentry2
sensor.set_pixformat(sensor.RGB565) # Formato de salida de la cámara RGB565 (también puede ser GRAYSCALE)）
sensor.set_framesize(sensor.QVGA)   # Tamaño de salida de la cámara QVGA (320x240)
sensor.skip_frames(time = 2000)     # Saltar fotogramas cada 2000ms
clock = time.clock()                # Crea un objeto reloj para calcular la frecuencia de imagen

while(True):
    clock.tick()                    # Actualizar el reloj que calcula la velocidad en fotogramas

    img = sensor.snapshot()         # Obtener una imagen

    # Generar coordenadas aleatorias
    for i in range(10):
        x0 = (urandom.getrandbits(30) % (2*img.width())) - (img.width()//2)
        y0 = (urandom.getrandbits(30) % (2*img.height())) - (img.height()//2)
        x1 = (urandom.getrandbits(30) % (2*img.width())) - (img.width()//2)
        y1 = (urandom.getrandbits(30) % (2*img.height())) - (img.height()//2)
        r = (urandom.getrandbits(30) % 127) + 128
        g = (urandom.getrandbits(30) % 127) + 128
        b = (urandom.getrandbits(30) % 127) + 128

        # Dibujar líneas en una imagen
        img.draw_line(x0, y0, x1, y1, color = (r, g, b), thickness = 2)

    print(clock.fps())  # imprimir frecuencia de imagen

Descargar el programa Lineas.py

Rectángulos

# Dibujar rectangulos sobre una imagen

import sensor, image, time, urandom

sensor.reset()                      # Reiniciar e inicializar Sentry2
sensor.set_pixformat(sensor.RGB565) # Formato de salida de la cámara RGB565 (también puede ser GRAYSCALE)）
sensor.set_framesize(sensor.QVGA)   # Tamaño de salida de la cámara QVGA (320x240)
sensor.skip_frames(time = 2000)     # Saltar fotogramas cada 2000ms
clock = time.clock()                # Crea un objeto reloj para calcular la frecuencia de imagen

while(True):
    clock.tick()                    # Actualizar el reloj que calcula la velocidad en fotogramas

    img = sensor.snapshot()         # Obtener una imagen

    # Generar valores aleatorios de coordenadas y valores RGB
    for i in range(10):
        x = (urandom.getrandbits(30) % (2*img.width())) - (img.width()//2)
        y = (urandom.getrandbits(30) % (2*img.height())) - (img.height()//2)
        w = (urandom.getrandbits(30) % (img.width()//2))
        h = (urandom.getrandbits(30) % (img.height()//2))
        r = (urandom.getrandbits(30) % 127) + 128
        g = (urandom.getrandbits(30) % 127) + 128
        b = (urandom.getrandbits(30) % 127) + 128

        # Dibujar rectángulos en la imagen
        img.draw_rectangle(x, y, w, h, color = (r, g, b), thickness = 2, fill = False)

    print(clock.fps())  # imprimir frecuencia de imagen

Descargar el programa Rectangulos.py

Texto

# Dibujar cadenas de texto sobre una imagen

import sensor, image, time, urandom

sensor.reset()                      # Reiniciar e inicializar Sentry2
sensor.set_pixformat(sensor.RGB565) # Formato de salida de la cámara RGB565 (también puede ser GRAYSCALE)）
sensor.set_framesize(sensor.QVGA)   # Tamaño de salida de la cámara QVGA (320x240)
sensor.skip_frames(time = 2000)     # Saltar fotogramas cada 2000ms
clock = time.clock()                # Crea un objeto reloj para calcular la frecuencia de imagen

while(True):
    clock.tick()                    # Actualizar el reloj que calcula la velocidad en fotogramas

    img = sensor.snapshot()         # Obtener una imagen

    # Generar valores aleatorios de coordenadas y valores RGB
    for i in range(10):
        x = (urandom.getrandbits(30) % (2*img.width())) - (img.width()//2)
        y = (urandom.getrandbits(30) % (2*img.height())) - (img.height()//2)
        r = (urandom.getrandbits(30) % 127) + 128
        g = (urandom.getrandbits(30) % 127) + 128
        b = (urandom.getrandbits(30) % 127) + 128

        # Dibujar cadenas de texto superpuestas a la imagen capturada
        img.draw_string(x, y, "Cadena de texto", color = (r, g, b), scale = 2, mono_space = False,
                        char_rotation = 0, char_hmirror = False, char_vflip = False,
                        string_rotation = 0, string_hmirror = False, string_vflip = False)

    print(clock.fps())  # imprimir frecuencia de imagen
    time.sleep_ms(200)

Descargar el programa Cadenas_texto.py