image-patches-differential-rotation-scale.py

# Esta obra está licenciada bajo la licencia MIT.
# Copyright (c) 2013-2023 OpenMV LLC. Todos los derechos reservados.
# https://github.com/openmv/openmv/blob/master/LICENSE
#
# Flujo óptico diferencial por parches de imagen: rotación/escala
#
# Este ejemplo muestra cómo usar su OpenMV Cam para medir
# rotación/escala comparando la imagen actual con la
# anterior. Tenga en cuenta que solo se maneja rotación/escala,
# no traslación en X e Y en este modo.
#
# Sin embargo, este ejemplo va más allá de realizar flujo óptico sobre toda
# la imagen a la vez. En su lugar, divide el proceso trabajando con grupos
# de píxeles de la imagen. Esto le da una "nueva" imagen de resultados.
#
# NOTA: las superficies necesitan tener algún tipo de "borde" para que el
# algoritmo funcione. Una superficie sin rasgos produce resultados erráticos.
#
# Para ejecutar esta demostración de forma efectiva, monte su OpenMV Cam sobre una base
# estable y gire LENTAMENTE la cámara alrededor del lente y mueva la cámara
# hacia adelante/atrás para ver cómo cambian los números.
# Es decir, solo cambios en la dirección Z.
#
# NOTA: debe usar una resolución pequeña que sea potencia de 2 al usar
# find_displacement(). Esto se debe a que el algoritmo funciona mediante
# algo llamado correlación de fase, que realiza la comparación de imágenes
# usando FFT. Una resolución que no sea potencia de 2 requiere relleno hasta una potencia
# de 2, lo que reduce la utilidad de los resultados del algoritmo. Por favor,
# use una resolución como B128X128 o B128X64 (2 veces más rápido).
#
# Su OpenMV Cam admite resoluciones potencia de 2 de 64x32, 64x64,
# 128x64 y 128x128. Si desea una resolución de 32x32, puede crearla
# ejecutando "img.scale(x_scale=0.5, y_scale=0.5, hint=image.AREA)" sobre una imagen de 64x64.

import csi
import image
import time
import math

BLOCK_W = 16  # pow2
BLOCK_H = 16  # pow2

csi0 = csi.CSI()
csi0.reset()  # Restablecer e inicializar el sensor.
csi0.pixformat(csi.GRAYSCALE)  # Establezca el formato de píxel en GRAYSCALE
csi0.framesize((128, 128))  # Establezca el tamaño de fotograma en 128x128... (o 64x64)...
csi0.snapshot(time=2000)  # Esperar a que los ajustes surtan efecto.
clock = time.clock()  # Crear un objeto clock para registrar los FPS.

# Cree un segundo framebuffer en el heap.
extra_fb = image.Image(csi0.width(), csi0.height(), csi0.pixformat())
extra_fb.draw_image(csi0.snapshot())

while True:
    clock.tick()  # Registre los milisegundos transcurridos entre snapshots().
    img = csi0.snapshot()  # Tomar una foto y devolver la imagen.

    for y in range(0, csi0.height(), BLOCK_H):
        for x in range(0, csi0.width(), BLOCK_W):
            displacement = extra_fb.find_displacement(
                img,
                logpolar=True,
                roi=(x, y, BLOCK_W, BLOCK_H),
                template_roi=(x, y, BLOCK_W, BLOCK_H),
            )

            # Por debajo de 0.1 aproximadamente (según el caso), los resultados son solo ruido.
            if displacement.response > 0.1:
                rotation_change = displacement.rotation
                zoom_amount = 1.0 + displacement.scale
                pixel_x = (
                    x
                    + (BLOCK_W // 2)
                    + int(math.sin(rotation_change) * zoom_amount * (BLOCK_W // 4))
                )
                pixel_y = (
                    y
                    + (BLOCK_H // 2)
                    + int(math.cos(rotation_change) * zoom_amount * (BLOCK_H // 4))
                )
                img.draw_line(
                    (x + BLOCK_W // 2, y + BLOCK_H // 2, pixel_x, pixel_y), color=255
                )
            else:
                img.draw_line(
                    (
                        x + BLOCK_W // 2,
                        y + BLOCK_H // 2,
                        x + BLOCK_W // 2,
                        y + BLOCK_H // 2,
                    ),
                    color=0,
                )
    extra_fb.draw_image(img)

    print(clock.fps())