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

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

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

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

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

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

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

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

Сцена

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

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

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

Process Diagram

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

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

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 между объектами сцены.

SceneObjects

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

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

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

SceneMesh

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

Упорядочение и системы координат

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

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

SceneQuad

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

Фигура SceneQuad

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

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

Примечание

При использовании MRTK обратите внимание, что вы будете взаимодействовать с MRTK ['WindowsSceneUnderstandingObserver'](xref:Microsoft.MixedReality.набор средств. WindowsSceneUnderstanding.Experimental.WindowsSceneUnderstandingObserver) и, следовательно, может пропустить этот раздел в большинстве случаев. Дополнительные сведения см. в [документации по распознаванию сцен 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 представляет экземпляр "вещи" и является неуместимым в пространстве, квадроциклы и сетки представляют геометрию, которая преобразуется относительно их родительского объекта. Для отдельных sceneObjects можно ссылаться на один и тот же Объект SceneMesh/SceneQuad SceneComponents, и также возможно, что объект SceneObject имеет несколько SceneMesh/SceneQuad.

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

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

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

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

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

Примечание

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

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

// 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 просто представляет ограниченную 2D-плоскость, локализованную в пространстве. Если подсистема или платформа знают, где находится четырехугольник и корня объектов относительно четырехугольника, голограммы будут расположены правильно в отношении реального мира.

Сетка

Сетки представляют геометрические представления объектов или сред. Подобно пространственному сопоставлению, индексу сетки и данным вершин, предоставляемым каждой пространственной сеткой поверхности, используется тот же знакомый макет, что и буферы вершин и индексов, используемые для отрисовки сетки треугольников во всех современных 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, но вы хотите играть с приложением Scene Understanding, вам потребуется скачать предварительно захваченную сцену. Пример "Основные сведения о сценах" в настоящее время поставляется с сериализованными сценами, которые можно скачать и использовать по своему усмотрению. Их можно найти здесь:

Основные сведения о сценах

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