Обзор пакета SDK для распознавания сцен

Понимание сцены преобразует данные датчика неструктурированной среды, которые захватывает устройство Смешанная реальность, и преобразует их в мощное абстрактное представление. Пакет SDK выступает в качестве уровня взаимодействия между приложением и средой выполнения Scene Understanding. Она предназначена для имитации существующих стандартных конструкций, таких как графы трехмерных сцен для трехмерных представлений, а также двухd-прямоугольники и панели для двухd-приложений. Хотя имитирующиеся конструкции Scene Understanding будут сопоставляться с конкретными платформами, в целом SceneUnderstanding не зависит от платформы, что позволяет взаимодействовать между различными платформами, которые взаимодействуют с ней. По мере развития осмысления сцены роль пакета SDK заключается в обеспечении предоставления новых представлений и возможностей в рамках единой платформы. В этом документе мы сначала познакомимся с высокоуровневыми понятиями, которые помогут вам ознакомиться со средой разработки и использованием, а затем предоставим более подробную документацию по конкретным классам и конструкциям.

Где получить пакет SDK?

Пакет SDK SceneUnderstanding можно скачать с помощью средства Смешанная реальность Feature Tool.

Примечание. Последний выпуск зависит от предварительных версий пакетов, и вам потребуется включить пакеты предварительной версии, чтобы увидеть его.

Для версии 0.5.2022-rc и более поздних версий осмысления сцен поддерживает языковые проекции для C# и C++, позволяя приложениям разрабатывать приложения для платформ Win32 или UWP. Начиная с этой версии SceneUnderstanding поддерживает unity в редакторе, за исключением SceneObserver, который используется исключительно для взаимодействия с HoloLens2.

Для SceneUnderstanding требуется Windows SDK версии 18362 или более поздней.

Общие сведения об основных понятиях

Сцена

Устройство смешанной реальности постоянно интегрирует сведения о том, что оно видит в вашей среде. Осмысление сцены направляет все эти источники данных и создает одну единую связную абстракцию. Распознавание сцен создает сцены, которые представляют собой композицию SceneObjects , представляющую экземпляр одной вещи (например, стену, потолок или пол). Объекты сцены сами являются композицией [SceneComponents, которые представляют более детализированные части, составляющие этот объект SceneObject. Примерами компонентов являются квадроциклы и сетки, но в будущем они могут представлять ограничивающие прямоугольники, сетки конфликтов, метаданные и т. д.

Процесс преобразования необработанных данных датчика в сцену — это потенциально дорогостоящая операция, которая может занять несколько секунд для средних пространств (~10x10 м) в минуты для больших пространств (~50 x 50 м), поэтому устройство не вычисляет его без запроса приложения. Вместо этого создание сцены активируется приложением по запросу. Класс SceneObserver имеет статические методы, которые могут вычислять или десериализовать сцену, которые затем можно перечислить или взаимодействовать с ними. Действие "Вычисление" выполняется по запросу и выполняется на ЦП, но в отдельном процессе (драйвер Смешанная реальность). Однако пока мы выполняем вычисления в другом процессе, полученные данные Сцены сохраняются и сохраняются в приложении в объекте Scene.

Ниже приведена схема, которая иллюстрирует этот поток процесса и показывает примеры двух приложений, взаимодействующих со средой выполнения Распознавания сцен.

Слева находится схема среды выполнения смешанной реальности, которая всегда включена и выполняется в собственном процессе. Эта среда выполнения отвечает за отслеживание устройств, пространственное сопоставление и другие операции, которые используются для понимания и анализа окружающего мира. В правой части диаграммы мы показываем два теоретических приложения, использующих осмысления сцены. Первое приложение взаимодействует с MRTK, который использует пакет SDK для распознавания сцены внутри организации, а второе приложение вычисляет и использует два отдельных экземпляра сцены. Все три сцены на этой схеме создают отдельные экземпляры сцен. Драйвер не отслеживает глобальное состояние, которое совместно используется приложениями, и объекты сцены в одной сцене не находятся в другой. Распознавание сцен предоставляет механизм отслеживания с течением времени, но это делается с помощью пакета SDK. Код отслеживания уже выполняется в пакете SDK в процессе приложения.

Так как каждая сцена хранит свои данные в пространстве памяти приложения, можно предположить, что все функции объекта Scene или его внутренние данные всегда выполняются в процессе приложения.

Layout

Для работы с осмысления сцен может быть полезно знать и понимать, как среда выполнения представляет компоненты логически и физически. Сцена представляет данные с определенным макетом, который был выбран для простоты, сохраняя при этом базовую структуру, которая может соответствовать будущим требованиям без необходимости серьезных изменений. Сцена делает это, сохраняя все компоненты (стандартные блоки для всех объектов сцены) в неструктурированном списке и определяя иерархию и композицию с помощью ссылок, где конкретные компоненты ссылались на другие.

Ниже приведен пример структуры как в плоской, так и в логической форме.

Логический макет	Физический макет
Сцена 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

На этом рисунке показано различие между физическим и логическим макетом сцены. Слева мы видим иерархический макет данных, который приложение видит при перечислении сцены. Справа мы видим, что сцена состоит из 12 отдельных компонентов, доступных по отдельности при необходимости. При обработке новой сцены мы ожидаем, что приложения логически обходят эту иерархию, однако при отслеживании между обновлениями сцены некоторые приложения могут быть заинтересованы только в конкретных компонентах, которые совместно используются между двумя сценами.

Обзор API

В следующем разделе представлен общий обзор конструкций в службе "Распознавание сцен". Из этого раздела вы получите представление о том, как представляются сцены и для чего используются различные компоненты. В следующем разделе приведены конкретные примеры кода и дополнительные сведения, которые смеются в этом обзоре.

Все типы, описанные ниже, находятся в Microsoft.MixedReality.SceneUnderstanding пространстве имен .

SceneComponents

Теперь, когда вы понимаете логическую структуру сцен, мы можем представить концепцию SceneComponents и то, как они используются для создания иерархии. SceneComponents — это наиболее детализированные декомпозиции в SceneUnderstanding, представляющие одну основную вещь, например сетку или четырехугольник или ограничивающий прямоугольник. SceneComponents — это вещи, которые могут обновляться независимо друг от друга, и на них могут ссылаться другие элементы SceneComponents, поэтому у них есть одно глобальное свойство, уникальный идентификатор, который позволяет использовать этот тип механизма отслеживания или ссылки. Идентификаторы используются для логической композиции иерархии сцены, а также для сохраняемости объектов (процесс обновления одной сцены относительно другой).

Если вы рассматриваете каждую вычисленную сцену как отдельную и просто перечисляете все данные в ней, то идентификаторы в значительной степени прозрачны для вас. Однако если вы планируете отслеживать компоненты в течение нескольких обновлений, вы будете использовать идентификаторы для индексирования и поиска SceneComponents между объектами Scene.

SceneObjects

SceneObject — это Объект SceneComponent, представляющий экземпляр "вещи", например, стену, пол, потолок и т. д. выражается свойством Kind. Объекты SceneObject являются геометрическими и, следовательно, имеют функции и свойства, представляющие их расположение в пространстве, однако они не содержат никакой геометрической или логической структуры. Вместо этого SceneObjects ссылаются на другие компоненты SceneComponents, в частности SceneQuads и SceneMeshes, которые предоставляют различные представления, поддерживаемые системой. При вычислении новой сцены приложение, скорее всего, перечислит объекты SceneObject для обработки интересующих его объектов.

SceneObjects может иметь любой из следующих вариантов:

SceneObjectKind	Описание
Историческая справка	SceneObject, как известно, не является одним из других распознаваемых типов объектов сцены. Этот класс не следует путать с Неизвестным, где фон, как известно, не является стеной, полом, потолком и т. д. пока неизвестно еще не классифицировано.
Стена	Физическая стена. Стены считаются недвижимыми экологическими сооружениями.
Этаж	Полы - это любые поверхности, по которым можно ходить. Примечание. Лестницы не являются этажами. Кроме того, обратите внимание, что на этажах предполагается любая проходимая поверхность и, следовательно, нет явного предположения о единственном полу. Многоуровневые структуры, пандусы и т. д.... все должны классифицироваться как этаж.
Ceiling	Верхняя поверхность комнаты.
Платформа	Большая плоская поверхность, на которой можно разместить голограммы. Они, как правило, представляют таблицы, столешницы и другие крупные горизонтальные поверхности.
World	Зарезервированная метка для геометрических данных, не зависящая от меток. Сетка, созданная при задании флага обновления EnableWorldMesh, будет классифицироваться как world.
Неизвестно	Этот объект сцены еще предстоит классифицировать и присвоить вид. Это не следует путать с Background, так как этот объект может быть чем угодно, система просто еще не придумала достаточно сильную классификацию для него.

SceneMesh

SceneMesh — это объект SceneComponent, который приблизительно определяет геометрию произвольных геометрических объектов с помощью списка треугольников. SceneMeshes используются в нескольких разных контекстах; они могут представлять компоненты структуры герметичной ячейки или как WorldMesh, который представляет собой несвязанную сетку пространственного сопоставления, связанную со сценой. Данные индекса и вершин, предоставляемые для каждой сетки, используют тот же привычный макет, что и буферы вершин и индексов , которые используются для отрисовки сеток треугольников во всех современных API-интерфейсах отрисовки. В службе "Распознавание сцен" сетки используют 32-разрядные индексы, и для некоторых модулей отрисовки может потребоваться разбить их на блоки.

Система порядка обмотки и координат

Ожидается, что все сетки, созданные службой "Распознавание сцен", будут возвращать сетки в Right-Handed системе координат с использованием порядка обмотки по часовой стрелке.

Примечание. Сборки ОС до 191105 могли иметь известную ошибку, из-за которой сетки World возвращались в Counter-Clockwise порядке обмотки, которая впоследствии была исправлена.

SceneQuad

SceneQuad — это объект SceneComponent, представляющий двухдовые поверхности, которые занимают трехмерный мир. SceneQuads можно использовать аналогично ARKit ARPlaneAnchor или ARCore Planes, но они предлагают более высокий уровень функциональности в виде двухмерных холстов, которые будут использоваться неструктурированными приложениями или дополненным пользовательским интерфейсом. 2D-интерфейсы API предоставляются для квадроциклов, которые упрощают размещение и макет, а разработка (за исключением отрисовки) с помощью четырехмерных холстов больше похожа на работу с двухмерными холстами, чем с трехмерными сетками.

Фигура SceneQuad

SceneQuads определяют ограниченную прямоугольную поверхность в 2d. Однако SceneQuads представляют поверхности с произвольными и потенциально сложными формами (например, таблица в форме кольцев). Чтобы представить сложную форму поверхности четырехугольника, можно использовать API GetSurfaceMask для отображения формы поверхности в предоставленном буфере изображений. Если объект SceneObject, имеющий четырехугольник, также имеет сетку, треугольники сетки должны быть эквивалентны этому изображению, они оба представляют реальную геометрию поверхности либо в двух- или трехмерных координатах.

Сведения и справочник по пакету SDK для распознавания сцен

Примечание

При использовании MRTK: Обратите внимание, что вы будете взаимодействовать с ['WindowsSceneUnderstandingObserver'](xref:Microsoft.MixedReality.Toolkit.WindowsSceneUnderstanding.Experimental.WindowsSceneUnderstandingObserver?view=mixed-reality-toolkit-unity-2020-dotnet-2.8.0&preserve-view=true), поэтому этот раздел может пропустить в большинстве случаев. Дополнительные сведения см. в [документации по распознаванию сцен MRTK](/windows/mixed-reality/mrtk-unity/features/spatial-awareness/scene-understanding).

Следующий раздел поможет вам ознакомиться с основами SceneUnderstanding. В этом разделе содержатся основные сведения. На этом этапе у вас должно быть достаточно контекста для просмотра примеров приложений, чтобы увидеть, как SceneUnderstanding используется целостно.

Инициализация

Первым шагом к работе с SceneUnderstanding является получение приложением ссылки на объект Scene. Это можно сделать одним из двух способов: сцену можно вычислить драйвером или десериализовать существующую сцену, вычисленную в прошлом. Последний полезен для работы со SceneUnderstanding во время разработки, где приложения и возможности можно быстро создавать прототипы без устройства смешанной реальности.

Сцены вычисляются с помощью SceneObserver. Перед созданием Сцены приложение должно запросить устройство, чтобы убедиться, что оно поддерживает SceneUnderstanding, а также запросить у пользователя доступ для получения сведений, необходимых SceneUnderstanding.

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

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

Если метод RequestAccessAsync() не вызывается, вычисление новой сцены завершится ошибкой. Далее мы вычислим новую сцену, которая коренится вокруг Смешанная реальность гарнитуры и имеет радиус 10 метров.

// 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();

Инициализация из данных (также известная как путь к КОМПЬЮТЕРу)

Хотя сцены можно вычислить для прямого использования, их также можно вычислить в сериализованной форме для последующего использования. Это оказалось полезным для разработки, так как позволяет разработчикам работать в службе "Распознавание сцен" и тестировать их без использования устройства. Процесс сериализации сцены почти идентичен ее вычислению. Данные возвращаются в приложение, а не десериализируются локально с помощью пакета SDK. Затем вы можете десериализовать его самостоятельно или сохранить для использования в будущем.

// 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

Теперь, когда у приложения есть сцена, приложение будет просматривать SceneObjects и взаимодействовать с ним. Для этого необходимо получить доступ к свойству SceneObjects :

SceneObject firstFloor = null;

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

Обновление и уточнение компонентов

Существует еще одна функция, которая извлекает компоненты в сцене с именем FindComponent. Эта функция полезна при обновлении объектов отслеживания и их поиске в последующих сценах. Следующий код вычисляет новую сцену относительно предыдущей сцены, а затем находит пол в новой сцене.

// 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
}

Доступ к сеткам и квадроциклам из объектов сцены

После того как SceneObjects будут найдены, приложение, скорее всего, захотите получить доступ к данным, содержащимся в четырехугольниках или сетках, из которых оно состоит. Доступ к этим данным осуществляется с помощью свойств Quads и Meshes . Следующий код перечисляет все квадроциклы и сетки объекта floor.

// 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
}

Обратите внимание, что это SceneObject, который имеет преобразование, которое относится к источнику Сцены. Это связано с тем, что SceneObject представляет экземпляр "вещи" и является locatable в пространстве, квадроциклы и сетки представляют геометрию, которая преобразуется относительно их родительского объекта. Отдельные объекты SceneObjects могут ссылаться на один и тот же SceneMesh/SceneQuad SceneComponents, а также возможно, что SceneObject содержит несколько SceneMesh/SceneQuad.

Работа с преобразованиями

Функция распознавания сцены предприняла преднамеренную попытку согласовать с традиционными представлениями трехмерной сцены при работе с преобразованиями. Таким образом, каждая сцена ограничена одной системой координат, как и большинство распространенных представлений трехмерной среды. Каждый объект SceneObject предоставляет свое расположение относительно этой системы координат. Если приложение работает со сценами, которые растягивают предел того, что предоставляет один источник, оно может привязать SceneObjects к SpatialAnchors или создать несколько сцен и объединить их вместе, но для простоты мы предполагаем, что ватеральные сцены существуют в собственном источнике, локализованном одним Идентификатором NodeId, определенным в Scene.OriginSpatialGraphNodeId.

Например, в следующем коде Unity показано, как использовать API Windows Perception и Unity для согласования систем координат. Дополнительные сведения об API распознавания Windows см. в разделах SpatialCoordinateSystem и SpatialGraphInteropPreview, а также Смешанная реальность собственные объекты в Unity, чтобы получить объект SpatialCoordinateSystem, соответствующий миру 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;
}

Каждый имеет SceneObject преобразование, которое затем применяется к данному объекту. В Unity мы преобразуем координаты правой руки и назначаем локальные преобразования следующим образом:

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

Квадроциклы были разработаны для поддержки двухD-сценариев размещения и должны рассматриваться как расширения для элементов пользовательского интерфейса на двухD-холсте. Хотя quads являются компонентами SceneObjects и могут быть отрисованы в трехмерном формате, сами API-интерфейсы Quad предполагают, что quads являются двухd-структурами. Они предоставляют такие сведения, как экстент, форма, и предоставляют API для размещения.

Квадроциклы имеют прямоугольные экстенты, но представляют собой поверхности произвольной формы. Чтобы включить размещение на этих двухD-поверхностях, взаимодействующих с трехмерной средой, можно использовать служебные программы, чтобы сделать это взаимодействие возможным. В настоящее время Служба распознавания сцен предоставляет две такие функции: FindCentermostPlacement и GetSurfaceMask. FindCentermostPlacement — это высокоуровневый API, который находит позицию на четырехугольнике, в которой можно разместить объект, и пытается найти наилучшее расположение для объекта, гарантируя, что предоставленный ограничивающий прямоугольник останется на базовой поверхности.

Примечание

Координаты выходных данных находятся относительно четырехугольника в "четырехугольнике", а верхний левый угол имеет значение (x = 0, y = 0), как и в случае с другими типами windows Rect. Обязательно учитывайте это при работе с источниками собственных объектов.

В следующем примере показано, как найти центральное расположение и привязать голограмму к четырехугольнику.

// 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)
            }
        }
    }
}

Шаги 1–4 в значительной степени зависят от конкретной платформы или реализации, но темы должны быть похожими. Важно отметить, что Quad просто представляет ограниченную двухd плоскость, локализованную в пространстве. Благодаря тому, что ваш обработчик или платформа знают, где находится четырехугольник, и корень объектов относительно этого четырехугольника, ваши голограммы будут правильно расположены относительно реального мира.

Сетка

Сетки представляют геометрические представления объектов или сред. Как и пространственное сопоставление, данные индекса сетки и вершин, предоставляемые для каждой сетки пространственной поверхности, используют тот же привычный макет, что и буферы вершин и индексов, которые используются для отрисовки сеток треугольников во всех современных API отрисовки. Позиции вершин указаны в системе координат объекта Scene. Ниже перечислены конкретные API, используемые для ссылки на эти данные.

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

В следующем коде приведен пример создания списка треугольников из структуры сетки:

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

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

Буферы индексов и вершин должны иметь >значение = число индексов и вершин, но в противном случае их размер может быть произвольным, что позволяет эффективно использовать память.

ColliderMesh

Объекты сцены предоставляют доступ к данным сетки и сетки коллайдера с помощью свойств Meshes и ColliderMeshes. Эти сетки всегда будут совпадать. Это означает, что i'й индекс свойства Meshes представляет ту же геометрию, что и i'й индекс свойства ColliderMeshes. Если среда выполнения или объект поддерживают сетки коллайдеров, вы гарантированно получите самый низкий многоугольник, наивысший порядок приближения и рекомендуется использовать ColliderMeshes везде, где приложение будет использовать коллайдеры. Если система не поддерживает коллайдеры, объект Mesh, возвращаемый в ColliderMeshes, будет тем же объектом, что и сетка, уменьшая ограничения памяти.

Разработка с пониманием сцены

На этом этапе необходимо понять основные стандартные блоки среды выполнения и пакета SDK для понимания сцены. Основная часть возможностей и сложности заключается в шаблонах доступа, взаимодействии с трехмерными платформами и средствах, которые можно написать на основе этих API для выполнения более сложных задач, таких как пространственное планирование, анализ помещений, навигация, физика и т. д. Мы надеемся записать их в примерах, которые, как мы надеемся, помогут вам в правильном направлении, чтобы ваши сценарии были блестящими. Если есть примеры или сценарии, которые мы не рассмотрим, сообщите нам, и мы попытаемся задокументировать или создать прототип того, что вам нужно.

Где можно получить пример кода?

Пример кода осмысления сцены для Unity можно найти на странице примеров Unity . Это приложение позволит вам взаимодействовать с устройством и отображать различные объекты сцены, а также загружать сериализованную сцену на компьютер и выполнять распознавание сцен без устройства.

Где можно получить примеры сцен?

Если у вас есть HoloLens2, вы можете сохранить любую захваченную сцену, сохранив выходные данные ComputeSerializedAsync в файл и десериализировав их по своему усмотрению.

Если у вас нет устройства HoloLens2, но вы хотите играть с осмысление сцены, необходимо скачать предварительно записанную сцену. В настоящее время в состав примера "Распознавание сцен" входит сериализованные сцены, которые можно скачать и использовать по своему усмотрению. Их можно найти здесь:

Пример сцены для распознавания сцен

См. также статью

• Пространственное сопоставление
• Интерпретация сцены
• Пример Unity