Kom hurtigt i gang med 3D Time-of-Flight applikationer

3D Time-of-Flight (ToF) billeder fungerer som et effektivt alternativ til videobilleder til en lang række anvendelsesformål, inklusive industriel sikkerhed, robotnavigation, grænseflader til styring via bevægelse og meget mere. Denne tilgang kræver dog en grundig blanding af optisk design, præcisionstimingkredsløb og signalbehandlingsfunktioner, hvilket ofte kan give udviklere problemer med at implementere en effektiv 3D ToF-platform.

I denne artikel beskrives nuancerne omkring ToF-teknologi, inden den viser, hvordan to 3D ToF-standardkit – Analog Devices' AD-96TOF1-EBZ udviklingsplatform og ESPROS Photonics' EPC660 evalueringskit– kan hjælpe udviklere med hurtigt at skabe prototyper af 3D ToF-applikationer og få den nødvendige erfaring til at implementere 3D ToF-design, der opfylder lige netop deres krav.

Hvad er ToF-teknologi?

ToF-teknologi er baseret på det kendte princip om, at afstanden mellem et objekt og et vilkårligt kildepunkt kan findes ved at måle forskellen mellem tidspunktet, hvor energien sendes af kilden, og tidspunktet, hvor refleksionen modtages igen af kilden (figur 1).

Figur 1: ToF-systemer beregner afstanden mellem systemet og eksterne objekter ved at måle forsinkelsen mellem afsendelsen af energi og systemets modtagelse af energien reflekteret af et objekt. (Billedkilde: Analog Devices)

Det grundlæggende princip er det samme, men ToF-løsninger er meget forskellige og har de samme funktioner og begrænsninger som deres underliggende teknologier, inklusive ultralyd, lysregistrering og afstandsmåling (LiDAR, light detection and ranging), kameraer og millimeterbølge (mmWave) RF-signaler:

• ToF-ultralydsløsninger er typisk billige, men med begrænset rækkevidde og rumlig opløsning af objekter
• Optiske ToF-løsninger kan levere større rækkevidde og rumlig opløsning end ultralydssystemer, men de fungerer dårligt i tyk tåge eller røg
• Løsninger baseret på mmWave-teknologi er typisk mere komplekse og dyre, men de har en lang rækkevidde og kan levere oplysninger om målobjektets hastighed og kurs på trods af røg, tåge og regn

Producenter kan udnytte fordelene ved hver teknologi til at opfylde deres specifikke krav. For eksempel er ultralydssensorer velegnede til at registrere forhindringer, når robotter skal bevæge sig på tværs af en vej eller som hjælp til at parkere et køretøj. mmWave-teknologi giver til gengæld køretøjer den funktionalitet til registrering på lange distancer, der kræves for at opdage farer forude – selv under vejrforhold, hvor andre sensorer ikke kan trænge igennem.

ToF-design kan bygges omkring et enkelt sender-/modtagerpar. Rent konceptuelt kræver et simpelt optisk ToF-design blot en LED til at oplyse et område og en fotodiode til at registrere refleksioner fra objekter inden for det pågældende område. Dette tilsyneladende enkle design kræver dog præcise timing- og synkroniseringskredsløb til at måle forsinkelsen. Desuden kan der være brug for modulerings- og demoduleringskredsløb for at differentiere mellem lyssignalet og baggrundskilderne eller understøtte mere komplekse kontinuerlige bølgemetoder.

Designets kompleksitet stiger hurtigt, når udviklere vil forbedre signal/støj-forholdet (SNR) og eliminere artefakter i ToF-systemer. Kompleksiteten stiger yderligere i mere avancerede registreringssystemer, der bruger flere sendere og modtagere til at spore flere objekter eller understøtte mere sofistikerede algoritmer til sporing af bevægelse. For eksempel vil mmWave-systemer ofte anvende flere modtagere til at spore kursen og hastigheden på flere uafhængige objekter. (Se "Brug millimeterbølge-radarkit til hurtig udvikling af præcise objektregistreringsdesign".)

3D optiske ToF-systemer

3D optiske ToF-systemer udbygger ideen om at bruge flere modtagere i form af billedsensorer, der typisk er baseret på en række ladningskoblede enheder (CCD'er). Når et sæt linser fokuserer et bestemt område på CCD-rækken, oplades hver ladningslagringsenhed i CCD-rækken af det reflekterede lys fra et tilsvarende punkt i det pågældende område. Synkroniseret med pulserende eller kontinuerlig bølge-belysning opfanges reflekteret lys, der når frem til CCD-rækken, i bund og grund i en sekvens af hhv. vinduer eller faser. Disse data behandles yderligere for at skabe en 3D-dybdeafbildning bestående af voxel (VOlume piXELs), hvis værdier repræsenterer afstanden til det tilsvarende punkt i det pågældende område.

Lige som billeder i et videoklip kan individuelle dybdeafbildninger registreres og anbringes i en sekvens for at tilvejebringe målinger med en tidsopløsning, der kun er begrænset af billedoptagelsessystemets billedhastighed, og med en rumlig opløsning, der kun er begrænset af CCD-rækken og det optiske system. Takket være CCD-billedgeneratorer med større opløsninger på 320 x 240 pixel finder 3D optiske ToF-systemer med højere oplysninger anvendelse i meget forskellige brancher, inklusive industriel automatisering, ubemandede luftfartøjer (UAV'er) og sågar grænseflader til styring via bevægelse (figur 2).

Figur 2: Takket være deres høje billedhastighed og rumlige opløsning kan 3D optiske ToF-løsninger levere detaljerede data til grænseflader til styring via bevægelse – såsom en persons hånd, der rækkes op mod ToF-kameraet som vist her. (Billedkilde: ESPROS Photonics)

I modsætning til de fleste kamerabaserede metoder kan 3D ToF-systemer give nøjagtige resultater på trods af skygger eller ændringer i lysforholdene. Disse systemer har indbygget belysning typisk i form af laserlys eller kraftfulde infrarøde LED'er såsom Lumileds' Luxeon IR LED'er, der kan fungere ved de skiftefrekvenser (i MHz), der bruges i disse systemer. I modsætning til andre metoder, såsom stereoskopiske kameraer, udgør 3D ToF-systemer en kompakt løsning til at generere detaljerede afstandsoplysninger.

Forhåndsbyggede løsninger

I implementeringen af 3D ToF-systemer står udviklere dog over for adskillige designmæssige udfordringer. Ud over de tidligere nævnte timingkredsløb afhænger disse systemer af en nøje designet signalbehandlingspipeline, der er optimeret til at læse resultater hurtigt fra CCD-rækken for hver vindues- eller fasemåling og dernæst udføre den nødvendige behandling for at omdanne de rå data til dybdeafbildninger. Avancerede 3D ToF-billedgeneratorer såsom ESPROS Photonics' EPC660-CSP68-007 ToF-billedgenerator kombinerer en CCD-række på 320 x 240 pixel med de timing- og signalbehandlingsfunktioner, der kræves for at udføre 3D ToF-målinger og levere 12-bit afstandsdata pr. pixel (figur 3).

Figur 3: ESPROS Photonics epc660 integrerer en billedgenerator på 320 x 240 pixel med det komplette sæt timingkredsløb og controllere, der kræves for at konvertere rå billedgeneratordata til dybdeafbildninger. (Billedkilde: ESPROS Photonics)

ESPROS Photonics' EPC660-007 chipholder monterer epc650-billedgeneratoren på et 37,25 x 36,00 mm stort PCB, komplet med afkoblingskondensatorer og kortkantkonnektor. Selvom denne chipholder fungerer som den grundlæggende hardwaregrænseflade i et 3D ToF-systemdesign er udviklere stadig nødt til at udarbejde et passende optisk frontend-design og sørge for behandlingsressourcer til backenden. ESPROS Photonics' epc660-evalueringskit eliminerer disse opgaver ved at stille et komplet 3D ToF-applikationsudviklingsmiljø til rådighed, der omfatter et forhåndsbygget 3D ToF-billedgenereringssystem og den tilknyttede software (figur 4).

Figur 4: ESPROS Photonics' epc660-evalueringskit indeholder et forhåndsbygget 3D ToF-kamerasystem og den tilknyttede software til at bruge dybdeinformation i applikationer. (Billedkilde: ESPROS Photonics)

ESPROS-kittet er designet til evaluering og hurtig prototypeudvikling og indeholder et forhåndssamlet kamerasystem, der kombinerer epc660 CC-chipholderen, et optisk linsemodul og et sæt på otte LED'er. Med til kamerasystemet følger et BeagleBone Black-processorkort med 512 MB RAM og 4 GB flashhukommelse, der fungerer som værtscontroller og applikationsberegningsressource.

ESPROS tilbyder også supportsoftware til epc660-evalueringskittet, der kan downloades fra producentens websted og åbnes med en adgangskode, som brugeren kan anmode om ved at kontakte producentens lokale salgsafdeling. Når de har fået adgang til softwaren, kan udviklere begynde at bruge kamerasystemet ved ganske enkelt at køre en GUI-applikation (graphical user interface, grafisk brugerflade) med en af de medfølgende konfigurationsfilter. GUI-applikationen indeholder også kontrolvinduer til at konfigurere yderligere parametre – inklusive filterindstillinger for rum og tid – og vinduer til at få vist resultaterne. Udviklere kan ganske let bruge kittet til at begynde at optegne dybdeafbildninger i realtid og bruge dem som input til deres egen software.

3D ToF-systemer med højere opløsning

En billedgenerator på 320 x 240 pixel såsom ESPROS epc660 kan bruges til mange formål, men den har muligvis en for lav opløsning til at registrere små bevægelser i grænseflader til styring via bevægelser eller til at skelne mellem små objekter uden at begrænse registreringsområdet markant. Til disse anvendelsesformål kan der med færdigbyggede udviklingskit baseret på 640 x 480 pixel ToF-sensorer hurtigt udvikles prototyper, hvor høj opløsning er et krav.

Seeed Technologys DepthEye Turbo-dybdekamera samler en 640 x 480 pixel ToF-sensor, fire 850-nm VCSEL-dioder (vertical-cavity surface-emitting laser), driftskredsløb til belysning og sensorer, strøm og USB-grænsefladeunderstøttelse i en terningformet løsning på 57 x 57 x 51 mm. Softwareunderstøttelsen findes i form af et open-source libPointCloud SDK github-lager med understøttelse for Linux, Windows, Mac OS og Android.

Ud over C++ drivere, biblioteker og eksempelkode omfatter libPointCloud SDK-distributionen en Python API til hurtig prototyping samt et visualiseringsværktøj. Når de har installeret distributionspakken på deres værtsudviklingsplatform, kan udviklere slutte kameraet til deres computer via USB-forbindelsen og med det samme begynde at bruge visualiseringsværktøjet til at vise fase-, amplitude- eller punktskyafbildninger, der i bund og grund er udvidede dybdeafbildninger gengivet med teksturoverflader for at vise et jævnere 3D-billede (figur 5).

Figur 5: Når den bruges sammen med Seeed Technology DepthEye Turbo-dybdekameraet, gør den tilhørende softwarepakke det let for udviklere at visualisere 3D ToF-data på flere måder, inklusive som punktskyer som vist her i hovedvinduet. (Billedkilde: Seeed Technology/PointCloud.AI)

Analog Devices' AD-96TOF1-EBZ 3D ToF-evalueringskit er et mere åbent hardwaredesign, der er opbygget omkring et kortpar og designet til at bruge Raspberry Pis Raspberry Pi 3 Model B+ eller Raspberry Pi 4 som værtscontroller og lokal beregningsressource (figur 6).

Figur 6: Analog Devices AD-96TOF1-EBZ 3D ToF-evalueringskittet kombinerer et modul bestående af to kort til belysning og dataregistrering med et Raspberry Pi-kort til lokal behandling. (Billedkilde: Analog Devices)

Kittets analoge frontend-kort (AFE) indeholder det optiske modul, CCD-rækken og buffere, firmwarehukommelsen og en processor, der håndterer den overordnede kamerastyring, inklusive belysningstiming, sensorsynkronisering og generering af dybdeafbildninger. Det andet kort rummer fire 850-nm VCSEL-laserdioder og drivere, og det er designet til at forbindes med AFE-kortet, således at laserdioderne omgiver det optiske modul som vist på figuren ovenfor.

Analog Devices understøtter AD-96TOF1-EBZ-kittet i form af sin open-source 3D ToF-softwarepakke bestående af 3D ToF SDK'et samt eksempelkode og wrappere til C/C++, Python og Matlab. For at understøtte både værtsapplikationer og low-level hardwareinteraktioner i et netværksmiljø opdeler Analog Devices SDK'et i en værtspartition optimeret til USB- og netværksforbindelse og en low-level partition, der kører på Embedded Linux og er bygget på en Video4Linux2-driver (V4L2) (figur 7).

Figur 7: Analog Devices 3D ToF SDK API'en understøtter applikationer, der kører på den lokale Embedded Linux-vært og applikationer, der kører eksternt på netværkstilsluttede værter. (Billedkilde: Analog Devices)

Med dette netværksaktiverede SDK kan applikationer, der kører på netværkstilsluttede værter, fungere eksternt med et ToF-hardwaresystem for at få adgang til kameraet og registrere dybdedata. Brugerprogrammer kan også køre i Embedded Linux-partitionen og drage fuld nytte af de avancerede funktioner, der findes på det niveau.

Som en del af softwaredistributionen stiller Analog Devices eksempelkode til rådighed, der demonstrerer centrale driftsfunktioner såsom start af kamera, grundlæggende billedoptagelse, fjernadgang og optagelse på tværs af platforme – på en værtscomputer og lokalt med Embedded Linux. Yderligere applikationseksempler bygger oven på disse grundlæggende handlinger for at illustrere brugen af registrerede data i applikationer på højere niveauer, såsom oprettelse af punktskyer. Et af applikationseksemplerne demonstrerer rent faktisk, hvordan en DNN-inferensmodel (Deep Neural Network) kan bruges til at klassificere data genereret af kamerasystemet. Dette DNN-applikationseksempel er skrevet i Python (dnn.py) og viser hvert trin i processen, der kræves for at hente data og forberede klassifikationen vha. inferensmodellen (post 1).

Copy
import aditofpython as tof
import numpy as np
import cv2 as cv
. . .
    try:
        net = cv.dnn.readNetFromCaffe(args.prototxt, args.weights)
    except:
        print("Error: Please give the correct location of the prototxt and caffemodel")
        sys.exit(1)
    swapRB = False
    classNames = {0: 'background',
                  1: 'aeroplane', 2: 'bicycle', 3: 'bird', 4: 'boat',
                  5: 'bottle', 6: 'bus', 7: 'car', 8: 'cat', 9: 'chair',
                  10: 'cow', 11: 'diningtable', 12: 'dog', 13: 'horse',
                  14: 'motorbike', 15: 'person', 16: 'pottedplant',
                  17: 'sheep', 18: 'sofa', 19: 'train', 20: 'tvmonitor'}
 
    system = tof.System()
    status = system.initialize()
    if not status:
        print("system.initialize() failed with status: ", status)
 
    cameras = []
    status = system.getCameraList(cameras)
. . .
    while True:
        # Capture frame-by-frame
        status = cameras[0].requestFrame(frame)
        if not status:
            print("cameras[0].requestFrame() failed with status: ", status)
 
        depth_map = np.array(frame.getData(tof.FrameDataType.Depth), dtype="uint16", copy=False)
        ir_map = np.array(frame.getData(tof.FrameDataType.IR), dtype="uint16", copy=False)
 
        # Creation of the IR image
        ir_map = ir_map[0: int(ir_map.shape[0] / 2), :]
        ir_map = np.float32(ir_map)
        distance_scale_ir = 255.0 / camera_range
        ir_map = distance_scale_ir * ir_map
        ir_map = np.uint8(ir_map)
        ir_map = cv.cvtColor(ir_map, cv.COLOR_GRAY2RGB)
 
        # Creation of the Depth image
        new_shape = (int(depth_map.shape[0] / 2), depth_map.shape[1])
        depth_map = np.resize(depth_map, new_shape)
        distance_map = depth_map
        depth_map = np.float32(depth_map)
        distance_scale = 255.0 / camera_range
        depth_map = distance_scale * depth_map
        depth_map = np.uint8(depth_map)
        depth_map = cv.applyColorMap(depth_map, cv.COLORMAP_RAINBOW)
 
        # Combine depth and IR for more accurate results
        result = cv.addWeighted(ir_map, 0.4, depth_map, 0.6, 0)
 
        # Start the computations for object detection using DNN
        blob = cv.dnn.blobFromImage(result, inScaleFactor, (inWidth, inHeight), (meanVal, meanVal, meanVal), swapRB)
        net.setInput(blob)
        detections = net.forward()
. . .
        for i in range(detections.shape[2]):
            confidence = detections[0, 0, i, 2]
            if confidence > thr:
                class_id = int(detections[0, 0, i, 1])
. . .
                if class_id in classNames:
                    value_x = int(center[0])
                    value_y = int(center[1])
                    label = classNames[class_id] + ": " + \
                            "{0:.3f}".format(distance_map[value_x, value_y] / 1000.0 * 0.3) + " " + "meters"
. . .
        # Show image with object detection
        cv.namedWindow(WINDOW_NAME, cv.WINDOW_AUTOSIZE)
        cv.imshow(WINDOW_NAME, result)
 
        # Show Depth map
        cv.namedWindow(WINDOW_NAME_DEPTH, cv.WINDOW_AUTOSIZE)
        cv.imshow(WINDOW_NAME_DEPTH, depth_map)

Post 1: Dette uddrag fra et applikationseksempel i Analog Devices 3D ToF SDK-distributionen demonstrerer de få trin, der kræves for at hente dybde- og IR-billeder og klassificere dem med en inferensmodel. (Kodekilde: Analog Devices)

Her begynder processen ved at bruge OpenCV's DNN-metoder (cv.dnn.readNetFromCaffe) til at læse netværket og tilknyttede vægtninger for en eksisterende inferensmodel. I dette tilfælde er modellen en Caffe-implementering af Google MobileNet Single Shot Detector (SSD) registreringsnetværket, der er kendt for at opnå høj nøjagtighed med relativt små modelstørrelser. Efter at have indlæst klassenavnene med de understøttede klasseidentifikatorer og klassemærkater identificerer applikationen de ledige kameraer og eksekverer en række startrutiner (ikke vist i post 1).

Størstedelen af eksempelkoden handler om at forberede dybdeafbildningen (depth_map) og IR-afbildningen (ir_map), inden de kombineres (cv.addWeighted) til en enkelt række for at øge nøjagtigheden. Endelig kalder koden en anden OpenCV DNN-metode (cv.dnn.blobFromImage), der konverterer det kombinerede billede til den firdimensionelle blob-datatype, som kræves til inferens. Den næste kodelinje indstiller den resulterende blob som input til inferensmodellen (net.setInput(blob)). Kaldet net.forward() aktiverer inferensmodellen, der returnerer klassifikationsresultaterne. Resten af applikationseksemplet identificerer klassifikationsresultater, der overstiger en forhåndsdefineret grænseværdi, og genererer for dem en mærkat og afgrænsningsboks, der viser de registrerede billeddata, mærkaten identificeret af inferensmodellen og dens afstand fra kameraet (figur 8).

Figur 8: Med et par linjers Python-kode og OpenCV-biblioteket registrerer DNN-applikationseksemplet i Analog Devices' 3D ToF SDK-distribution dybdebilleder, klassificerer dem og viser det identificerede objekts mærkat og afstand. (Billedkilde: Analog Devices)

Som Analog Devices' DNN-applikationseksempel demonstrerer, kan udviklere bruge 3D ToF-dybdeafbildninger sammen med maskinlæringsmetoder til at oprette mere avancerede applikationsfunktioner. Selvom applikationer, der har brug for svar med lav forsinkelse, sandsynligvis vil bygge disse funktioner med C/C++, er de grundlæggende trin ens.

Ved hjælp af 3D ToF-data og højtydende inferensmodeller kan industrielle robotsystemer på mere sikker vis synkronisere deres bevægelser med andet udstyr eller sågar med mennesker i "cobot"-miljøer, hvor mennesker og robotter arbejder sammen tæt på hinanden. Med forskellige inferensmodeller kan en anden applikation bruge et 3D ToF-kamera med høj opløsning til at klassificere fine bevægelser til en grænseflade til styring via bevægelser. I applikationer til bilindustrien kan denne tilgang hjælpe med at øge nøjagtigheden af avancerede førerhjælpesystemer (ADAS, advanced driver-assistance systems) ved at gøre fuld brug af den høje tids- og rumopløsning i 3D ToF-systemer.

Konklusion

ToF-teknologier spiller en nøglerolle i næsten ethvert system, hvor nøjagtige målinger af afstanden mellem systemet og andre objekter er altafgørende. Blandt ToF-teknologierne kan optisk 3D ToF levere både høj rum- og tidsopløsning, så der skabes bedre adskillelse mellem mindre objekter og mere præcis overvågning af deres relative afstand.

Inden de kunne drage fordel af denne teknologi, har udviklere dog tidligere haft flere udfordringer knyttet til systemernes optiske design, præcisionstiming og synkroniseret signalregistrering. Som vist fjerner færdigbyggede 3D ToF-systemer såsom Analog Devices' AD-96TOF1-EBZ-udviklingsplatform og ESPROS Photonics' EPC660-evalueringskit de stopklodser, der står i vejen for brugen af denne teknologi i industrielle systemer, grænseflader til styring via bevægelser, sikkerhedssystemer i bilbranchen m.m.