image-patches-absolute-rotation-scale.py

# Dieses Werk ist unter der MIT-Lizenz lizenziert.
# Copyright (c) 2013-2023 OpenMV LLC. Alle Rechte vorbehalten.
# https://github.com/openmv/openmv/blob/master/LICENSE
#
# Bildausschnitte absoluter optischer Fluss Rotation/Skalierung
#
# Dieses Beispiel zeigt, wie Sie mit Ihrer OpenMV Cam
# Rotation/Skalierung messen, indem das aktuelle und ein vorheriges
# Bild miteinander verglichen werden. Beachten Sie, dass in diesem Modus nur Rotation/Skalierung
# verarbeitet wird - nicht die X- und Y-Translation.
#
# Dieses Beispiel geht jedoch über die Berechnung des optischen Flusses für das gesamte
# Bild auf einmal hinaus. Stattdessen wird der Vorgang aufgeteilt, indem mit Gruppen
# von Pixeln im Bild gearbeitet wird. Dies liefert ein "neues" Ergebnisbild.
#
# BEACHTEN SIE, dass Oberflächen eine Art "Kante" aufweisen müssen, damit der
# Algorithmus funktioniert. Eine merkmalslose Oberfläche liefert völlig unsinnige Ergebnisse.
#
# Um diese Demo effektiv auszuführen, montieren Sie Ihre OpenMV Cam bitte auf einer stabilen
# Unterlage und drehen Sie die Kamera LANGSAM um das Objektiv und bewegen Sie die Kamera
# vor und zurück, um zu sehen, wie sich die Werte ändern.
# D. h. nur Änderungen in Z-Richtung.
#
# HINWEIS: Bei der Verwendung von
# find_displacement() müssen Sie eine kleine Auflösung verwenden, die eine Zweierpotenz ist. Dies liegt daran, dass der Algorithmus auf
# der sogenannten Phasenkorrelation basiert, die den Bildvergleich
# mittels FFTs durchführt. Eine Auflösung, die keine Zweierpotenz ist, erfordert ein Auffüllen auf eine Zweierpotenz,
# was die Aussagekraft der Algorithmusergebnisse verringert. Bitte
# verwenden Sie eine Auflösung wie B128X128 oder B128X64 (2x schneller).
#
# Ihre OpenMV Cam unterstützt Zweierpotenz-Auflösungen von 64x32, 64x64,
# 128x64 und 128x128. Wenn Sie eine Auflösung von 32x32 wünschen, können Sie diese
# erzeugen, indem Sie "img.scale(x_scale=0.5, y_scale=0.5, hint=image.AREA)" auf ein 64x64-Bild anwenden.

import csi
import image
import time
import math

BLOCK_W = 16  # pow2
BLOCK_H = 16  # pow2

csi0 = csi.CSI()
csi0.reset()  # Sensor zurücksetzen und initialisieren.
csi0.pixformat(csi.GRAYSCALE)  # Pixelformat auf GRAYSCALE setzen
csi0.framesize((128, 128))  # Bildgröße auf 128x128 setzen ... (oder 64x64) ...
csi0.snapshot(time=2000)  # Warten, bis die Einstellungen wirksam werden.
clock = time.clock()  # Ein Clock-Objekt erstellen, um die FPS zu verfolgen.

# Erstellt einen zweiten Framebuffer auf dem Heap.
extra_fb = image.Image(csi0.width(), csi0.height(), csi0.pixformat())
extra_fb.draw_image(csi0.snapshot())

while True:
    clock.tick()  # Erfasst die vergangenen Millisekunden zwischen den Aufrufen von snapshots().
    img = csi0.snapshot()  # Nimmt ein Bild auf und gibt es zurück.

    for y in range(0, csi0.height(), BLOCK_H):
        for x in range(0, csi0.width(), BLOCK_W):
            # Für dieses Beispiel wird das alte Bild nie aktualisiert, um die absolute Änderung zu messen.
            displacement = extra_fb.find_displacement(
                img,
                logpolar=True,
                roi=(x, y, BLOCK_W, BLOCK_H),
                template_roi=(x, y, BLOCK_W, BLOCK_H),
            )

            # Unter etwa 0.1 (YMMV) sind die Ergebnisse nur noch Rauschen.
            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())