Vue d’ensemble du KIT de développement logiciel (SDK) Scene Understanding
La compréhension des scènes transforme les données de capteur d’environnement non structurées que votre Mixed Reality appareil capture et les convertit en une représentation abstraite puissante. Le KIT de développement logiciel (SDK) sert de couche de communication entre votre application et le runtime Scene Understanding. Il vise à imiter les constructions standard existantes, telles que les graphiques de scène 3D pour les représentations 3D, et les rectangles et panneaux 2D pour les applications 2D. Alors que les constructions des mimiques Scene Understanding seront mappées à des frameworks concrets, en général, SceneUnderstanding est indépendant du framework, ce qui permet l’interopérabilité entre diverses infrastructures qui interagissent avec elle. À mesure que Scene Understanding évolue, le rôle du SDK est de s’assurer que les nouvelles représentations et fonctionnalités continuent d’être exposées au sein d’une infrastructure unifiée. Dans ce document, nous allons d’abord introduire des concepts généraux qui vous aideront à vous familiariser avec l’environnement de développement/l’utilisation, puis nous fournirons 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 de préversion pour la voir.
Pour les versions 0.5.2022-rc et ultérieures, Scene Understanding prend en charge les projections de langage pour C# et C++, ce qui permet aux applications de développer des applications pour les plateformes Win32 ou UWP. À partir de cette version, SceneUnderstanding prend en charge la prise en charge de l’unité dans l’éditeur, à l’exception de SceneObserver, qui est utilisé uniquement pour la communication avec HoloLens2.
SceneUnderstanding nécessite le Kit de développement logiciel (SDK) Windows version 18362 ou ultérieure.
Vue d'ensemble conceptuelle
La scène
Votre appareil de réalité mixte intègre constamment des informations sur ce qu’il voit dans votre environnement. Scene Understanding entonnoir toutes ces sources de données et produit une seule abstraction cohésive. 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 sont eux-mêmes une composition de [SceneComponents, qui représentent des éléments plus granulaires qui composent cet objet SceneObject. Des exemples de composants sont les quads et les maillages, mais à l’avenir pourraient représenter des zones englobantes, des maillages de collision, des métadonnées, etc.
Le processus de conversion des données brutes du capteur en une 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 par conséquent, 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ènes 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, que vous pouvez ensuite énumérer/interagir avec. L’action « Calcul » est exécutée à la demande et s’exécute sur le processeur, mais dans un processus distinct (le pilote Mixed Reality). Toutefois, pendant que nous calculons dans un autre processus, les données Scene obtenues sont stockées et conservées dans votre application dans l’objet Scene.
Vous trouverez ci-dessous un diagramme illustrant ce flux de processus et montrant des exemples de deux applications interfaçage avec le runtime Scene Understanding.
Sur le côté gauche se trouve un diagramme du runtime de réalité mixte, qui est toujours actif et s’exécute 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 qui vous entoure. Sur le côté droit du diagramme, nous montrons deux applications théoriques qui utilisent Scene Understanding. La première application s’interface avec MRTK, qui utilise le Kit de développement logiciel (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 partagé entre les applications et les objets de scène d’une scène ne se trouvent pas dans une autre. Scene Understanding fournit un mécanisme pour effectuer le suivi au fil du temps, mais cela se fait à l’aide du KIT de développement logiciel (SDK). Le code de suivi est déjà en cours d’exécution dans le 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 de ses données internes sont toujours exécutées dans le processus de votre application.
Layout
Pour utiliser Scene Understanding, il peut être utile de savoir et de comprendre comment le runtime représente les composants de manière logique et physique. 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 flexible pour répondre aux exigences futures sans nécessiter de révisions majeures. Pour ce faire, la scène stocke tous les composants (blocs de construction de tous les objets de scène) dans une liste plate et définit 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.
Nous présentons ci-dessous un exemple de structure dans sa forme plate et logique.
| Disposition logique | Disposition physique |
|---|---|
|
|
Cette illustration met en évidence la différence entre la disposition physique et logique de la scène. Sur la 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 voyons 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 suivent logiquement cette hiérarchie. Toutefois, lors du suivi entre les mises à jour de scène, certaines applications peuvent uniquement être intéressées par le ciblage de composants spécifiques qui sont 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 permet de comprendre comment les scènes sont représentées et ce pour quoi les différents composants font/sont utilisés. La section suivante fournit des exemples de code concrets et des détails supplémentaires qui sont occultés dans cette vue d’ensemble.
Tous les types décrits ci-dessous résident dans l’espace de Microsoft.MixedReality.SceneUnderstanding noms.
SceneComponents
Maintenant que vous comprenez la disposition logique des scènes, nous pouvons présenter le concept de SceneComponents et la façon dont ils sont utilisés pour composer la hiérarchie. SceneComponents sont les décompositions les plus granulaires dans SceneUnderstanding représentant une seule chose de cœur, par exemple, un maillage ou un quad ou un cadre englobant. Les sceneComponents sont des éléments qui peuvent être mis à jour indépendamment et peuvent être référencés par d’autres SceneComponents. Ils ont donc une propriété globale unique, un ID unique, qui autorise ce type de mécanisme de suivi/référencement. Les ID sont utilisés pour la composition logique de la hiérarchie de scène ainsi que pour la persistance des objets (le fait de mettre à jour 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 qu’elle contient, les ID sont en grande partie transparents pour vous. Toutefois, si vous envisagez de suivre les composants sur plusieurs mises à jour, vous utiliserez les ID pour indexer et rechercher des SceneComponents entre les objets Scene.
SceneObjects
Un objet SceneObject est un SceneComponent qui représente un instance d’une « chose », par exemple un mur, un plancher, un plafond, etc. exprimé par leur propriété Kind. Les sceneObjects sont géométriques et ont 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 qui l’intéresse.
SceneObjects peut avoir l’un des éléments suivants :
| SceneObjectKind | Description |
|---|---|
| Arrière-plan | L’objet SceneObject 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 Unknown où l’arrière-plan est connu pour ne pas être mur/plancher/plafond, etc. alors qu’inconnu n’est pas encore classé. |
| Wall | Un mur physique. Les murs sont supposés être des structures environnementales immuables. |
| Floor | Les planchers sont toutes les surfaces sur lesquelles on peut marcher. Remarque : les escaliers ne sont pas des étages. Notez également que les étages supposent toute surface accessible à pied et qu’il n’y a donc pas d’hypothèse explicite d’un plancher singulier. Structures multiniveaux, rampes, etc. doivent tous être classés comme plancher. |
| Ceiling | Surface supérieure d’une pièce. |
| Plateforme | Grande surface plane sur laquelle vous pouvez placer des hologrammes. Ceux-ci ont tendance à représenter des tables, des comptoirs et d’autres grandes surfaces horizontales. |
| World (Monde) | Étiquette réservée pour les données géométriques qui est indépendante de l’étiquetage. Le maillage généré par la définition de l’indicateur de mise à jour EnableWorldMesh serait classé comme world. |
| Unknown | Cet objet de scène n’a pas encore été classé et affecté à un type. Cela ne doit pas être confondu avec l’arrière-plan, car cet objet pourrait être n’importe quoi, le système n’a tout simplement pas encore trouvé une classification suffisamment forte pour lui. |
SceneMesh
Un SceneMesh est un SceneComponent qui se rapproche de la géométrie d’objets géométriques arbitraires à l’aide d’une liste de triangles. Les sceneMeshes sont utilisés 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 tampons de vertex et d’index utilisés pour le rendu des maillages triangles dans toutes les API de rendu modernes. Dans Scene Understanding, les maillages utilisent des index 32 bits et peuvent devoir être divisés en blocs pour certains moteurs de rendu.
Ordre de re winding 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 d’un ordre de bobage dans le sens des aiguilles d’une montre.
Remarque : les builds du système d’exploitation antérieures à .191105 peuvent présenter un bogue connu dans lequel les maillages « World » revenaient dans Counter-Clockwise ordre de re winding, qui a ensuite été corrigé.
SceneQuad
Un SceneQuad est un SceneComponent qui représente des surfaces 2D qui occupent le monde 3D. Les sceneQuads peuvent être utilisés de la même manière que les plans ARKit ARPlaneAnchor ou ARCore, mais ils offrent des fonctionnalités de plus haut niveau comme des canevas 2D à utiliser par des applications plates ou une expérience utilisateur augmentée. Les API spécifiques 2D sont fournies pour les quads qui rendent l’emplacement et la disposition simples à utiliser, et le développement (à l’exception du rendu) avec des quads doit être plus semblable à travailler avec des canevas 2D que des maillages 3D.
Forme SceneQuad
Les scènesQuads définissent une surface rectangulaire délimitée en 2d. Toutefois, les SceneQuads représentent des surfaces avec des formes arbitraires et potentiellement complexes (par exemple, une table en forme de beignet). Pour représenter la forme complexe de la surface d’un quad, vous pouvez utiliser l’API GetSurfaceMask pour restituer la forme de la surface sur une mémoire tampon d’image que vous fournissez. Si l’objet SceneObject qui a le quad a également un maillage, les triangles de maillage doivent être équivalents à cette image rendue, ils représentent tous deux la géométrie réelle de la surface, soit en coordonnées 2d ou 3d.
Détails et référence du Kit de développement logiciel (SDK) De compréhension des scènes
Notes
Lors de l’utilisation de MRTK, Notez que vous allez interagir avec mrTK ['WindowsSceneUnderstandingObserver'](xref:Microsoft.MixedReality.Toolkit.WindowsSceneUnderstanding.Experimental.WindowsSceneUnderstandingObserver?view=mixed-reality-toolkit-unity-2020-dotnet-2.8.0&preserve-view=true) et peut donc ignorer cette section dans la plupart des cas. Pour plus d’informations, reportez-vous aux [documents 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, auquel moment vous devez disposer de suffisamment de contexte pour parcourir les exemples d’applications pour voir comment SceneUnderstanding est utilisé de manière holistique.
Initialisation
La première étape de l’utilisation de SceneUnderstanding consiste à ce que votre application obtienne une référence à un objet Scene. Cela peut être effectué de l’une des deux manières suivantes : 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 sérialisée. Ce dernier est utile pour travailler avec SceneUnderstanding pendant le développement, où les applications et les expériences peuvent être rapidement prototypes sans appareil de réalité mixte.
Les scènes sont calculées à l’aide d’un serveur SceneObserver. Avant de créer une scène, votre application doit interroger votre appareil pour s’assurer qu’il prend en charge SceneUnderstanding, ainsi que pour demander l’accès utilisateur 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. Nous allons ensuite calculer une nouvelle scène qui est enracinée autour du casque Mixed Reality et 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 PC)
Bien que les scènes puissent être calculées pour une 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. Le fait de sérialiser une scène est presque identique à son calcul. Les données sont retournées à votre application au lieu d’être désérialisées localement par le SDK. Vous pouvez ensuite le 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 dispose d’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 redéfinition 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 d’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 l’étage 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 SceneObjects trouvés, votre application voudra probablement accéder aux données contenues dans les quads/maillages dont 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 que c’est l’objet SceneObject qui a la transformation relative à l’origine de la scène. Cela est dû au fait que l’objet SceneObject représente une instance d’une « chose » et qu’il est locatable dans l’espace, que les quads et les maillages représentent la géométrie qui est transformée par rapport à leur parent. Il est possible que des SceneObjects distincts référencent les mêmes SceneMesh/SceneQuad SceneComponents, et il est également possible qu’un Objet SceneObject ait plusieurs SceneMesh/SceneQuad.
Gestion des transformations
Scene Understanding a tenté délibérément de s’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 la plupart des représentations environnementales 3D courantes. Les sceneObjects fournissent chacun leur emplacement par rapport à ce système de coordonnées. Si votre application traite de scènes qui étendent la limite de ce qu’une seule origine fournit, elle peut ancrer SceneObjects sur SpatialAnchors, ou générer plusieurs scènes et les fusionner, mais par souci de simplicité, nous supposons que les scènes étanches existent dans leur propre origine localisée par un NodeId défini par Scene.OriginSpatialGraphNodeId.
Le code Unity suivant, par exemple, montre comment utiliser la perception Windows et les API Unity pour aligner les systèmes de coordonnées entre eux. Pour plus d’informations sur les API De perception Windows, consultez SpatialCoordinateSystem et SpatialGraphInteropPreview et Mixed Reality des objets natifs dans Unity pour plus d’informations sur l’obtention d’un SpatialCoordinateSystem qui correspond à l’origine mondiale d’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 faciliter les scénarios de placement 2D et doivent être considérés comme des extensions des éléments d’expérience utilisateur de canevas 2D. Alors que les Quads sont des composants de SceneObjects et peuvent être rendus en 3D, les API Quad elles-mêmes 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 de forme arbitraire. Pour activer le placement sur ces surfaces 2D qui interagissent avec l’environnement 3D, les quads 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 le cadre englobant que vous fournissez restera sur la surface sous-jacente.
Notes
Les coordonnées de la sortie sont relatives au quad dans « quad space », le coin supérieur gauche étant (x = 0, y = 0), comme il le serait avec d’autres types windows Rect. Veillez à en tenir compte lorsque vous travaillez avec les origines de vos propres objets.
L’exemple suivant montre comment trouver l’emplacement le plus central et ancrer un hologramme au 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é qui est localisé dans l’espace. En faisant savoir à votre moteur/framework où se trouve le quad et en rootant vos objets par rapport au quad, vos hologrammes seront localisés correctement par rapport au monde réel.
Maillage
Les maillages représentent des représentations géométriques d’objets ou d’environnements. Tout comme le mappage spatial, les données d’index de maillage et de vertex fournies avec chaque maillage de surface spatiale utilisent la même disposition familière que les tampons de vertex et d’index utilisés pour le rendu des maillages de triangles 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 index/vertex doivent être >= le nombre 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 scene permettent d’accéder aux données de maillage et de maillage de collisionneur via les propriétés Meshes et ColliderMeshes. Ces maillages correspondent toujours, ce qui signifie que l’index i’ième de la propriété Meshes représente la même géométrie que l’i’ième index de la propriété ColliderMeshes. Si le runtime/objet prend en charge les maillages de collisionneurs, vous êtes assuré d’obtenir le polygone le plus bas, l’approximation de l’ordre le plus élevé et il est recommandé d’utiliser ColliderMeshes partout où votre application utiliserait des collisionneurs. Si le système ne prend pas en charge les collisionneurs, l’objet Mesh retourné dans ColliderMeshes sera le même objet que le maillage réduisant les contraintes de mémoire.
Développement avec la 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 que nous n’abordons pas, faites-le 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 sur notre page d’exemple de page Unity . Cette application vous permettra de communiquer avec votre appareil et de restituer les différents objets de scène, ou vous permettra de charger une scène sérialisée sur votre PC et de faire l’expérience de Scene Understanding sans appareil.
Où puis-je obtenir des exemples de scènes ?
Si vous disposez d’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 lire avec Scene Understanding, vous devez télécharger une scène pré-capturée. L’exemple Scene Understanding est actuellement 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