Viimeksi päivitetty: maaliskuu 2026

Orbbec Femto Boltin käyttöönotto on suoraviivaista. Tämä kattava kehitysohje kattaa SDK:n asennuksen, ohjelmointiohjeet ja käytännön koodiesimerkit, jotka auttavat sinua rakentamaan tehokkaita 3D-näköjärjestelmiä.

Orbbec Femto Bolt -kehitysohje: täydellinen SDK-asennus ja ohjelmointiohje

Mikä on Orbbec Femto Bolt?

Orbbec Femto Bolt on korkean suorituskyvyn Time of Flight (ToF) -syvyyskamera, joka on kehitetty yhteistyössä Orbbecin ja Microsoftin kanssa, perustuen todistettuun Azure Kinect -syvyysteknologiaan. Tämä kompakti mutta tehokas laite tarjoaa 4K RGB -kuvaa yhdistettynä tarkkaan syvyyden mittaukseen, tehden siitä ihanteellisen valinnan kehittäjille, jotka työskentelevät tekoälyn, robotiikan, lisätyn todellisuuden ja konenäön sovellusten parissa. Femto Boltin erottava piirre on sen API-yhteensopivuus Microsoft Azure Kinect SDK:n kanssa Orbbec SDK K4A Wrapperin kautta, mikä mahdollistaa kehittäjien hyödyntää olemassa olevia Azure Kinect -koodipohjia vähäisillä muutoksilla. Kamera tukee kahta syvyystilaa—laajakulmanäkymää (WFOV) 120 asteen alueen skannaukseen ja kapean näkökentän tilaa (NFOV) 75 astetta tarkkoihin mittauksiin—säilyttäen syvyystarkkuuden alle 11 mm plus 0,1 % mitatusta etäisyydestä. Olitpa rakentamassa autonomisia robotteja, kehittämässä volyymivideon tallennusjärjestelmiä tai luomassa immersiivisiä AR-kokemuksia, Femto Bolt tarjoaa anturitoiminnot ja ohjelmiston joustavuuden, joita tarvitset visiosi toteuttamiseen.

Ymmärtäminen Femto Bolt -laitteen teknisestä arkkitehtuurista

Time of Flight -syvyyden mittausteknologia

Femto Bolt käyttää edistynyttä Time of Flight (ToF) -teknologiaa, joka toimii 850 nm aallonpituudella, huolellisesti valitulla spektrillä, joka tasapainottaa silmäturvallisuusvaatimukset ja optimaalisen anturin herkkyyden. Toisin kuin perinteiset stereonäköjärjestelmät, jotka perustuvat kahden kameran väliseen piirteen sovitukseen, ToF-kamerat mittaavat syvyyden suoraan laskemalla aikaa, joka moduloidun infrapunasäteilyn kulkuun anturista kohtiin kuvassa ja takaisin heijastumiseen kuluu. Tämä aktiivinen valaistusmenetelmä tarjoaa useita merkittäviä etuja: tasainen syvyystarkkuus riippumatta kohtauksen tekstuurista, nopeampi käsittely, koska piirteiden poimintaa ei tarvita, sekä luotettava suorituskyky tasaisilla tai tekstuurittomilla pinnoilla, jotka haastavat stereon sovitusalgoritmeja.

Kameran 1 megapikselin ToF-anturi tallentaa syvyystietoja koko näkökentän alueelta samanaikaisesti, mahdollistaen reaaliaikaisen syvyyskartoituksen jopa 30 kuvataajuudella sekunnissa valitusta tilasta riippuen. 850 nm infrapunasäde sopii erityisen hyvin sisätilasovelluksiin, koska se on ihmisille näkymätön, mutta heijastuu voimakkaasti useimmista yleisistä materiaaleista. Anturin dynaaminen alue mahdollistaa vaihtelevien valaistusolosuhteiden käsittelyn toimintaympäristössään, vaikka suoraa auringonvaloa tulisi välttää, sillä se voi kyllästää detektorielementit ja heikentää mittaustarkkuutta.

Kaksoissyvyystilan toiminta

Femto Boltin monipuolisuus perustuu sen tukeen kahdelle erilliselle syvyystilalle, jotka on optimoitu erilaisiin sovellustilanteisiin. WFOV (laaja näkökenttä) -tila tallentaa syvyystietoja 1024x1024 pikselin resoluutiolla 120 asteen vaakasuoralla ja pystysuoralla näkökentällä, tehden siitä täydellisen ympäristön kartoitukseen, robotiikan navigointiin ahtaissa tiloissa ja laaja-alaisten skannausprojektien toteutukseen. Tämä tila toimii 15 kuvataajuudella sekunnissa ja pystyy havaitsemaan kohteita jopa 5,46 metrin etäisyydeltä, tarjoten kattavan peiton suurille ympäristöille minimaalisilla kameran uudelleensijoituksilla.

NFOV (kapea näkökenttä) -tila uhraa laajuuden tarkkuuden hyväksi, toimiessaan 640x576 resoluutiolla ja 75 asteen vaakasuoralla sekä 65 asteen pystysuoralla näkökentällä, samalla kaksinkertaistaen kuvataajuuden 30 FPS:ään. Tämä tila soveltuu erinomaisesti sovelluksiin, jotka vaativat yksityiskohtaisia mittauksia: laadunvalvontatarkastukset, kohteiden tunnistustehtävät, biometrinen skannaus ja tarkka manipulointi robotiikassa. Korkeampi kuvataajuus hyödyttää myös dynaamisia kohtauksia, joissa kamera tai kohteet liikkuvat, vähentäen liike-epäterävyyttä syvyystiedoissa ja varmistaen tarkemman seurannan.

Integroitu 4K RGB -kamerajärjestelmä

Syvyysmittausominaisuuksiensa lisäksi Femto Bolt sisältää korkean resoluution 4K RGB-kameran, joka kykenee tallentamaan värikuvia jopa 3840x2160 pikselin tarkkuudella. Tämä kamera tarjoaa 80 asteen vaakasuoran ja 51 asteen pystysuoran näkökentän, tarjoten hieman kapeamman peiton kuin syvyyssensorin WFOV-tila, mutta huomattavasti enemmän yksityiskohtia visuaaliseen analyysiin. Kamera tukee laajaa dynaamista aluetta (HDR), mikä mahdollistaa haastavien valaistusolosuhteiden käsittelyn, joissa kirkkaat ja tummat alueet esiintyvät samassa kohtauksessa.

Ehkä tärkeimpänä RGB-kamera suorittaa laitteistotasolla synkronoidun rekisteröinnin syvyystietojen kanssa, varmistaen, että jokaisella värikuvan pikselillä on vastaava syvyysarvo. Tämä tiivis integraatio poistaa tarpeen ohjelmistopohjaiselle kohdistusprosessoinnille ja takaa, että väri- ja syvyystiedot pysyvät täydellisesti synkronoituna jopa nopean kameran liikkeen tai dynaamisten kohtauksien aikana. Automaattiset valotus- ja valkotasapainojärjestelmät toimivat jatkuvasti ylläpitääkseen optimaalista kuvanlaatua vaihtelevissa valaistusolosuhteissa, vaikka manuaaliset säädöt ovat myös käytettävissä sovelluksissa, jotka vaativat tarkkaa värintoistoa.

Inertiaalimittausyksikön integrointi

Integroitu 6-akselinen inertiaalimittausyksikkö (IMU) yhdistää 3-akselisen kiihtyvyysanturin ja 3-akselisen gyroskoopin, tarjoten olennaiset liikkeen mittausominaisuudet, jotka parantavat monia syvyyskamerasovelluksia. Robotiikkaympäristöissä IMU-dataa voidaan yhdistää visuaalisen odometrian algoritmeihin paikannustarkkuuden parantamiseksi ja seurannan jatkuvuuden ylläpitämiseksi lyhyiden kameran peittymisten aikana. Lisätyn todellisuuden sovelluksissa IMU auttaa seuraamaan laitteen suuntaa ja liikettä, mikä edistää vakaata päällekkäisrekisteröintiä käyttäjän näkymässä.

IMU-data virtaa noin 1,6 kHz taajuudella, tarjoten korkeataajuisia liikepäivityksiä, jotka täydentävät 15–30 FPS syvyys- ja värikehyksiä. IMU:n aikaleimat synkronoidaan kamerakehysten kanssa, mahdollistaen tarkan datan yhdistämisen sovelluksissasi. Tämä visuaalisen syvyysmittauksen ja inertiaalimittausten yhdistelmä luo vahvan pohjan SLAM:lle (samanaikainen paikannus ja kartoitus), eleentunnistukselle, tärinän havaitsemiselle ja kaikille sovelluksille, jotka vaativat tietoisuutta sekä visuaalisesta ympäristöstä että laitteen liikkeestä.

Kehitysympäristön asennus

Windows-kehitysympäristön määritys

Femto Boltin sovelluskehitys Windowsilla vaatii Visual Studio 2019:n tai uudemman asentamisen C++-kehitystyökaluineen sekä Orbbec SDK K4A Wrapperin, joka tarjoaa API-yhteensopivuuden Azure Kinect -sovellusten kanssa. Aloita asentamalla Visual Studio "Työpöytäsovelluskehitys C++:lla" -työkuormalla, varmistaen, että Windows 10 SDK -komponentit sisältyvät. Lataa seuraavaksi uusin Orbbec SDK K4A Wrapper -julkaisu virallisesta GitHub-repositorysta, valiten Windowsille valmiiksi käännetyt binäärit välttääksesi käännösaikaa.

Ennen kameran käyttöä sinun on suoritettava UVC-metatietojen rekisteröintiskripti, joka mahdollistaa oikean viestinnän Windowsin ja USB-liitetyn syvyyskameran välillä. Avaa PowerShell järjestelmänvalvojana ja siirry SDK:n skriptikansioon, sitten suorita asennuskomento:

cd src/orbbec/OrbbecSDK/misc/scripts
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
.\obsensor_metadata_win10.ps1 -op install_all

Tämä skripti rekisteröi kameran USB Video Class -metatietokyvyt Windowsissa, mahdollistaen aikaleimojen ja muiden metatietojen käytön, jotka ovat välttämättömiä syvyyskameran oikealle toiminnalle. Ilman tätä vaihetta saatat kohdata ongelmia, joissa laite tunnistetaan, mutta syvyyskehyksiä ei ole saatavilla tai aikaleimat ovat virheellisiä.

Linux-kehitysympäristön konfigurointi

Linux-kehitykseen vaaditaan lukuisia rakennusriippuvuuksia ennen SDK:n kääntämistä tai käyttämistä. Seuraava komento asentaa kaikki tarvittavat paketit Ubuntu-pohjaisissa jakeluissa:

sudo apt update
sudo apt install -y \
    pkg-config \
    ninja-build \
    doxygen \
    clang \
    gcc-multilib \
    g++-multilib \
    python3 \
    nasm \
    libgl1-mesa-dev \
    libsoundio-dev \
    libvulkan-dev \
    libx11-dev \
    libxcursor-dev \
    libxinerama-dev \
    libxrandr-dev \
    libusb-1.0-0-dev \
    libssl-dev \
    libudev-dev \
    mesa-common-dev \
    uuid-dev

Riippuvuuksien asentamisen jälkeen sinun täytyy konfiguroida udev-säännöt, jotta kameraan pääsee käsiksi ilman pääkäyttäjän oikeuksia. SDK sisältää asennusskriptin, joka luo tarvittavat laiteoikeudet:

cd src/orbbec/OrbbecSDK/misc/scripts
sudo chmod +x ./install_udev_rules.sh
sudo ./install_udev_rules.sh

Tämä udev-konfiguraatio varmistaa, että kuka tahansa video-ryhmän jäsen voi käyttää Femto Boltia ilman pääkäyttäjän oikeuksia. Kun olet lisännyt itsesi video-ryhmään komennolla sudo usermod -a -G video $USER ja kirjautumalla ulos ja takaisin sisään, voit käyttää kameraa tavallisena käyttäjänä.

Rakentaaksesi SDK:n lähdekoodista, kloonaa repositorio ja sen alikokoelmat, sitten konfiguroi ja käännä:

git clone https://github.com/orbbec/OrbbecSDK-K4A-Wrapper.git
cd OrbbecSDK-K4A-Wrapper
git submodule update --init --recursive
mkdir build && cd build
cmake .. -G Ninja
ninja
sudo ninja install

NVIDIA Jetson sulautetun alustan asennus

Femto Bolt on täysin yhteensopiva NVIDIA Jetson -alustojen kanssa, mukaan lukien AGX Orin, Orin NX, Orin Nano, AGX Xavier ja Xavier NX, mahdollistaen reunalaskennan tekoälysovellukset, jotka vaativat paikallista käsittelyä ilman pilviyhteyttä. Aloita lataamalla Jetson-laitteeseesi uusin JetPack SDK NVIDIA:lta ja varmista, että valitset laitteistollesi sopivan JetPack-version.

Yllä kuvattu Linuxin asennusprosessi koskee Jetson-laitteita, jotka käyttävät Ubuntu-pohjaisia L4T (Linux for Tegra) -jakeluja. CMake-rakennusjärjestelmä tunnistaa automaattisesti ARM64-arkkitehtuurin ja kääntää sopivat binäärit. Parhaan suorituskyvyn varmistamiseksi varmista, että Jetson toimii maksimisuorituskykymoodissa:

sudo nvpmodel -m 0
sudo jetson_clocks

Nämä komennot ottavat kaikki suorittimen ytimet käyttöön maksimitaajuudella ja konfiguroivat GPU:n kestävään suorituskykyyn. Kun integroit CUDA-sovelluksiin, muista, että Jetsonin GPU:ta voi käyttää nopeutettuun syvyyskäsittelyyn, pistepilvien generointiin ja tekoälyn päättelytehtäviin.

Ohjelmistokehityspaketin syväluotaus

K4A Wrapper -arkkitehtuurin ymmärtäminen

Orbbec SDK:n K4A Wrapper on elegantti ratkaisu kehittäjille, jotka haluavat hyödyntää olemassa olevia Azure Kinect -ekosysteemejä ja samalla saada Orbbecin kustannustehokkaan laitteiston edut. Tämä wrapper kääntää jokaisen kutsun Azure Kinect Sensor SDK API:ssa vastaaviksi Orbbec SDK:n funktioiksi sisäisesti, luoden saumattoman yhteensopivuuskerroksen, joka yleensä ei vaadi koodimuutoksia kirjastotiedoston vaihdon lisäksi. Wrapper on rakennettu Azure Kinect Sensor SDK v1.4.1:n päälle, varmistaen API:n vakauden ja kattavan ominaisuustuen.

Kun sovelluksesi kutsuu funktioita kuten k4a_device_open() tai k4a_device_start_cameras(), wrapper sieppaa nämä kutsut ja ohjaa ne asianmukaiseen Orbbec SDK:n toteutukseen. Tämä käännös tapahtuu läpinäkyvästi, jolloin olemassa olevat Azure Kinect -koodikannat toimivat Femto Bolt -laitteistolla vähäisellä kitkalla. Wrapper tukee sekä Orbbec SDK:n päähaaraa (v1) että v2-päähaaraa (v2), tarjoten joustavuutta valita vakaa tai huippuluokan toteutus.

Laitetuki vaihtelee laiteohjelmistoversion mukaan, ja SDK asettaa vähimmäisvaatimukset oikean toiminnan varmistamiseksi. Femto Bolt vaatii vähintään laiteohjelmistoversion 1.1.2, ja versio 1.1.2 on suositeltu optimaaliseen yhteensopivuuteen. Voit tarkistaa laitteesi laiteohjelmistoversion SDK:n laiteluettelofunktioilla tai mukana tulevilla katseluohjelmilla.

API-yhteensopivuus ja erot

Vaikka K4A Wrapper tarjoaa laajan API-yhteensopivuuden, kehittäjien tulisi olla tietoisia useista eroista alkuperäiseen Azure Kinect SDK:hon verrattuna. Merkittävin ero on tallennuksen aikaleiman offset-kentän tyyppi: Orbbec SDK käyttää uint64_t start_timestamp_offset_usec kun taas Azure Kinect käyttää uint32_t start_timestamp_offset_usec. Sovellukset, jotka käyttävät tätä kenttää eksplisiittisesti, tarvitsevat otsikkotiedoston korvaamisen tai ehdollisen käännöksen.

Useita Azure Kinect -rajapintoja ei ole toteutettu K4A Wrapperissa, vaikka niitä harvoin tarvitaan useimmissa sovelluksissa:

• Mukautetut muistinvaraajafunktiot (k4a_set_allocator())
• Lämpötilan lukeminen ja asetusfunktiot
• Manuaaliset valotus-, valkotasapaino- ja ISO-herkkyyden säädöt kuvatason tasolla
• Synkkauskaapelin liitännän tilan tunnistus

Suurimmassa osassa syvyyskamera-sovelluksia nämä toteuttamattomat funktiot eivät vaikuta toiminnallisuuteen. Jos kuitenkin siirrät erikoistunutta Azure Kinect -koodia, joka luottaa näihin ominaisuuksiin, sinun täytyy toteuttaa vaihtoehtoisia ratkaisuja tai hyväksyä toiminnallisuuden rajoittuminen.

Python-kehitys pyk4an kanssa

Python-kehittäjät voivat hyödyntää Femto Boltia pyk4a-kirjaston kautta, joka tarjoaa Python-tyylisen rajapinnan taustalla olevaan Azure Kinect -yhteensopivaan APIin. Asenna paketti pipillä:

pip install pyk4a

pyk4a-kirjasto yksinkertaistaa kameran alustuksen ja kuvakehysten kaappauksen intuitiivisiksi metodikutsuiksi. Tässä on perusesimerkki, joka kaappaa synkronoidut syvyys- ja väri-kuvakehykset:

from pyk4a import PyK4A, Config, ColorResolution, DepthMode

# Konfiguroi kameran asetukset
config = Config(
    color_resolution=ColorResolution.RES_720P,
    depth_mode=DepthMode.NFOV_UNBINNED,
    camera_fps=30,
    synchronized_images_only=True
)

# Alusta ja käynnistä kamera
k4a = PyK4A(config=config)
k4a.start()

try:
    # Kaappaa 100 kehystä
    for frame_count in range(100):
        capture = k4a.get_capture()

        # Pääsy syvyyskuvaan numpy-taulukkona
        depth = capture.depth
        print(f"Syvyyskehys {frame_count}: {depth.shape}")

        # Pääsy värikuvaan
        color = capture.color
        print(f"Värikehys {frame_count}: {color.shape}")

        # Pääsy IR-kuvaan, jos saatavilla
        if capture.ir is not None:
            print(f"IR-kehys: {capture.ir.shape}")

finally:
    k4a.stop()

Pyk4a-kirjasto palauttaa syvyys- ja värikuvat numpy-taulukkoina, mikä tekee niiden integroinnista OpenCV:n, NumPy-pohjaisten käsittelyputkien ja koneoppimiskehysten kanssa vaivatonta. Kirjasto tukee myös laitteiston synkronoinnin konfigurointia monikamerajärjestelmiä varten ja tarjoaa kätevän pääsyn IMU-dataan.

Vaihtoehtoiset Python-kääreet

Pyk4an lisäksi Python-kehittäjillä on muita vaihtoehtoja Femto Bolt -datan käyttöön. Virallinen azure-kinect-python paketti tarjoaa suorat sidokset Azure Kinect SDK:hin, tarjoten ominaisuuksiltaan vastaavuuden C++ API:n kanssa sovelluksille, jotka vaativat täydellistä hallintaa:

pip install azure-kinect-python

Tämä paketti noudattaa C++ API -rakennetta läheisemmin kuin pyk4a, mikä voi olla suositeltavaa kehittäjille, jotka siirtyvät C++-kehityksestä tai tarvitsevat tiettyjä SDK-ominaisuuksia, joita pyk4an kätevä käyttöliittymä ei tarjoa.

3D-visualisointiin ja -käsittelyyn Open3D tarjoaa tehokkaita työkaluja, jotka integroituvat hyvin syvyyskameran dataan:

pip install open3d

Open3D voi lukea Femto Bolt -syvyyskuvia ja muuntaa ne automaattisesti värillisiksi pistepilviksi, suorittaa rekisteröinnin useiden syvyyskuvausten välillä ja tarjota interaktiivisia visualisointityökaluja. Kirjaston tietorakenteet on optimoitu miljoonien pisteiden tehokkaaseen käsittelyyn, mikä tekee siitä sopivan 3D-rekonstruktio- ja kartoitussovelluksiin.

Keskeiset ohjelmointikäsitteet ja esimerkit

Laitteen alustaminen ja konfigurointi

Minkä tahansa Femto Bolt -sovelluksen perusta on laitteen asianmukainen alustaminen ja kameran konfigurointi. SDK käyttää konfigurointirakennetta, joka ohjaa kaikkia kameran parametreja ennen kuvausputken käynnistämistä. Jokaisen konfigurointivaihtoehdon ymmärtäminen mahdollistaa kameran optimoinnin juuri sinun sovelluksesi vaatimuksiin.

Konfigurointirakenne sisältää asetukset värin resoluutiolle, syvyystilalle, kuvataajuudelle, synkronoidulle kuvanotolle, syvyysviiveelle, väriviiveelle, langalliselle synkronointitilalle ja alisteiselle viiveen siirrolle. Näin voit konfiguroida kameran tyypilliseen käyttötarkoitukseen:

#include <k4a/k4a.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    // Hae liitettyjen laitteiden määrä
    uint32_t device_count = k4a_device_get_installed_count();
    if (device_count == 0) {
        printf("Azure Kinect -laitteita ei löytynyt!\n");
        return 1;
    }

    // Avaa oletuslaite
    k4a_device_t device = NULL;
    if (k4a_device_open(K4A_DEVICE_DEFAULT, &device) != K4A_RESULT_SUCCEEDED) {
        printf("Laitteen avaaminen epäonnistui\n");
        return 1;
    }

    // Määritä kameran parametrit
    k4a_device_configuration_t config = K4A_DEVICE_CONFIG_INIT_DISABLE_ALL;

    // Ota käyttöön syvyyskamera
    config.depth_mode = K4A_DEPTH_MODE_NFOV_UNBINNED;
    config.camera_fps = K4A_FRAMES_PER_SECOND_30;

    // Ota käyttöön värikamera 720p-resoluutiolla
    config.color_resolution = K4A_COLOR_RESOLUTION_720P;
    config.color_format = K4A_IMAGE_FORMAT_COLOR_BGRA32;

    // Ota käyttöön synkronoitu kaappaus
    config.synchronized_images_only = true;

    // Aseta syvyys-väri-viive kohdistusta varten
    config.depth_delay_off_color_usec = 0;

    // Määritä langallinen synkronointi (itsenäinen tila)
    config.wired_sync_mode = K4A_WIRED_SYNC_MODE_STANDALONE;

    // Käynnistä kamerat
    if (k4a_device_start_cameras(device, &config) != K4A_RESULT_SUCCEEDED) {
        printf("Kameran käynnistys epäonnistui\n");
        k4a_device_close(device);
        return 1;
    }

    printf("Kamera käynnistetty onnistuneesti\n");
    printf("Syvyystila: %d\n", config.depth_mode);
    printf("Värin resoluutio: %d\n", config.color_resolution);
    printf("Kehysnopeus: %d FPS\n", config.camera_fps);

    // ... kehyksen kaappauskoodi tulisi tähän ...

    // Siivous
    k4a_device_stop_cameras(device);
    k4a_device_close(device);

    return 0;
}

The K4A_DEVICE_CONFIG_INIT_DISABLE_ALL makro alustaa konfiguraatiorakenteen kaikilla kameroilla pois päältä, jolloin voit valita vain sovelluksesi tarvitsemat kamerat. Tämä selkeä lähestymistapa estää odottamattomien oletusten vaikuttamisen sovelluksesi toimintaan.

Kehyksen kaappaus ja käsittely

Kehysten kaappaaminen Femto Boltilla tarkoittaa laitteen pyytämistä ottamaan kuvia ja haluttujen kuvatyyppien erottamista. SDK käyttää odotuspohjaista lähestymistapaa, jossa sovelluksesi estyy, kunnes täydellinen kehys on saatavilla, varmistaen synkronoidun datan toimituksen. Tässä on kattava esimerkki oikeasta kehyksen käsittelystä:

#include <k4a/k4a.h>
#include <stdio.h>
#include <stdlib.h>

void process_depth_image(k4a_image_t depth_image) {
    if (depth_image == NULL) {
        return;
    }

    // Hae kuvan ominaisuudet
    int width = k4a_image_get_width_pixels(depth_image);
    int height = k4a_image_get_height_pixels(depth_image);
    int stride = k4a_image_get_stride_bytes(depth_image);
    uint8_t* buffer = k4a_image_get_buffer(depth_image);

    // Hae aikaleima
    uint64_t timestamp = k4a_image_get_timestamp_usec(depth_image);
    printf("Syvyyskehys ajassa %llu us: %dx%d (stride=%d)\n", 
           (unsigned long long)timestamp, width, height, stride);

    // Pääsy raaka-syvyysarvoihin (16-bittiset allekirjoittamattomat kokonaisluvut)
    uint16_t* depth_data = (uint16_t*)buffer;

    // Esimerkki: Etsi kehyksen pienin syvyysarvo
    uint16_t min_depth = UINT16_MAX;
    for (int i = 0; i < width * height; i++) {
        uint16_t depth_value = depth_data[i];
        if (depth_value != 0 && depth_value < min_depth) {
            min_depth = depth_value;
        }
    }

    // Muunna millimetreiksi (syvyys on mm)
    printf("Kehyksen pienin syvyys: %.2f metriä\n", min_depth / 1000.0f);
}

void process_color_image(k4a_image_t color_image) {
    if (color_image == NULL) {
        return;
    }

    int width = k4a_image_get_width_pixels(color_image);
    int height = k4a_image_get_height_pixels(color_image);
    int stride = k4a_image_get_stride_bytes(color_image);
    k4a_image_format_t format = k4a_image_get_format(color_image);

    printf("Värikehys: %dx%d (formaatti=%d, stride=%d)\n", 
           width, height, format, stride);
}

int main() {
    k4a_device_t device = NULL;
    k4a_device_open(K4A_DEVICE_DEFAULT, &device);

    k4a_device_configuration_t config = K4A_DEVICE_CONFIG_INIT_DISABLE_ALL;
    config.depth_mode = K4A_DEPTH_MODE_WFOV_UNBINNED;
    config.color_resolution = K4A_COLOR_RESOLUTION_1080P;
    config.camera_fps = K4A_FRAMES_PER_SECOND_15;
    config.synchronized_images_only = true;

    k4a_device_start_cameras(device, &config);

    // Kaappaa 100 kehystä
    for (int frame_index = 0; frame_index < 100; frame_index++) {
        // Odota kaappausta (aikakatkaisu 1000 ms:n jälkeen)
        k4a_capture_t capture = NULL;
        k4a_wait_result_t result = k4a_device_get_capture(device, &capture, 1000);

        if (result == K4A_WAIT_RESULT_SUCCEEDED) {
            // Poimi ja käsittele syvyyskuva
            k4a_image_t depth_image = k4a_capture_get_depth_image(capture);
            process_depth_image(depth_image);
            if (depth_image != NULL) {
                k4a_image_release(depth_image);
            }

            // Poimi ja käsittele väri-kuva
            k4a_image_t color_image = k4a_capture_get_color_image(capture);
            process_color_image(color_image);
            if (color_image != NULL) {
                k4a_image_release(color_image);
            }

            // Vapauta kaappaus käytön jälkeen
            k4a_capture_release(capture);
        }
        else if (result == K4A_WAIT_RESULT_TIMEOUT) {
            printf("Aikakatkaisu odotettaessa kaappausta\n");
        }
        else {
            printf("Kaappauksen hakeminen epäonnistui\n");
            break;
        }
    }

    k4a_device_stop_cameras(device);
    k4a_device_close(device);

    return 0;
}

Kaappausobjekti sisältää viitteet kaikkiin synkronoituun kuviin (syvyys, väri, IR ja valinnaisesti muunnetut versiot). Vapauta aina kaappaukset ja kuvat käytön jälkeen muistivuotojen estämiseksi. SDK hallinnoi sisäisiä puskureita ja käyttää niitä uudelleen kehyksissä tehokkuuden parantamiseksi.

Pistepilven luonti

Yksi Femto Boltin tehokkaimmista ominaisuuksista on 3D-pistepilvien luominen muuntamalla syvystiedot avaruudellisiksi koordinaateiksi. SDK sisältää sisäänrakennetut funktiot tähän muunnokseen, jotka käsittelevät kameran sisäisen kalibroinnin automaattisesti:

#include <k4a/k4a.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// Rakenne 3D-pisteen tallentamiseen
typedef struct {
    float x, y, z;
    uint8_t r, g, b;
} PointXYZRGB;

void generate_point_cloud(k4a_image_t depth_image, 
                         k4a_image_t color_image,
                         PointXYZRGB** points_out,
                         int* point_count_out) {
    // Hae syvyyskuvan ominaisuudet
    int depth_width = k4a_image_get_width_pixels(depth_image);
    int depth_height = k4a_image_get_height_pixels(depth_image);
    uint8_t* depth_buffer = k4a_image_get_buffer(depth_image);

    // Hae väri-kuvan ominaisuudet
    int color_width = 0, color_height = 0;
    uint8_t* color_buffer = NULL;
    if (color_image != NULL) {
        color_width = k4a_image_get_width_pixels(color_image);
        color_height = k4a_image_get_height_pixels(color_image);
        color_buffer = k4a_image_get_buffer(color_image);
    }

    // Hae kalibrointi muunnosta varten
    k4a_calibration_t calibration;
    // (Oletetaan, että laitteen kalibrointi on jo haettu)

    // Luo muunnoskahva
    k4a_transformation_t transformation = k4a_transformation_create(&calibration);

    // Luo muunnettu syvyyskuva (kohdistettu väriin)
    k4a_image_t transformed_depth = NULL;
    k4a_image_create(K4A_IMAGE_FORMAT_DEPTH16, 
                     color_width, color_height,
                     color_width * (int)sizeof(uint16_t),
                     &transformed_depth);

    k4a_transformation_depth_image_to_color_camera(transformation,
                                                    depth_image,
                                                    transformed_depth);

    // Varaa pistepilvi-taulukko
    int max_points = color_width * color_height;
    PointXYZRGB* points = (PointXYZRGB*)malloc(sizeof(PointXYZRGB) * max_points);
    int point_count = 0;

    // Hae muunnettu syvyysvälimuisti
    uint16_t* transformed_depth_data = (uint16_t*)k4a_image_get_buffer(transformed_depth);

    // Luo XYZ-koordinaatit
    float* xyz_buffer = (float*)malloc(color_width * color_height * 3 * sizeof(float));
    k4a_transformation_color_camera_to_world_point(transformation,
                                                     &calibration,
                                                     depth_image,
                                                     color_width * color_height,
                                                     (const k4a_float2_t*)color_buffer,
                                                     xyz_buffer);

    // Käy läpi jokainen pikseli
    for (int i = 0; i < color_width * color_height; i++) {
        uint16_t depth = transformed_depth_data[i];

        if (depth > 0 && depth < 65535) {
            points[point_count].x = xyz_buffer[i * 3];
            points[point_count].y = xyz_buffer[i * 3 + 1];
            points[point_count].z = xyz_buffer[i * 3 + 2] / 1000.0f; // mm metreiksi

            // Lisää väri, jos saatavilla
            if (color_buffer != NULL) {
                // Oletetaan BGRA-muoto
                points[point_count].b = color_buffer[i * 4];
                points[point_count].g = color_buffer[i * 4 + 1];
                points[point_count].r = color_buffer[i * 4 + 2];
            }

            point_count++;
        }
    }

    *points_out = points;
    *point_count_out = point_count;

    // Siivous
    free(xyz_buffer);
    k4a_image_release(transformed_depth);
    k4a_transformation_destroy(transformation);
}

Tämä esimerkki havainnollistaa pistepilven luomisen ydinkonseptia: 2D-syvyyskuvapikselien muuntamista 3D-koordinaateiksi kameran sisäisten kalibrointiparametrien avulla. Muunnos kohdistaa myös syvyysdatan väri­kameran näkökulmaan, mahdollistaen värilliset pistepilvet, joissa jokaisella 3D-pisteellä on siihen liittyvä RGB-arvo.

IMU-datan käyttö

IMU tarjoaa korkeataajuista liikedataa, joka voi parantaa seurannan tarkkuutta ja mahdollistaa eleentunnistussovellukset. IMU-datan käyttö vaatii erillisen suoratoistomekanismin kamerakehyksistä:

#include <k4a/k4a.h>
#include <stdio.h>
#include <stdlib.h>

void process_imu_sample(k4a_imu_sample_t* sample) {
    printf("IMU-näyte:\n");
    printf("  Kiihtyvyys: x=%.4f, y=%.4f, z=%.4f (m/s²)\n",
           sample->acc_sample.x, sample->acc_sample.y, sample->acc_sample.z);
    printf("  Gyro:  x=%.4f, y=%.4f, z=%.4f (rad/s)\n",
           sample->gyro_sample.x, sample->gyro_sample.y, sample->gyro_sample.z);
    printf("  Aikaleima: %.3f s\n", sample->acc_timestamp_usec / 1000000.0);
    printf("  Lämpötila: %.2f °C\n", sample->temperature);
}

int main() {
    k4a_device_t device = NULL;
    k4a_device_open(K4A_DEVICE_DEFAULT, &device);

    // Käynnistä IMU-suoratoisto (täytyy käynnistää ennen kameroita oikean synkronoinnin varmistamiseksi)
    if (k4a_device_start_imu(device) != K4A_RESULT_SUCCEEDED) {
        printf("IMU:n käynnistäminen epäonnistui\n");
        k4a_device_close(device);
        return 1;
    }

    k4a_device_configuration_t config = K4A_DEVICE_CONFIG_INIT_DISABLE_ALL;
    config.depth_mode = K4A_DEPTH_MODE_NFOV_UNBINNED;
    k4a_device_start_cameras(device, &config);

    // Kerää IMU-näytteitä 10 sekunnin ajan
    for (int i = 0; i < 1000; i++) {
        k4a_imu_sample_t sample;
        k4a_wait_result_t result = k4a_device_get_imu_sample(device, &sample, 100);

        if (result == K4A_WAIT_RESULT_SUCCEEDED) {
            process_imu_sample(&sample);
        }
    }

    k4a_device_stop_imu(device);
    k4a_device_stop_cameras(device);
    k4a_device_close(device);

    return 0;
}

IMU lähettää dataa noin 1,6 kHz taajuudella, tarjoten liikepäivityksiä paljon useammin kuin kameran kehykset. Tämä korkean taajuuden data on arvokasta kameran asennon suodatuksessa kehysten välillä, nopeiden liikkeiden havaitsemisessa ja integroituna laajennettuihin Kalman-suodattimiin luotettavaa seurantaa varten.

Monikamerainen synkronointi

Langallisen synkronoinnin asetukset

Sovelluksissa, jotka vaativat useita Femto Bolt -kameroita—kuten tilavuustallennusjärjestelmät, 360 asteen skannaus tai laajennetun näkökentän kuvantaminen—SDK tukee langallista synkronointia kameran synkronointiliittimen kautta. Tämä mahdollistaa useiden kameroiden samanaikaisen tallennuksen alle millisekunnin tarkkuudella.

Yksi kamera toimii pääkamerana, kun taas muut toimivat alisteisina (orjina). Pääkamera tuottaa synkronointisignaalin, joka laukaisee kaikkien alisteisten kameroiden tallennuksen samanaikaisesti. Yhdistä kamerat 3,5 mm TRS-kaapeleilla synkronointiliittimien välillä:

#include <k4a/k4a.h>
#include <stdio.h>

void configure_master(k4a_device_t device) {
    k4a_device_configuration_t config = K4A_DEVICE_CONFIG_INIT_DISABLE_ALL;
    config.depth_mode = K4A_DEPTH_MODE_WFOV_UNBINNED;
    config.camera_fps = K4A_FRAMES_PER_SECOND_15;
    config.wired_sync_mode = K4A_WIRED_SYNC_MODE_MASTER;
    config.subordinate_delay_off_master_usec = 0;

    k4a_device_start_cameras(device, &config);
    printf("Kamera asetettu pääkameraksi (MASTER)\n");
}

void configure_subordinate(k4a_device_t device) {
    k4a_device_configuration_t config = K4A_DEVICE_CONFIG_INIT_DISABLE_ALL;
    config.depth_mode = K4A_DEPTH_MODE_WFOV_UNBINNED;
    config.camera_fps = K4A_FRAMES_PER_SECOND_15;
    config.wired_sync_mode = K4A_WIRED_SYNC_MODE_SUBORDINATE;

    // Viive master-laukaisun jälkeen ennen tallennusta
    // Säädä kaapelin pituuden ja kokoonpanon mukaan
    config.subordinate_delay_off_master_usec = 0;

    k4a_device_start_cameras(device, &config);
    printf("Kamera asetettu alisteiseksi (SUBORDINATE)\n");
}

int main() {
    // Avaa ensimmäinen kamera (master)
    k4a_device_t master = NULL;
    k4a_device_open(0, &master);

    // Avaa toinen kamera (subordinate)
    k4a_device_t subordinate = NULL;
    k4a_device_open(1, &subordinate);

    configure_master(master);
    configure_subordinate(subordinate);

    // Nyt molemmat kamerat tallentavat synkronoidut kehykset
    // Master laukaisee tallennuksen, subordinate tallentaa viiveen jälkeen

    // Siivous
    k4a_device_stop_cameras(master);
    k4a_device_stop_cameras(subordinate);
    k4a_device_close(master);
    k4a_device_close(subordinate);

    return 0;
}

Alisteinen viiveparametri kompensoi synkronointikaapelin signaalin kulkuviiveitä. Useimmissa asennuksissa, joissa kaapelit ovat lyhyitä, nollaviive toimii hyvin, mutta suuremmissa kokoonpanoissa tämän arvon säätäminen voi olla tarpeen tarkan synkronoinnin saavuttamiseksi.

Ulkoisen laukaisun synkronointi

Femto Bolt tukee myös ulkoista laukaisutilaa, jossa ulkoinen signaali käynnistää kehyksen tallennuksen. Tämä on välttämätöntä teollisissa sovelluksissa, jotka vaativat synkronointia muiden laitteiden, salamalaitteiden tai tarkasti ajoitettujen tallennusjaksojen kanssa:

#include <k4a/k4a.h>
#include <stdio.h>

void configure_external_trigger(k4a_device_t device) {
    k4a_device_configuration_t config = K4A_DEVICE_CONFIG_INIT_DISABLE_ALL;
    config.depth_mode = K4A_DEPTH_MODE_NFOV_UNBINNED;
    config.camera_fps = K4A_FRAMES_PER_SECOND_30;

    // Määritä ulkoisen laukaisimen tila
    config.wired_sync_mode = K4A_WIRED_SYNC_MODE_SUBORDINATE;
    config.external_sync_mode = true;

    // Ulkoinen laukaisin odottaa nousevaa reunaa kaappauksen laukaisemiseksi
    config.subordinate_delay_off_master_usec = 0;

    k4a_device_start_cameras(device, &config);
    printf("Kamera asetettu ULKOISEN LAUKAISIMEN tilaan\n");
    printf("Odotetaan ulkoista laukaisusignaalia...\n");
}

int main() {
    k4a_device_t device = NULL;
    k4a_device_open(K4A_DEVICE_DEFAULT, &device);

    configure_external_trigger(device);

    // Kaappaa kehyksiä laukaisimen aktivoituessa
    for (int i = 0; i < 10; i++) {
        k4a_capture_t capture = NULL;

        // Odota laukaisinta enintään 2 sekuntia
        k4a_wait_result_t result = k4a_device_get_capture(device, &capture, 2000);

        if (result == K4A_WAIT_RESULT_SUCCEEDED) {
            printf("Kaapattu kehys %d\n", i);
            k4a_capture_release(capture);
        }
    }

    k4a_device_stop_cameras(device);
    k4a_device_close(device);

    return 0;
}

Ulkoisen laukaisimen tila vaatii oikein muotoillun laukaisusignaalin synkronointiliittimessä. Kamera odottaa 3,3 V logiikkasignaalia, jonka pulssin minimileveys on määritelty. Tarkat sähkövaatimukset löytyvät laitteiston dokumentaatiosta.

Tallennus ja toisto

MKV-tallennustoiminnallisuus

SDK tukee kameradatan tallentamista MKV (Matroska Video) -tiedostoihin myöhempää analyysiä, käsittelyä tai toistoa varten. Tallenteet sisältävät kaikki synkronoidut virrat (syvyys, väri, IR ja IMU) täydellisine metatietoineen, mahdollistaen tallennussession täydellisen rekonstruoinnin:

#include <k4a/k4a.h>
#include <stdio.h>
#include <string.h>

int main() {
    k4a_device_t device = NULL;
    k4a_device_open(K4A_DEVICE_DEFAULT, &device);

    k4a_device_configuration_t config = K4A_DEVICE_CONFIG_INIT_DISABLE_ALL;
    config.depth_mode = K4A_DEPTH_MODE_NFOV_UNBINNED;
    config.color_resolution = K4A_COLOR_RESOLUTION_720P;
    config.camera_fps = K4A_FRAMES_PER_SECOND_30;
    config.synchronized_images_only = true;

    // Luo tallennusasetukset
    k4a_recording_t recording = NULL;
    k4a_recording_configuration_t record_config = {
        .format = K4A_RECORDING_FORMAT_MKV,
        .segment_size = 0,  // 0 = ei segmentointia
    };

    // Aloita tallennus tiedostoon
    const char* filename = "capture_session_001.mkv";
    if (k4a_device_start_recording(device, &record_config, filename) != K4A_RESULT_SUCCEEDED) {
        printf("Tallennuksen aloittaminen epäonnistui\n");
        k4a_device_close(device);
        return 1;
    }

    printf("Tallennetaan tiedostoon %s\n", filename);

    // Tallenna 60 sekunnin ajan
    for (int frame = 0; frame < 1800; frame++) {  // 30 fps * 60 sekuntia
        k4a_capture_t capture = NULL;
        k4a_wait_result_t result = k4a_device_get_capture(device, &capture, K4A_WAIT_INFINITE);

        if (result == K4A_RESULT_SUCCEEDED) {
            // Kaappaus lisätään automaattisesti tallennukseen
            k4a_capture_release(capture);

            if (frame % 30 == 0) {
                printf("Tallennettu %d kehystä\n", frame);
            }
        }
    }

    // Lopeta tallennus
    k4a_device_stop_recording(device);
    printf("Tallennus valmis. Tiedosto tallennettu.\n");

    k4a_device_stop_cameras(device);
    k4a_device_close(device);

    return 0;
}

Tallenteet sisältävät automaattisesti kaiken kalibrointidatan, mikä varmistaa toiston täydellisen spatiaalisen tarkkuuden. MKV-muoto on laajasti tuettu ja sitä voidaan käsitellä tavallisilla video-ohjelmilla tai SDK:n toistotoiminnoilla.

Toisto ja tietojen poiminta

Tallennettujen tiedostojen toisto on suoraviivaista SDK:n toisto-API:n avulla:

```cpp

include

include

int main() { k4a_playback_t playback = NULL;

// Avaa tallennetiedosto
if (k4a_playback_open("capture_session_001.mkv", &playback) != K4A_RESULT_SUCCEEDED) {
    printf("Tallenteen avaaminen epäonnistui\n");
    return 1;
}

// Hae tallenteen ominaisuudet
k4a_record_configuration_t record_config;
k4a_playback_get_record_configuration(playback, &record_config);

printf("Tallenteen ominaisuudet:\n");
printf("  Kesto: %.2f sekuntia\n", k4a_playback_get_duration_count_us(playback) / 1000000.0);
printf("  Syvyystila: %d\n", record_config.depth_mode);
printf("  Värin resoluutio: %d\n", record_config.color_resolution);

// Hae kalibrointi tallenteesta
k4a_calibration_t calibration;
k4a_playback_get_calibration(playback, &calibration);

// Käy läpi kaikki kehykset
k4a_capture_t capture = NULL;
while (k4a_playback_get_next_capture(playback, &capture) == K4A_RESULT_SUCCEEDED) {
    k4a_image_t depth = k4a_capture_get_depth_image(capture);
    if (depth != NULL) {
        uint64_t timestamp = k4a_image_get_timestamp_usec(depth);
        printf("Kehys ajassa %.3f sekuntia\n", timestamp / 1000000.0);
        k4a_image_release(depth);
    }
    k4a_capture_release(capture);
}

k4a_playback_close(playback);

Usein kysytyt kysymykset

Mikä on Orbbec Femto Boltin suurin syvyysalue?

Femto Bolt saavuttaa tehokkaan syvyyden mittauksen 0,25 metristä 5,46 metriin valitusta syvyystilasta ja ympäristöolosuhteista riippuen. Tämä alue kattaa suurimman osan ihmisen mittakaavan vuorovaikutustilanteista, läheltä tapahtuvista robottitoiminnoista keskipitkän matkan valvontasovelluksiin. WFOV (Wide Field of View) -tila optimoi laajemmalle peittoalueelle jonkin verran tarkkuudesta tinkien, kun taas NFOV (Narrow Field of View) -tila tarjoaa parannetun tarkkuuden tarkempiin tarkastustehtäviin.

Voiko Femto Boltia käyttää ulkona?

Femto Bolt on optimoitu sisätiloihin, mutta se voi toimia myös puolilämpimissä ulkotiloissa sopivissa valaistusolosuhteissa. Voimakas suora auringonvalo voi häiritä kameran käyttämää infrapunasäteilyä syvyyden mittaamisessa, mikä rajoittaa suorituskykyä aurinkoisissa ulko-olosuhteissa. Kuitenkin katetut ulkoalueet, varjostetut paikat tai pilviset sääolosuhteet mahdollistavat yleensä hyväksyttävän toiminnan. Pysyviin ulkokäyttöihin kannattaa harkita suojakuorta ja ympäristöolosuhteiden hallintaa.

Onko Femto Bolt yhteensopiva ROS:n (Robot Operating System) kanssa?

Kyllä, Femto Bolt on yhteensopiva ROS:n (Robot Operating System) kanssa saatavilla olevan SDK:n ja yhteisön kehittämien ROS-wrapperien kautta. Azure Kinect SDK, jota Femto Bolt tukee, sisältää ROS-integraatiovaihtoehtoja, ja Orbbec-yhteisö on kehittänyt lisäpaketteja ROS:lle. Tämä yhteensopivuus mahdollistaa helpon integroinnin olemassa oleviin robotiikan kehitystyönkulkuihin.

Kuinka tarkka syvyysmittaus on?

Femto Bolt saavuttaa syvyystarkkuuden, jossa systemaattinen virhe on alle 11 mm plus 0,1 % mitatusta etäisyydestä, ja satunnaisen virheen keskihajonta on enintään 17 mm. Tämä suorituskyky täyttää vaativien teollisuus- ja tutkimussovellusten vaatimukset. Todellinen tarkkuus riippuu käyttötilasta, etäisyydestä, pinnan ominaisuuksista ja ympäristöolosuhteista.

Voidaanko useita Femto Bolt -kameroita synkronoida?

Kyllä, Femto Bolt tukee ulkoista laukaisinkontrollia, joka mahdollistaa tarkan synkronoinnin useiden kameroiden välillä. Tämä ominaisuus tukee ketjutettuja asennuksia laajennetun kattavuuden saavuttamiseksi, moninäkymätallennusta 3D-rekonstruktioon sekä samanaikaista tallennusta useista näkökulmista tilavuusvideota varten.

Mikä on ero WFOV- ja NFOV-tilojen välillä?

WFOV (Wide Field of View) -tila tallentaa syvyyttä 1024x1024-resoluutiolla ja 15 kuvaa sekunnissa, tarjoten 120° vaakasuoran ja pystysuoran näkökentän, mikä sopii laajoihin sovelluksiin. NFOV (Narrow Field of View) -tila tarjoaa 640x576-resoluution 30 kuvalla sekunnissa, 75° vaakasuoran ja 65° pystysuoran näkökentän, mikä sopii tarkempaan tarkasteluun ja korkeampiin kuvataajuuksiin.

Vaatiiko Femto Bolt erityistä valaistusta?

Femto Bolt käyttää omaa infrapunasäteilyään syvyyden mittaukseen, joten se ei vaadi erityistä ulkoista valaistusta syvyysmittauksia varten. RGB-kamera toimii tavallisen kameran tavoin ja hyötyy sopivasta valaistuksesta värikuvantamisessa. Syvyyden tarkkuuden varmistamiseksi kannattaa välttää erittäin heijastavia pintoja ja hyvin tummia materiaaleja, jotka voivat vaikuttaa infrapunasignaalin paluuseen.

Mitkä ohjelmointikielet tukevat Femto Bolt -kehitystä?

Femto Bolt tukee kehitystä useilla ohjelmointikielillä erilaisten SDK:iden kautta. Ensisijainen C/C++ SDK tarjoaa täydellisimmän toiminnallisuuden Azure Kinect API:n ja K4A Wrapperin kautta. Python-kehittäjät voivat käyttää pyk4a- tai azure-kinect-python-paketteja. Lisäksi yhteisön kehittämiä sidoksia on saatavilla C#:lle, Unitylle ja muille kielille.

Yhteenveto

Orbbec Femto Bolt muuttaa edistyneen 3D-näköteknologian kalliista erikoislaitteesta saavutettavaksi ominaisuudeksi kehittäjille ja integroijille lähes kaikilla toimialoilla. Sen poikkeuksellinen yhdistelmä tarkkaa TOF-syvyysmittausta, 4K RGB -kuvausta, erittäin kompaktia muotoilua ja täyttä Azure Kinect -yhteensopivuutta luo äärimmäisen monipuolisen alustan, joka sopii sovelluksiin aina kehittyneestä robottien laatikonpoiminnasta tilavuusvideon tallennukseen, yksityiskohtaisista tarkastusjärjestelmistä immersiivisiin AR-kokemuksiin.

Laaja kehitysmahdollisuuksien kirjo – robotiikasta, konenäöstä, AR/VR:stä, logistiikasta, terveydenhuollosta ja tutkimuksesta – osoittaa teknologian poikkeuksellisen monipuolisuuden. Käytännössä jokainen toimiala voi löytää kameran kyvystä tallentaa tarkkaa kolmiulotteista tietoa suurta kustannusta tai monimutkaisuutta vailla olevan automaation, oivallusten ja vuorovaikutuksen mahdollistamiseksi poikkeuksellista arvoa.

Onnistunut käyttöönotto vaatii huolellista ympäristövaatimusten, integraatiotekijöiden ja suorituskyvyn rajoitusten ymmärtämistä. Kuitenkin sovelluksissa, jotka todella hyödyntävät sen vaikuttavia ominaisuuksia, Femto Bolt tarjoaa erinomaisen perustan innovatiivisille 3D-näköratkaisuille.

Tämä kattava kehitysopas kattaa Orbbec Femto Bolt SDK:n asennuksen, ohjelmointioppaat ja koodiesimerkit. Tarkempia tuotetietoja ja osto-ohjeita löydät Orbbec Femto Bolt -tuotesivulta OpenELABissa.

Haluatko oppia lisää ToF-kamerateknologiasta? Tutustu OpenELABin laajaan valikoimaan TOF-kameroita ja syvyyskameroita lisävaihtoehtoja varten.

Etsitkö sovellus-esimerkkejä? Tutustu Orbbec Femto Boltin sovellusoppaaseen ja löydä toimialakohtaisia käyttötapauksia ja toteutusvinkkejä.

Valmis aloittamaan kehitystyö? Tutustu OpenELABin kehitysmateriaaleihin, joissa on SDK-dokumentaatiota, käytännön koodiesimerkkejä ja yksityiskohtaisia integraatio-opastuksia, jotka nopeuttavat 3D-näköprojektisi kehitystä.

Lue lisää Time of Flight -teknologiasta Wikipediassa ja osallistu keskusteluihin Redditissä robotiikasta ja syvyyskamera-sovelluksista.

Osta: OpenELAB