image-patches-absolute-rotation-scale.py

# Este trabalho está licenciado sob a licença MIT.
# Copyright (c) 2013-2023 OpenMV LLC. Todos os direitos reservados.
# https://github.com/openmv/openmv/blob/master/LICENSE
#
# Fluxo Óptico Absoluto por Patches de Imagem - Rotação/Escala
#
# Este exemplo demonstra o uso da sua OpenMV Cam para medir
# rotação/escala comparando a imagem atual com uma
# anterior. Note que apenas rotação/escala é
# tratada - não translação em X e Y neste modo.
#
# No entanto, este exemplo vai além de fazer fluxo óptico na imagem
# inteira de uma vez. Em vez disso, ele divide o processo trabalhando em grupos
# de pixels na imagem. Isso fornece uma "nova" imagem de resultados.
#
# NOTA que as superfícies precisam ter algum tipo de "borda" nelas para o
# algoritmo funcionar. Uma superfície sem características produz resultados aleatórios.
#
# Para executar esta demonstração de forma eficaz, monte sua OpenMV Cam em uma
# base estável e gire LENTAMENTE a câmera em torno da lente e mova a câmera
# para frente/para trás para ver os números mudarem.
# Ou seja, apenas mudanças na direção Z.
#
# NOTA Você deve usar uma pequena resolução em potência de 2 ao usar
# find_displacement(). Isso ocorre porque o algoritmo é baseado em
# algo chamado correlação de fase, que faz a comparação de imagens
# usando FFTs. Uma resolução que não seja potência de 2 requer preenchimento até uma potência
# de 2, o que reduz a utilidade dos resultados do algoritmo. Por favor,
# use uma resolução como B128X128 ou B128X64 (2x mais rápido).
#
# Sua OpenMV Cam suporta resoluções em potência de 2 de 64x32, 64x64,
# 128x64 e 128x128. Se quiser uma resolução de 32x32, você pode criá-la
# fazendo "img.scale(x_scale=0.5, y_scale=0.5, hint=image.AREA)" em uma imagem 64x64.

import csi
import image
import time
import math

BLOCK_W = 16  # pow2
BLOCK_H = 16  # pow2

csi0 = csi.CSI()
csi0.reset()  # Reinicia e inicializa o sensor.
csi0.pixformat(csi.GRAYSCALE)  # Define o formato de pixel para GRAYSCALE
csi0.framesize((128, 128))  # Define o tamanho do frame para 128x128... (ou 64x64)...
csi0.snapshot(time=2000)  # Aguarda as configurações fazerem efeito.
clock = time.clock()  # Cria um objeto clock para rastrear o FPS.

# Cria um segundo frame buffer no heap.
extra_fb = image.Image(csi0.width(), csi0.height(), csi0.pixformat())
extra_fb.draw_image(csi0.snapshot())

while True:
    clock.tick()  # Rastreia os milissegundos decorridos entre snapshots().
    img = csi0.snapshot()  # Tira uma foto e retorna a imagem.

    for y in range(0, csi0.height(), BLOCK_H):
        for x in range(0, csi0.width(), BLOCK_W):
            # Neste exemplo nunca atualizamos a imagem antiga para medir a mudança absoluta.
            displacement = extra_fb.find_displacement(
                img,
                logpolar=True,
                roi=(x, y, BLOCK_W, BLOCK_H),
                template_roi=(x, y, BLOCK_W, BLOCK_H),
            )

            # Abaixo de 0.1 aproximadamente (pode variar) os resultados são apenas ruído.
            if displacement.response > 0.1:
                rotation_change = displacement.rotation
                zoom_amount = 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,
                )

    print(clock.fps())