Vyhledatelná kamera

Článek
07/12/2023

Než začnete, doporučujeme, abyste se podívali na článek s přehledem lokatable kamery , který obsahuje přehledové informace a tabulku s podrobnostmi o fotoaparátech HoloLens 1 a 2.

Použití MediaFrameReference

Tyto pokyny platí v případě, že ke čtení snímků obrázků z fotoaparátu používáte třídu MediaFrameReference .

Každý rámeček obrázku (fotka nebo video) obsahuje SpatialCoordinateSystem s rootem ve fotoaparátu v době zachycení, ke kterému je možné přistupovat pomocí vlastnosti CoordinateSystem vašeho MediaFrameReference. Každý snímek obsahuje popis modelu objektivu fotoaparátu, který najdete ve vlastnosti CameraIntrinsics . Tyto transformace společně definují pro každý pixel paprsek v 3D prostoru představující cestu pořízenou fotony, které vytvořily pixel. Tyto paprsky mohou být spojeny s jiným obsahem v aplikaci získáním transformace ze souřadnicového systému rámce do jiného souřadnicového systému (např. ze statického referenčního rámce).

Každý rámeček obrázku poskytuje následující:

Pixelová data (ve formátu RGB/NV12/JPEG/atd.)
A SpatialCoordinateSystem z umístění zachycení
Třída CameraIntrinsics obsahující režim čočky fotoaparátu

Ukázka HolographicFaceTracking ukazuje poměrně jednoduchý způsob, jak dotazovat na transformaci mezi souřadnicovým systémem kamery a souřadnicovými systémy vaší vlastní aplikace.

Použití Media Foundation

Pokud používáte Media Foundation přímo ke čtení snímků z fotoaparátu, můžete použít atribut MFSampleExtension_CameraExtrinsics každého snímku a atribut MFSampleExtension_PinholeCameraIntrinsics k vyhledání snímků vzhledem k ostatním souřadnicovým systémům vaší aplikace, jak je znázorněno v tomto ukázkovém kódu:

#include <winrt/windows.perception.spatial.preview.h>
#include <mfapi.h>
#include <mfidl.h>
 
using namespace winrt::Windows::Foundation;
using namespace winrt::Windows::Foundation::Numerics;
using namespace winrt::Windows::Perception;
using namespace winrt::Windows::Perception::Spatial;
using namespace winrt::Windows::Perception::Spatial::Preview;
 
class CameraFrameLocator
{
public:
    struct CameraFrameLocation
    {
        SpatialCoordinateSystem CoordinateSystem;
        float4x4 CameraViewToCoordinateSystemTransform;
        MFPinholeCameraIntrinsics Intrinsics;
    };
 
    std::optional<CameraFrameLocation> TryLocateCameraFrame(IMFSample* pSample)
    {
        MFCameraExtrinsics cameraExtrinsics;
        MFPinholeCameraIntrinsics cameraIntrinsics;
        UINT32 sizeCameraExtrinsics = 0;
        UINT32 sizeCameraIntrinsics = 0;
        UINT64 sampleTimeHns = 0;
 
        // query sample for calibration and validate
        if (FAILED(pSample->GetUINT64(MFSampleExtension_DeviceTimestamp, &sampleTimeHns)) ||
            FAILED(pSample->GetBlob(MFSampleExtension_CameraExtrinsics, (UINT8*)& cameraExtrinsics, sizeof(cameraExtrinsics), &sizeCameraExtrinsics)) ||
            FAILED(pSample->GetBlob(MFSampleExtension_PinholeCameraIntrinsics, (UINT8*)& cameraIntrinsics, sizeof(cameraIntrinsics), &sizeCameraIntrinsics)) ||
            (sizeCameraExtrinsics != sizeof(cameraExtrinsics)) ||
            (sizeCameraIntrinsics != sizeof(cameraIntrinsics)) ||
            (cameraExtrinsics.TransformCount == 0))
        {
            return std::nullopt;
        }
 
        // compute extrinsic transform
        const auto& calibratedTransform = cameraExtrinsics.CalibratedTransforms[0];
        const GUID& dynamicNodeId = calibratedTransform.CalibrationId;
        const float4x4 cameraToDynamicNode =
            make_float4x4_from_quaternion(quaternion{ calibratedTransform.Orientation.x, calibratedTransform.Orientation.y, calibratedTransform.Orientation.z, calibratedTransform.Orientation.w }) *
            make_float4x4_translation(calibratedTransform.Position.x, calibratedTransform.Position.y, calibratedTransform.Position.z);
 
        // update locator cache for dynamic node
        if (dynamicNodeId != m_currentDynamicNodeId || !m_locator)
        {
            m_locator = SpatialGraphInteropPreview::CreateLocatorForNode(dynamicNodeId);
            if (!m_locator)
            {
                return std::nullopt;
            }
 
            m_frameOfReference = m_locator.CreateAttachedFrameOfReferenceAtCurrentHeading();
            m_currentDynamicNodeId = dynamicNodeId;
        }
 
        // locate dynamic node
        auto timestamp = PerceptionTimestampHelper::FromSystemRelativeTargetTime(TimeSpan{ sampleTimeHns });
        auto coordinateSystem = m_frameOfReference.GetStationaryCoordinateSystemAtTimestamp(timestamp);
        auto location = m_locator.TryLocateAtTimestamp(timestamp, coordinateSystem);
        if (!location)
        {
            return std::nullopt;
        }
 
        const float4x4 dynamicNodeToCoordinateSystem = make_float4x4_from_quaternion(location.Orientation()) * make_float4x4_translation(location.Position());
 
        return CameraFrameLocation{ coordinateSystem, cameraToDynamicNode * dynamicNodeToCoordinateSystem, cameraIntrinsics };
    }

private:
    GUID m_currentDynamicNodeId{ GUID_NULL };
    SpatialLocator m_locator{ nullptr };
    SpatialLocatorAttachedFrameOfReference m_frameOfReference{ nullptr };
};

Scénáře použití lokalizovatelné kamery

Zobrazení fotky nebo videa ve světě, kde byla pořízena

Snímky kamery zařízení se dodávají s transformací "Kamera do světa", která se dá použít k zobrazení přesného umístění zařízení, když byl snímek pořízen. Můžete například umístit malou holografickou ikonu na toto místo (CameraToWorld.MultiplyPoint(Vector3.zero)) a dokonce nakreslit malou šipku ve směru, kterým fotoaparát směřoval (CameraToWorld.MultiplyVector(Vector3.forward)).

Kmitočet

Udržování interaktivní snímkové frekvence aplikace je důležité, zejména při práci s dlouhotrvajícími algoritmy pro rozpoznávání obrázků. Z tohoto důvodu běžně používáme následující vzor:

Hlavní vlákno: spravuje objekt kamery.
Hlavní vlákno: požaduje nové rámce (asynchronní)
Hlavní vlákno: předat nové rámce do sledování vlákna
Sledovací vlákno: zpracovává obrázek ke shromažďování klíčových bodů.
Hlavní vlákno: přesune virtuální model tak, aby odpovídal nalezené klíčové body.
Hlavní vlákno: opakujte od kroku 2.

Některé systémy značek obrázků poskytují pouze jeden pixel umístění (jiné poskytují úplnou transformaci, v takovém případě nebude tento oddíl potřeba), což odpovídá paprsku možných umístění. Abychom se dostali na jedno třetí místo, můžeme využít více paprsků a najít konečný výsledek podle jejich přibližného průsečíku. Abyste to mohli udělat, budete muset:

Získání smyčky při shromažďování více snímků z fotoaparátu
Vyhledání přidružených bodů prvků a jejich paprsků světa
Pokud máte slovník prvků, každý s více paprsky světa, můžete použít následující kód k řešení průniku těchto paprsků:

public static Vector3 ClosestPointBetweenRays(
   Vector3 point1, Vector3 normalizedDirection1,
   Vector3 point2, Vector3 normalizedDirection2) {
   float directionProjection = Vector3.Dot(normalizedDirection1, normalizedDirection2);
   if (directionProjection == 1) {
     return point1; // parallel lines
   }
   float projection1 = Vector3.Dot(point2 - point1, normalizedDirection1);
   float projection2 = Vector3.Dot(point2 - point1, normalizedDirection2);
   float distanceAlongLine1 = (projection1 - directionProjection * projection2) / (1 - directionProjection * directionProjection);
   float distanceAlongLine2 = (projection2 - directionProjection * projection1) / (directionProjection * directionProjection - 1);
   Vector3 pointOnLine1 = point1 + distanceAlongLine1 * normalizedDirection1;
   Vector3 pointOnLine2 = point2 + distanceAlongLine2 * normalizedDirection2;
   return Vector3.Lerp(pointOnLine2, pointOnLine1, 0.5f);
 }

Umístění modelované scény

Pokud máte dvě nebo více sledovaných umístění značek, můžete modelovanou scénu umístit tak, aby odpovídala aktuálnímu scénáři uživatele. Pokud nemůžete předpokládat závažnost, budete potřebovat tři umístění značek. V mnoha případech používáme barevné schéma, kde bílé koule představují umístění sledovaných značek v reálném čase a modré koule představují umístění modelovaných značek. To uživateli umožňuje vizuálně změřit kvalitu zarovnání. Ve všech aplikacích předpokládáme následující nastavení:

Dvě nebo více umístění modelovaných značek
Jeden "kalibrační prostor", který je ve scéně nadřazený značky
Identifikátor funkce fotoaparátu
Chování, které přesouvá prostor kalibrace tak, aby se modelované značky zarovnaly se značkami v reálném čase (dbáme na to, abychom přesunuli nadřazený prostor, ne samotné modelované značky, protože jiné spojení je relativní k nim).

// In the two tags case:
 Vector3 idealDelta = (realTags[1].EstimatedWorldPos - realTags[0].EstimatedWorldPos);
 Vector3 curDelta = (modelledTags[1].transform.position - modelledTags[0].transform.position);
 if (IsAssumeGravity) {
   idealDelta.y = 0;
   curDelta.y = 0;
 }
 Quaternion deltaRot = Quaternion.FromToRotation(curDelta, idealDelta);
 trans.rotation = Quaternion.LookRotation(deltaRot * trans.forward, trans.up);
 trans.position += realTags[0].EstimatedWorldPos - modelledTags[0].transform.position;

Sledování nebo identifikace označených statických nebo pohybujících se reálných objektů nebo tváří pomocí LED diod nebo jiných knihoven rozpoznávání

Příklady:

Průmyslové roboty s LED diodami (nebo kódy QR pro pomalejší pohybující se objekty)
Identifikace a rozpoznávání objektů v místnosti
Identifikace a rozpoznávání lidí v místnosti, například umístění holografických karet kontaktů přes tváře

Sdílet prostřednictvím