Vue d’ensemble du Kit de développement logiciel (SDK) De compréhension

La compréhension des scènes transforme les données de capteur d’environnement non structurées capturées par votre appareil Mixed Reality et les convertit en une représentation abstraite puissante. Le Kit de développement logiciel (SDK) agit comme couche de communication entre votre application et le runtime Scene Understanding. Il vise à imiter des constructions standard existantes, telles que des graphiques de scène 3D pour les représentations 3D, et des rectangles et des panneaux 2D pour les applications 2D. Bien que les constructions Scene Understanding mappent aux infrastructures concrètes, en général SceneUnderstanding est une infrastructure agnostique permettant l’interopérabilité entre des infrastructures variées qui interagissent avec elle. À mesure que Scene Understanding évolue, le rôle du SDK est de garantir que de nouvelles représentations et fonctionnalités continuent d’être exposées dans une infrastructure unifiée. Dans ce document, nous allons d’abord présenter des concepts de haut niveau qui vous aideront à vous familiariser avec l’environnement de développement/l’utilisation, puis fournir une documentation plus détaillée pour des classes et des constructions spécifiques.

Où puis-je obtenir le Kit de développement logiciel (SDK) ?

Le Kit de développement logiciel (SDK) SceneUnderstanding est téléchargeable via l’outil de fonctionnalité Mixed Reality.

Remarque : la dernière version dépend des packages en préversion et vous devez activer les packages préversion pour le voir.

Pour la version 0.5.2022-rc et ultérieure, Scene Understanding prend en charge les projections de langage pour C# et C++ permettant aux applications de développer des applications pour les plateformes Win32 ou UWP. À compter de cette version, SceneUnderstanding prend en charge unity dans l’éditeur prenant en charge l’exception de SceneObserver, qui est utilisée uniquement pour communiquer avec HoloLens2.

SceneUnderstanding nécessite Windows sdk version 18362 ou ultérieure.

Vue d'ensemble conceptuelle

Scène

Votre appareil de réalité mixte intègre constamment des informations sur ce qu’il voit dans votre environnement. Scene Understanding entonnoirs toutes ces sources de données et produit une seule abstraction cohérente. Scene Understanding génère des scènes, qui sont une composition de SceneObjects qui représentent une instance d’une seule chose, (par exemple, un mur/plafond/plancher).) Les objets de scène eux-mêmes sont une composition de [SceneComponents, qui représentent des éléments plus précis qui composent ce SceneObject. Des exemples de composants sont des quads et des maillages, mais dans l’avenir pourrait représenter des boîtes englobantes, des maillages de collision, des métadonnées, etc.

Le processus de conversion des données de capteur brutes en scène est une opération potentiellement coûteuse qui peut prendre des secondes pour les espaces moyens (~10x10m) en minutes pour les grands espaces (~50x50m) et donc ce n’est pas quelque chose qui est calculé par l’appareil sans demande d’application. Au lieu de cela, la génération de scène est déclenchée par votre application à la demande. La classe SceneObserver a des méthodes statiques qui peuvent calculer ou désérialiser une scène, avec laquelle vous pouvez ensuite énumérer/interagir. L’action « Calcul » est exécutée à la demande et s’exécute sur le processeur, mais dans un processus distinct (pilote Mixed Reality). Toutefois, pendant que nous calculons dans un autre processus, les données de scène résultantes sont stockées et conservées dans votre application dans l’objet Scene.

Voici un diagramme illustrant ce flux de processus et montrant des exemples de deux applications interfacant avec le runtime Scene Understanding.

Process Diagram

Sur le côté gauche, il s’agit d’un diagramme du runtime de réalité mixte, qui est toujours activé et exécuté dans son propre processus. Ce runtime est chargé d’effectuer le suivi des appareils, le mappage spatial et d’autres opérations que Scene Understanding utilise pour comprendre et raisonner le monde autour de vous. Sur le côté droit du diagramme, nous affichons deux applications théoriques qui utilisent Scene Understanding. Les premières interfaces d’application avec MRTK, qui utilisent le KIT SDK Scene Understanding en interne, la deuxième application calcule et utilise deux instances de scène distinctes. Les trois scènes de ce diagramme génèrent des instances distinctes des scènes, le pilote ne suit pas l’état global qui est partagé entre les applications et les objets scène dans une scène ne se trouvent pas dans une autre. Scene Understanding fournit un mécanisme permettant de suivre au fil du temps, mais cela est effectué à l’aide du Kit de développement logiciel (SDK). Le code de suivi est déjà en cours d’exécution dans le Kit de développement logiciel (SDK) dans le processus de votre application.

Étant donné que chaque scène stocke ses données dans l’espace mémoire de votre application, vous pouvez supposer que toutes les fonctions de l’objet Scene ou ses données internes sont toujours exécutées dans le processus de votre application.

Layout

Pour travailler avec Scene Understanding, il peut être utile de savoir et de comprendre comment le runtime représente les composants logiquement et physiquement. La Scène représente des données avec une disposition spécifique qui a été choisie pour être simple tout en conservant une structure sous-jacente qui est pliable pour répondre aux exigences futures sans avoir besoin de révisions majeures. La Scène effectue cette opération en stockant tous les composants (blocs de construction pour tous les objets de scène) dans une liste plate et en définissant la hiérarchie et la composition par le biais de références où des composants spécifiques référencent d’autres éléments.

Ci-dessous, nous présentons un exemple de structure dans sa forme plate et logique.

Disposition logiqueDisposition physique
    Scene
    • SceneObject_1
      • SceneMesh_1
      • SceneQuad_1
      • SceneQuad_2
    • SceneObject_2
      • SceneQuad_1
      • SceneQuad_3
    • SceneObject_3
      • SceneMesh_3
  • SceneObject_1
  • SceneObject_2
  • SceneObject_3
  • SceneQuad_1
  • SceneQuad_2
  • SceneQuad_3
  • SceneMesh_1
  • SceneMesh_2

Cette illustration met en évidence la différence entre la disposition physique et logique de la scène. À gauche, nous voyons la disposition hiérarchique des données que votre application voit lors de l’énumération de la scène. À droite, nous constatons que la scène est composée de 12 composants distincts accessibles individuellement si nécessaire. Lors du traitement d’une nouvelle scène, nous nous attendons à ce que les applications marchent logiquement dans cette hiérarchie, toutefois, lors du suivi entre les mises à jour de scène, certaines applications peuvent uniquement s’intéresser à cibler des composants spécifiques partagés entre deux scènes.

Présentation de l’API

La section suivante fournit une vue d’ensemble générale des constructions dans Scene Understanding. La lecture de cette section vous donnera une compréhension de la façon dont les scènes sont représentées et de ce que les différents composants font/sont utilisés pour. La section suivante fournit des exemples de code concrets et des détails supplémentaires qui sont brillants dans cette vue d’ensemble.

Tous les types décrits ci-dessous se trouvent dans l’espace Microsoft.MixedReality.SceneUnderstanding de noms.

SceneComponents

Maintenant que vous comprenez la disposition logique des scènes, nous pouvons présenter le concept de SceneComponents et comment ils sont utilisés pour composer la hiérarchie. SceneComponents est les décompositions les plus granulaires dans SceneUnderstanding représentant une seule chose principale, par exemple, un maillage ou un quad ou une zone englobante. SceneComponents sont des éléments qui peuvent être mis à jour indépendamment et peuvent être référencés par d’autres SceneComponents, par conséquent ils ont une propriété globale unique, un ID unique, qui permettent ce type de mécanisme de suivi/de référencement. Les ID sont utilisés pour la composition logique de la hiérarchie de scènes ainsi que pour la persistance des objets (l’acte de mise à jour d’une scène par rapport à une autre).

Si vous traitez chaque scène nouvellement calculée comme étant distincte et que vous énumérez simplement toutes les données au sein de celle-ci, les ID sont largement transparents pour vous. Toutefois, si vous envisagez de suivre les composants sur plusieurs mises à jour, vous allez utiliser les ID pour indexer et rechercher sceneComponents entre les objets Scene.

SceneObjects

Un SceneObject est une SceneComponent qui représente une instance d’une « chose » par exemple, un mur, un plancher, un plafond, etc.... exprimée par leur propriété Kind. SceneObjects est géométrique et possède donc des fonctions et des propriétés qui représentent leur emplacement dans l’espace, mais ils ne contiennent aucune structure géométrique ou logique. Au lieu de cela, SceneObjects référence d’autres SceneComponents, en particulier SceneQuads et SceneMeshes, qui fournissent les représentations variées prises en charge par le système. Lorsqu’une nouvelle scène est calculée, votre application énumère probablement les SceneObjects de la scène pour traiter ce qu’elle intéresse.

SceneObjects peut avoir l’un des éléments suivants :

SceneObjectKind Description
Arrière-planSceneObject est connu pour ne pas être l’un des autres types reconnus d’objet de scène. Cette classe ne doit pas être confondue avec Inconnu où l’arrière-plan est connu pour ne pas être mur/plancher/plafond, etc.... alors que l’inconnu n’est pas encore classé.
MurUn mur physique. Les murs sont supposés être des structures environnementales immuables.
FloorLes étages sont des surfaces sur lesquelles on peut marcher. Remarque : les escaliers ne sont pas des étages. Notez également que les étages supposent toute surface marchable et, par conséquent, il n’y a aucune hypothèse explicite d’un plancher singulier. Structures à plusieurs niveaux, rampes, etc. doit tous classer comme plancher.
CeilingSurface supérieure d’une pièce.
PlateformeUne grande surface plate sur laquelle vous pouvez placer des hologrammes. Celles-ci ont tendance à représenter des tables, des comptoirs et d’autres surfaces horizontales volumineuses.
World (Monde)Étiquette réservée pour les données géométriques qui sont agnostiques à l’étiquetage. Le maillage généré en définissant l’indicateur de mise à jour EnableWorldMesh est classé comme un monde.
UnknownCet objet de scène n’a pas encore été classé et affecté à un type. Cela ne doit pas être confondu avec Background, car cet objet pourrait être n’importe quoi, le système n’a juste pas trouvé de classification assez forte pour elle encore.

SceneMesh

Une SceneMesh est une SceneComponent qui approximativement la géométrie des objets géométriques arbitraires à l’aide d’une liste de triangles. SceneMeshes est utilisé dans plusieurs contextes différents ; ils peuvent représenter des composants de la structure de cellule étanche ou comme WorldMesh, qui représente le maillage de mappage spatial non lié associé à la scène. Les données d’index et de vertex fournies avec chaque maillage utilisent la même disposition familière que les mémoires tampons de vertex et d’index utilisées pour le rendu des maillages triangle dans toutes les API de rendu modernes. Dans Scene Understanding, les maillages utilisent des index 32 bits et doivent peut-être être divisés en blocs pour certains moteurs de rendu.

Ordre de vent et systèmes de coordonnées

Tous les maillages produits par Scene Understanding sont censés retourner des maillages dans un système de coordonnées Right-Handed à l’aide de l’ordre du vent dans le sens de l’horloge.

Remarque : les builds du système d’exploitation antérieures à .191105 peuvent avoir un bogue connu où les maillages « World » retournent dans Counter-Clockwise ordre de vent, qui a ensuite été résolu.

SceneQuad

Un SceneQuad est un SceneComponent qui représente des surfaces 2d qui occupent le monde 3D. SceneQuads peut être utilisé de la même manière que les API ARKit ARPlaneAnchor ou ARCore Planes, mais elles offrent des fonctionnalités plus élevées que les 2d canevas à utiliser par les applications plates ou les API 2D spécifiques. Les API spécifiques à 2D sont fournies pour les quads qui rendent le placement et la disposition simples à utiliser, et le développement (à l’exception du rendu) avec des quads doit se sentir plus proche de travailler avec des canevas 2d que des maillages 3d.

Forme SceneQuad

SceneQuads définit une surface rectangulaire délimitée en 2d. Toutefois, SceneQuads représente des surfaces avec des formes arbitraires et potentiellement complexes (par exemple, une table en forme de donut.) Pour représenter la forme complexe de la surface d’un quad, vous pouvez utiliser l’API GetSurfaceMask pour afficher la forme de la surface sur une mémoire tampon d’image que vous fournissez. Si SceneObject qui a le quad a également un maillage, les triangles de maillage doivent être équivalents à cette image rendue, ils représentent toutes deux la géométrie réelle de la surface, soit en coordonnées 2d ou 3d.

Présentation des détails et références du Kit de développement logiciel (SDK) de la scène

Notes

Lorsque vous utilisez MRTK, notez que vous interagirez avec les ['WindowsSceneUnderstandingObserver'](xref:Microsoft.MixedReality.Shared Computer Toolkit. WindowsSceneUnderstanding.Experimental.WindowsSceneUnderstandingObserver) et peut donc ignorer cette section dans la plupart des circonstances. Pour plus d’informations, reportez-vous à la documentation [MRTK Scene Understanding](/windows/mixed-reality/mrtk-unity/features/spatial-awareness/scene-understanding).

La section suivante vous aidera à vous familiariser avec les principes de base de SceneUnderstanding. Cette section doit vous fournir les principes de base, à quel moment vous devez disposer d’un contexte suffisant pour parcourir les exemples d’applications pour voir comment SceneUnderstanding est utilisé de manière holistique.

Initialisation

La première étape d’utilisation de SceneUnderstanding consiste à obtenir une référence à un objet Scene. Cela peut être effectué de deux façons, une scène peut être calculée par le pilote, ou une scène existante qui a été calculée dans le passé peut être désérialisée. Ce dernier est utile pour travailler avec SceneUnderstanding pendant le développement, où les applications et les expériences peuvent être prototypes rapidement sans appareil de réalité mixte.

Les scènes sont calculées à l’aide d’un SceneObserver. Avant de créer une scène, votre application doit interroger votre appareil pour vous assurer qu’il prend en charge SceneUnderstanding, ainsi que pour demander à l’utilisateur d’accéder aux informations dont SceneUnderstanding a besoin.

if (!SceneObserver.IsSupported())
{
    // Handle the error
}

// This call should grant the access we need.
await SceneObserver.RequestAccessAsync();

Si RequestAccessAsync() n’est pas appelé, le calcul d’une nouvelle scène échoue. Ensuite, nous allons calculer une nouvelle scène enracinée autour du casque Mixed Reality et qui a un rayon de 10 mètres.

// Create Query settings for the scene update
SceneQuerySettings querySettings;

querySettings.EnableSceneObjectQuads = true;                                       // Requests that the scene updates quads.
querySettings.EnableSceneObjectMeshes = true;                                      // Requests that the scene updates watertight mesh data.
querySettings.EnableOnlyObservedSceneObjects = false;                              // Do not explicitly turn off quad inference.
querySettings.EnableWorldMesh = true;                                              // Requests a static version of the spatial mapping mesh.
querySettings.RequestedMeshLevelOfDetail = SceneMeshLevelOfDetail.Fine;            // Requests the finest LOD of the static spatial mapping mesh.

// Initialize a new Scene
Scene myScene = SceneObserver.ComputeAsync(querySettings, 10.0f).GetAwaiter().GetResult();

Initialisation à partir de données (également appelée chemin d’accès du PC)

Bien que les scènes puissent être calculées pour la consommation directe, elles peuvent également être calculées sous forme sérialisée pour une utilisation ultérieure. Cela s’est avéré utile pour le développement, car il permet aux développeurs de travailler et de tester Scene Understanding sans avoir besoin d’un appareil. L’acte de sérialisation d’une scène est presque identique à l’informatique, les données sont retournées à votre application au lieu d’être désérialisées localement par le Kit de développement logiciel (SDK). Vous pouvez ensuite désérialiser vous-même ou l’enregistrer pour une utilisation ultérieure.

// Create Query settings for the scene update
SceneQuerySettings querySettings;

// Compute a scene but serialized as a byte array
SceneBuffer newSceneBuffer = SceneObserver.ComputeSerializedAsync(querySettings, 10.0f).GetAwaiter().GetResult();

// If we want to use it immediately we can de-serialize the scene ourselves
byte[] newSceneData = new byte[newSceneBuffer.Size];
newSceneBuffer.GetData(newSceneData);
Scene mySceneDeSerialized = Scene.Deserialize(newSceneData);

// Save newSceneData for later

SceneObject, énumération

Maintenant que votre application a une scène, votre application examine et interagit avec SceneObjects. Pour ce faire, accédez à la propriété SceneObjects :

SceneObject firstFloor = null;

// Find the first floor object
foreach (var sceneObject in myScene.SceneObjects)
{
    if (sceneObject.Kind == SceneObjectKind.Floor)
    {
        firstFloor = sceneObject;
        break;
    }
}

Composants de mise à jour et de refinding des composants

Il existe une autre fonction qui récupère les composants de la Scène appelée FindComponent. Cette fonction est utile lors de la mise à jour des objets de suivi et de leur recherche dans des scènes ultérieures. Le code suivant calcule une nouvelle scène par rapport à une scène précédente, puis recherche le sol dans la nouvelle scène.

// Compute a new scene, and tell the system that we want to compute relative to the previous scene
Scene myNextScene = SceneObserver.ComputeAsync(querySettings, 10.0f, myScene).GetAwaiter().GetResult();

// Use the Id for the floor we found last time, and find it again
firstFloor = (SceneObject)myNextScene.FindComponent(firstFloor.Id);

if (firstFloor != null)
{
    // We found it again, we can now update the transforms of all objects we attached to this floor transform
}

Accès aux maillages et aux quads à partir d’objets de scène

Une fois que SceneObjects a été trouvé, votre application souhaite probablement accéder aux données contenues dans les quads/maillages qu’elle est composée. Ces données sont accessibles avec les propriétés Quads et Meshes . Le code suivant énumère tous les quads et maillages de notre objet de plancher.


// Get the transform for the SceneObject
System.Numerics.Matrix4x4 objectToSceneOrigin = firstFloor.GetLocationAsMatrix();

// Enumerate quads
foreach (var quad in firstFloor.Quads)
{
    // Process quads
}

// Enumerate meshes
foreach (var mesh in firstFloor.Meshes)
{
    // Process meshes
}

Notez qu’il s’agit de SceneObject qui a la transformation relative à l’origine de la scène. Cela est dû au fait que SceneObject représente une instance d’une « chose » et est locatable dans l’espace, les quads et les maillages représentent la géométrie transformée par rapport à leur parent. Il est possible de séparer SceneObjects pour faire référence au même SceneMesh/SceneQuad SceneComponents, et il est également possible qu’un SceneObject possède plusieurs SceneMesh/SceneQuad.

Gestion des transformations

Scene Understanding a fait une tentative délibérée d’aligner sur les représentations de scène 3D traditionnelles lors de la gestion des transformations. Chaque scène est donc limitée à un système de coordonnées unique comme les représentations environnementales 3D les plus courantes. SceneObjects fournit chacun leur emplacement par rapport à ce système de coordonnées. Si votre application traite des scènes qui étendent la limite de ce qu’une seule origine fournit il peut ancrer SceneObjects à SpatialAnchors, ou générer plusieurs scènes et les fusionner, mais pour simplifier, nous supposons que les scènes d’eau existent dans leur propre origine localisée par un NodeId défini par Scene.OriginSpatialGraphNodeId.

Le code Unity suivant, par exemple, montre comment utiliser Windows Perception et les API Unity pour aligner les systèmes de coordonnées ensemble. Consultez SpatialCoordinateSystem et SpatialGraphInteropPreview pour plus d’informations sur les API perception Windows, et Mixed Reality objets natifs dans Unity pour plus d’informations sur l’obtention d’un SpatialCoordinateSystem qui correspond à l’origine mondiale de Unity.

private System.Numerics.Matrix4x4? GetSceneToUnityTransformAsMatrix4x4(SceneUnderstanding.Scene scene)
{
    System.Numerics.Matrix4x4? sceneToUnityTransform = System.Numerics.Matrix4x4.Identity;

    
    Windows.Perception.Spatial.SpatialCoordinateSystem sceneCoordinateSystem = Microsoft.Windows.Perception.Spatial.Preview.SpatialGraphInteropPreview.CreateCoordinateSystemForNode(scene.OriginSpatialGraphNodeId);
    Windows.Perception.Spatial.SpatialCoordinateSystem unityCoordinateSystem = Microsoft.Windows.Perception.Spatial.SpatialCoordinateSystem.FromNativePtr(UnityEngine.XR.WindowsMR.WindowsMREnvironment.OriginSpatialCoordinateSystem);

    sceneToUnityTransform = sceneCoordinateSystem.TryGetTransformTo(unityCoordinateSystem);

    if (sceneToUnityTransform != null)
    {
        sceneToUnityTransform = ConvertRightHandedMatrix4x4ToLeftHanded(sceneToUnityTransform.Value);
    }
    else
    {
        return null;
    }
            
    return sceneToUnityTransform;
}

Chacune SceneObject a une transformation, qui est ensuite appliquée à cet objet. Dans Unity, nous convertissons en coordonnées droites et affectons des transformations locales comme suit :

private System.Numerics.Matrix4x4 ConvertRightHandedMatrix4x4ToLeftHanded(System.Numerics.Matrix4x4 matrix)
{
    matrix.M13 = -matrix.M13;
    matrix.M23 = -matrix.M23;
    matrix.M43 = -matrix.M43;

    matrix.M31 = -matrix.M31;
    matrix.M32 = -matrix.M32;
    matrix.M34 = -matrix.M34;

    return matrix;
}

 private void SetUnityTransformFromMatrix4x4(Transform targetTransform, System.Numerics.Matrix4x4 matrix, bool updateLocalTransformOnly = false)
 {
    if(targetTransform == null)
    {
        return;
    }

    Vector3 unityTranslation;
    Quaternion unityQuat;
    Vector3 unityScale;

    System.Numerics.Vector3 vector3;
    System.Numerics.Quaternion quaternion;
    System.Numerics.Vector3 scale;

    System.Numerics.Matrix4x4.Decompose(matrix, out scale, out quaternion, out vector3);

    unityTranslation = new Vector3(vector3.X, vector3.Y, vector3.Z);
    unityQuat        = new Quaternion(quaternion.X, quaternion.Y, quaternion.Z, quaternion.W);
    unityScale       = new Vector3(scale.X, scale.Y, scale.Z);

    if(updateLocalTransformOnly)
    {
        targetTransform.localPosition = unityTranslation;
        targetTransform.localRotation = unityQuat;
    }
    else
    {
        targetTransform.SetPositionAndRotation(unityTranslation, unityQuat);
    }
}

// Assume we have an SU object called suObject and a unity equivalent unityObject

System.Numerics.Matrix4x4 converted4x4LocationMatrix = ConvertRightHandedMatrix4x4ToLeftHanded(suObject.GetLocationAsMatrix());
SetUnityTransformFromMatrix4x4(unityObject.transform, converted4x4LocationMatrix, true);
        

Quad

Les quads ont été conçus pour aider les scénarios de placement 2D et doivent être considérés comme des extensions aux éléments d’expérience utilisateur de canevas 2D. Même si les quads sont des composants de SceneObjects et peuvent être rendus en 3D, les API Quad supposent que les quads sont des structures 2D. Ils offrent des informations telles que l’étendue, la forme et fournissent des API pour le placement.

Les quads ont des étendues rectangulaires, mais ils représentent des surfaces 2D arbitrairement mises en forme. Pour activer le placement sur ces surfaces 2D qui interagissent avec les quads de l’environnement 3D, offrent des utilitaires pour rendre cette interaction possible. Actuellement Scene Understanding fournit deux fonctions de ce type, FindCentermostPlacement et GetSurfaceMask. FindCentermostPlacement est une API de haut niveau qui localise une position sur le quad où un objet peut être placé et essaiera de trouver le meilleur emplacement pour votre objet garantissant que la zone englobante que vous fournissez restera sur la surface sous-jacente.

Notes

Les coordonnées de la sortie sont relatives au quad dans « quad space » avec le coin supérieur gauche étant (x = 0, y = 0), tout comme avec d’autres types de fenêtres Rect. Veillez à prendre cela en compte lors de l’utilisation des origines de vos propres objets.

L’exemple suivant montre comment trouver l’emplacement le plus central et ancrer un hologramme sur le quad.

// This code assumes you already have a "Root" object that attaches the Scene's Origin.

// Find the first quad
foreach (var sceneObject in myScene.SceneObjects)
{
    // Find a wall
    if (sceneObject.Kind == SceneObjectKind.Wall)
    {
        // Get the quad
        var quads = sceneObject.Quads;
        if (quads.Count > 0)
        {
            // Find a good location for a 1mx1m object  
            System.Numerics.Vector2 location;
            if (quads[0].FindCentermostPlacement(new System.Numerics.Vector2(1.0f, 1.0f), out location))
            {
                // We found one, anchor something to the transform
                // Step 1: Create a new game object for the quad itself as a child of the scene root
                // Step 2: Set the local transform from quads[0].Position and quads[0].Orientation
                // Step 3: Create your hologram and set it as a child of the quad's game object
                // Step 4: Set the hologram's local transform to a translation (location.x, location.y, 0)
            }
        }
    }
}

Les étapes 1-4 dépendent fortement de votre infrastructure/implémentation particulière, mais les thèmes doivent être similaires. Il est important de noter que le Quad représente simplement un plan 2D délimité localisé dans l’espace. En ayant votre moteur/framework savoir où se trouve le quad et raciner vos objets par rapport au quad, vos hologrammes se trouvent correctement en ce qui concerne le monde réel.

Maillage

Les maillages représentent des représentations géométriques d’objets ou d’environnements. Tout comme le mappage spatial, l’index de maillage et les données de vertex fournies avec chaque maillage de surface spatiale utilisent la même disposition familière que les mémoires tampons de vertex et d’index utilisées pour le rendu des maillages triangle dans toutes les API de rendu modernes. Les positions de vertex sont fournies dans le système de coordonnées du Scene. Les API spécifiques utilisées pour référencer ces données sont les suivantes :

void GetTriangleIndices(int[] indices);
void GetVertices(System.Numerics.Vector3[] vertices);

Le code suivant fournit un exemple de génération d’une liste de triangles à partir de la structure de maillage :

uint[] indices = new uint[mesh.TriangleIndexCount];
System.Numerics.Vector3[] positions = new System.Numerics.Vector3[mesh.VertexCount];

mesh.GetTriangleIndices(indices);
mesh.GetVertexPositions(positions);

Les mémoires tampons d’index/vertex doivent être >= les nombres d’index/vertex, mais sinon, elles peuvent être dimensionnées arbitrairement, ce qui permet une réutilisation efficace de la mémoire.

ColliderMesh

Les objets de scène permettent d’accéder aux données de maillage et de maillage de collision par le biais des propriétés Meshes et ColliderMeshes. Ces maillages correspondent toujours, ce qui signifie que l’index i’th de la propriété Meshes représente la même géométrie que l’index i’th de la propriété ColliderMeshes. Si le runtime/objet prend en charge les maillages de collisionneurs, vous êtes garanti d’obtenir le polygone le plus bas, l’approximation de l’ordre le plus élevé et il est recommandé d’utiliser ColliderMeshes où que votre application utilise des collisionneurs. Si le système ne prend pas en charge les collisionneurs, l’objet Mesh retourné dans ColliderMeshes est le même objet que le maillage réduisant les contraintes de mémoire.

Développement avec compréhension des scènes

À ce stade, vous devez comprendre les principaux blocs de construction du runtime et du SDK de compréhension de la scène. La majeure partie de la puissance et de la complexité réside dans les modèles d’accès, l’interaction avec les frameworks 3D et les outils qui peuvent être écrits sur ces API pour effectuer des tâches plus avancées telles que la planification spatiale, l’analyse des salles, la navigation, la physique, etc. Nous espérons les capturer dans des exemples qui devraient vous guider dans la bonne direction pour faire briller vos scénarios. S’il existe des exemples ou des scénarios dont nous n’avons pas besoin, faites-nous savoir et nous essayerons de documenter/prototyper ce dont vous avez besoin.

Où puis-je obtenir un exemple de code ?

L’exemple de code Scene Understanding pour Unity est disponible dans notre page Exemple de page Unity . Cette application vous permet de communiquer avec votre appareil et de restituer les différents objets de scène, ou vous permet de charger une scène sérialisée sur votre PC et de vous permettre d’expérimenter Scene Understanding sans appareil.

Où puis-je obtenir des exemples de scènes ?

Si vous avez un HoloLens2, vous pouvez enregistrer n’importe quelle scène que vous avez capturée en enregistrant la sortie de ComputeSerializedAsync dans un fichier et en la désérialisant à votre convenance.

Si vous n’avez pas d’appareil HoloLens2 mais que vous souhaitez jouer avec Scene Understanding, vous devez télécharger une scène pré-capturée. L’exemple Scene Understanding est fourni avec des scènes sérialisées qui peuvent être téléchargées et utilisées à votre convenance. Vous pouvez les trouver ici :

Exemples de scènes de compréhension des scènes

Voir aussi