Event-Based Vision Software: Mga SDK, Mga Format ng Data at Pagsasama

Ano ang proseso ng software ng pangitain na nakabatay sa kaganapan?

Ang isang camera ng kaganapan ay nag-uulat ng mga pagbabago sa liwanag sa halip na maghatid ng isang kumbensyonal na frame ng video sa bawat pagitan. Ang isang na-decode na kaganapan ay karaniwang tumutukoy sa isang pixel, isang polarity at isang timestamp. Dapat mapanatili ng iyong aplikasyon ang kahulugan ng mga field na iyon sa pamamagitan ng pagkuha, pag-filter, pag-record at paghihinuha. Ang batay sa kaganapan kumpara sa paghahambing na batay sa frame nagpapaliwanag kung kailan kapaki-pakinabang ang data model na iyon.

Tukuyin ang tatlong format sa disenyo: ang sensor o transport encoding, ang decoded na representasyon ng kaganapan na ginagamit ng software, at ang representasyon na ipinasa sa isang algorithm. Ang isang file na naglalaman ng mga raw sensor packet, isang hanay ng mga na-decode na kaganapan at isang naipon na imahe ay nagsisilbi sa iba't ibang layunin. Ang pag-convert sa pagitan ng mga ito ay maaaring magbago ng paggamit ng memorya, gastos sa pagproseso at ang impormasyon sa tiyempo na magagamit sa ibaba ng agos.

Paano suriin ang isang event-camera SDK

Magsimula sa eksaktong sensor, firmware ng camera at platform ng host. Ang isang desktop demonstration ay hindi nagtatatag ng suporta para sa isang naka-embed na Linux na larawan, isang ARM processor o iyong lisensya sa produksyon. Tanungin ang supplier para sa mga sinusuportahang operating system, mga arkitektura ng CPU, mga kondisyon sa muling pamamahagi at mga kinakailangan sa interface ng camera. I-verify ang application sa nilalayong platform bago i-commit ang carrier circuit board para sa isang compute module.

• Pagkuha: pagtuklas ng device, pagsasaayos, pag-decode at pag-uulat ng error.
• Timing: pinanggalingan ng timestamp, paghawak ng rollover, mga panlabas na trigger at pag-align ng maraming device.
• Reproducibility: pag-record, pag-export ng configuration at isang natukoy na bersyon ng software.
• Deployment: walang ulo na operasyon, sinusuportahang binary, pag-restart ng gawi at mga tuntunin ng lisensya.
• Pagmamasid: bilang ng kaganapan, lalim ng pila, nalaglag na data at paggamit ng mapagkukunan ng host.

Bumuo ng pipeline na may tahasang mga hangganan ng timing

Panatilihing hiwalay ang pagkuha mula sa mamahaling visualization, pagsusulat ng disk at inference ng modelo. Kung hindi, maaaring maantala ng isang mabagal na mamimili ang bagong data bago pa man magsimula ang algorithm. Tumukoy ng bounded queue at isang tahasang overload na patakaran. Ang pag-drop sa pinakalumang window, pagbabawas ng rehiyon ng interes at paghinto sa isang error ay may iba't ibang kahihinatnan; piliin ang gawi na akma sa aplikasyon at itala kapag nangyari ito.

Gumamit ng mga timestamp ng sensor upang ilarawan kung kailan naganap ang mga obserbasyon, at isang monotonic na host clock upang sukatin ang mga tagal ng pagproseso. Ang pagbabawas ng mga timestamp mula sa mga hindi nauugnay na orasan ay hindi gumagawa ng wastong end-to-end latency. Kung kailangang isama ang camera sa isang IMU o conventional camera, itatag ang ugnayan ng orasan at proseso ng pagkakalibrate na inilarawan sa aming gabay sa pag-synchronize ng sensor-fusion.

Isang maliit na halimbawa ng pag-record-inspeksyon

Ang sumusunod na halimbawa ng Python ay nagbibilang ng mga na-decode na kaganapan sa isang sinusuportahang recording at nag-uulat ng span ng kanilang mga timestamp. Ginagamit nito ang dokumentadong Metavision streaming API at nangangailangan ng katugmang SDK na pag-install at pagre-record. Ito ay isang halimbawa ng inspeksyon, hindi isang ALVEXIS benchmark ng camera o isang detector.

import argparse
from metavision_sdk_stream import Camera, CameraStreamSlicer

parser = argparse.ArgumentParser()
parser.add_argument("recording")
args = parser.parse_args()
source = Camera.from_file(args.recording)
count, first_us, last_us = 0, None, None

for batch in CameraStreamSlicer(source.move()):
    events = batch.events
    if events.size:
        start = int(events["t"][0])
        end = int(events["t"][-1])
        first_us = start if first_us is None else min(first_us, start)
        last_us = end if last_us is None else max(last_us, end)
        count += int(events.size)

span_s = 0.0 if first_us is None else (last_us - first_us) / 1_000_000
print({"events": count, "event_timestamp_span_s": span_s})

Sinasaklaw ng timestamp span ang una hanggang huling naobserbahang kaganapan; hindi nito sinusukat ang tagal ng file, pagkaantala sa pagkuha o throughput ng pagproseso. Ang mga walang laman na panahon at pag-reset ng orasan ay nangangailangan ng hiwalay na pangangasiwa sa produksyon. Panatilihin ang configuration ng device at pagre-record ng metadata sa tabi ng file nang sa gayon ay maaaring kopyahin ng pangalawang engineer ang interpretasyon.

I-validate ang mga tahimik na eksena, abalang eksena at pagbawi ng pagkabigo

Subukan ang isang nakatigil na eksena, representasyong galaw at isang sadyang hinihingi na eksena. Ang flicker, vibration ng camera at naka-texture na paggalaw ay maaaring lumikha ng ibang mga rate ng kaganapan. Itala ang parehong karaniwang pag-uugali at ang pinakamasamang kaso na iyong naobserbahan. Ulitin nang aktibo ang storage at mga komunikasyon, dahil ang mga workload na iyon ay nakikipagkumpitensya para sa memorya at oras ng CPU.

Kapag gumagamit ng neural network ang algorithm, suriin ang resultang tensor at mga sinusuportahang operator bago pumili ng accelerator. Ang camera ng kaganapan ay hindi awtomatikong nangangailangan ng isang NPU, at ang isang NPU ay hindi awtomatikong tumatanggap ng isang stream ng kaganapan. Ang aming FPGA, NPU at MPU gabay sa arkitektura naghihiwalay sa mga serbisyo ng pagkuha, preprocessing, inference at application.

Mga tanong bago pumili ng software stack

Maaari ba akong gumamit ng isang normal na modelo ng computer-vision?

Pagkatapos lamang matukoy ang isang katugmang representasyon ng input at patunayan ang pag-uugali nito. Ang pag-iipon ng mga kaganapan sa mga larawan ay maaaring magbigay-daan sa muling paggamit ng isang yugto ng pagproseso ng imahe, ngunit binabago ang pamamahagi ng data at nagdaragdag ng isang window ng tiyempo. Suriin ang kumpletong aplikasyon sa kinatawan ng data.

Ang isang gumaganang laptop demo ba ay nagpapatunay ng naka-embed na compatibility?

Hindi. Kumpirmahin ang arkitektura ng CPU, operating system, interface ng sensor, driver, lisensya ng SDK at patuloy na paggamit ng mapagkukunan ng aktwal na target na platform.

Ano ang dapat kong ipadala para sa isang talakayan sa pagsasama?

Ipadala ang camera o sensor reference, sample recording, nilalayon na output, katanggap-tanggap na pagkaantala, host platform, interface at deployment environment. Ang mga input na ito ay ginagawang sapat ang talakayan upang matukoy ang mga unang panganib sa pagsasama.

Neuromorphic vision sa pipeline ng computer vision

Ang mga camera ng kaganapan ay madalas na tinatalakay sa ilalim ng neuromorphic vision dahil ang kanilang mga tala ng output ay nagbabago sa mga indibidwal na pixel sa halip na isang nakapirming pagkakasunud-sunod ng mga kumpletong larawan. Ang representasyon ng data na iyon ay hindi awtomatikong nagbibigay ng object detection o resulta ng neural-network. Ang software ay nangangailangan pa rin ng isang tinukoy na gawain, isang katugmang algorithm at masusukat na pamantayan sa pagtanggap.

Kapag isinasama ang mga tool sa computer vision na nakatuon sa frame, ang isang stream ng kaganapan ay maaaring ma-convert sa isang time-window na imahe o isa pang representasyon. Panatilihin ang orihinal na mga timestamp kung ang gawain ay nakasalalay sa pinong temporal na impormasyon. Suriin ang kumpletong conversion at pagproseso ng pipeline; ang isang kaakit-akit na muling itinayong imahe lamang ay hindi nagtatatag ng katumpakan o latency ng huling aplikasyon.

Magplano ng timing bago ang sensor data fusion