Toggle search
Toggle menu
4.8K
5.5K
229
46.5K
VR & AR Wiki
Toggle preferences menu
Toggle personal menu
Not logged in
Your IP address will be publicly visible if you make any edits.

Plane detection

From VR & AR Wiki
More actions

Plane detection is the process by which an augmented reality (AR) or mixed reality system finds flat surfaces in the user's surroundings, such as floors, tables, walls and ceilings, and reports each one to applications as a tracked plane with a position, an orientation and an approximate boundary. Google's ARCore documentation describes the basic method on phones: the system "looks for clusters of feature points that appear to lie on common horizontal or vertical surfaces, like tables or walls, and makes these surfaces available to your app as geometric planes".[1] The W3C draft that brings the feature to the web says it "enables apps to receive the set of planes detected by the native XR devices".[2]

AR apps use detected planes to decide where to put virtual objects: a model is set on a detected floor or tabletop, a virtual picture is hung on a detected wall, and a tap on the screen is converted into a 3D point by casting a ray against the known planes.[1][3] The capability reached phones through ARKit (2017, horizontal planes) and the ARCore preview (2017), gained vertical planes in 2018, and is also exposed by visionOS, Android XR, Meta Horizon OS, WebXR and OpenXR.[4][3] In research, finding planes in images and point clouds predates consumer AR by decades and draws on robust model fitting such as RANSAC, published by Martin Fischler and Robert Bolles in 1981.[5]

Reviewed 29 September 2026. Checked every cited claim against its source: ARKit, ARCore, visionOS, Jetpack XR, Meta, Microsoft, WebXR, OpenXR and Unity documentation, news reports, and paper metadata and text for RANSAC, PTAM, Simon et al., Efficient RANSAC, Feng et al., Dense Planar SLAM, PlaneNet, PlaneRCNN and Maneli and Isafiade. About review dates.

Definition

A detected plane is usually represented by three pieces of data: a pose, an extent and a boundary. In Apple's ARKit, each surface is reported as an ARPlaneAnchor; the width and length of the plane span the anchor's local x-z plane, and "the y-axis of the plane anchor is the plane's normal vector".[6] Google's ARCore uses the same convention: a Plane "describes the current best knowledge of a real-world planar surface", its center pose has the +Y axis pointing along the plane normal, and it carries X and Z extents of a bounding rectangle plus the 2D vertices of "a convex polygon approximating the detected plane".[7] The WebXR draft defines an XRPlane with a planeSpace whose Y axis is the plane normal, a polygon of vertices, an orientation of "horizontal" or "vertical" (or null when it cannot be classified), a lastChangedTime and an optional semanticLabel.[2]

Plane estimates change as the device sees more of the room. ARKit "continually updates its estimates of each detected plane's shape and extent", and offers both a rectangular estimate (extent and center) and a convex polygon tightly enclosing all points it currently estimates to be part of the plane.[8] When two ARCore planes turn out to be the same surface they are merged, and the older one reports "the non-subsumed plane that this one has been merged into".[7]

Most systems sort planes by orientation relative to gravity. ARKit's options are horizontal ("planar surfaces that are perpendicular to gravity") and vertical ("surfaces that are parallel to gravity").[9] ARCore distinguishes horizontal upward-facing planes ("floor or tabletop"), horizontal downward-facing planes ("a ceiling") and vertical planes ("a wall").[10] The OpenXR spatial plane tracking extension adds a fourth alignment, "arbitrary", for planes that are neither horizontal nor vertical.[11] Many platforms also attach a semantic class, such as floor, wall, ceiling or table, which overlaps with the broader field of scene understanding.

How it works

Planes from sparse feature points

On phones and headsets without depth sensors, plane detection runs on top of the visual tracking system. ARCore's motion tracking uses the camera to find "visually distinct features", and its environmental understanding then groups those feature points into planes.[1] When Google announced ARCore in August 2017, it said the SDK "can detect horizontal surfaces using the same feature points it uses for motion tracking".[12] This ties plane detection to visual-inertial odometry and SLAM: the same sparse 3D map used to estimate the device pose supplies the points that are fitted to planes.

The dependence on feature points is the method's main weakness. Google's documentation warns that "flat surfaces without texture, such as a white wall, may not be detected properly".[1] When ARCore added vertical planes in 2018, Google described them as a way to place objects on "textured walls".[3]

Robust fitting

A common way to fit a plane to noisy 3D points is RANSAC: repeatedly pick a minimal random sample, form a model hypothesis, and keep the hypothesis that the most remaining points agree with. Fischler and Bolles introduced the method as a way of fitting models to data "containing a significant percentage of gross errors", which suits the output of error-prone feature detectors.[5] The AR tracker PTAM (Parallel Tracking and Mapping), presented by Georg Klein and David Murray at ISMAR 2007, used this directly. After building its initial map, PTAM finds the dominant plane by RANSAC, choosing many random sets of three points to hypothesise a plane and testing the remaining points for consensus; the winning plane is refined from the mean and covariance of its inliers, with the smallest eigenvector of the covariance matrix taken as the plane normal. The map is then rotated so that this plane lies at z=0, and it becomes the virtual ground plane on which the system's AR game characters move.[13]

Ruwen Schnabel, Roland Wahl and Reinhard Klein's 2007 "Efficient RANSAC" extended random sampling to unorganized point clouds, detecting planes, spheres, cylinders, cones and tori, and reported that point sets with several million samples could be decomposed in under a minute.[14]

Planes from depth data

Depth sensors produce dense, organized point clouds, which allow faster region-based methods. Chen Feng, Yuichi Taguchi and Vineet Kamat (ICRA 2014) split a Kinect-style point cloud into small cells, merged neighbouring cells that fit the same plane by agglomerative hierarchical clustering, and refined the result with pixel-wise region growing; they reported detecting all major planes at more than 35 Hz on 640x480 point clouds.[15] On consumer AR hardware, MacRumors reported at the ARKit 3.5 release in March 2020 that the LiDAR Scanner on iPad Pro "enables incredibly quick plane detection, allowing for the instant placement of AR objects in the real world without scanning"; Apple said instant AR placement worked on iPad Pro without developers writing new code.[16][17]

Learned plane detection

Neural networks can infer planes from a single RGB image. PlaneNet (Chen Liu and colleagues, CVPR 2018) predicts a set of plane parameters and segmentation masks directly from one image, using more than 50,000 piece-wise planar depth maps that the authors generated from the ScanNet RGB-D video database for training and testing.[18] Its successor PlaneRCNN (CVPR 2019) uses a variant of Mask R-CNN to detect planes with their parameters and masks, then refines the masks with a loss that enforces consistency with a nearby view during training; the authors named augmented reality and virtual reality among the intended applications.[19]

History

Research systems

Early AR research used planes for camera tracking. In 2000 Gilles Simon, Andrew Fitzgibbon and Andrew Zisserman of the University of Oxford described a markerless AR camera tracker for scenes containing one or more planes, noting that "the tracked plane imposes a natural reference frame" for aligning real and virtual coordinates. Their system could detect the plane automatically: running RANSAC over matched interest points across the whole image returns the homography of the largest set of coplanar points, so the user did not need to mark the plane if it was the largest one in view.[20]

PTAM (2007) generalized the approach: it built a map of thousands of point features with no planarity assumption and then extracted a dominant plane from that map for AR content. Klein and Murray described the aim as turning "any flat (and reasonably textured) surface into a playing field".[13]

With RGB-D cameras, research moved to mapping complete planar regions. Dense Planar SLAM, presented by Renato Salas-Moreno, Ben Glocker, Paul Kelly and Andrew Davison at ISMAR 2014, detects bounded planar regions of arbitrary shape (including holes where an object sits on a table) and grows and joins them over time, storing their extent in a 2D occupancy map.[21][22] In an AR demonstration the user chose planes to be covered with application windows, shown through an Oculus Rift paired with an Xtion depth sensor. The thesis suggested the same technique for see-through headsets, where large projections on planes could replace small floating widgets without obstructing the wearer's field of view, which the thesis called a limiting factor of the Google Glass of the time.[22]

Consumer platforms

Apple announced ARKit on 5 June 2017 as part of its iOS 11 preview, and the framework became available with iOS 11.[23][24] The first release offered only horizontal plane detection, which in TechCrunch's words allowed developers "to know where the 'floor' is".[4] Plane detection is off by default and is enabled through a configuration option; the vertical option and the polygonal plane geometry arrived with iOS 11.3.[24][9][25] Announced in January 2018 as ARKit 1.5, that update let apps "recognize vertical surfaces and place objects onto those surfaces" and improved recognition of irregularly shaped surfaces such as round tables.[4] iOS 12 added plane classification (wall, floor, ceiling, table, seat, door and window) on supported devices.[26]

Google released the ARCore preview on 29 August 2017 for Pixel phones and the Samsung Galaxy S8, with horizontal surface detection as one of its three core capabilities.[12] At Google I/O in May 2018 the company announced vertical plane detection alongside Cloud Anchors and Augmented Images; 9to5Google reported the features as part of ARCore 1.2.[3][27] ARCore's configuration lets an app enable horizontal planes, vertical planes, both, or neither.[28]

Head-mounted systems took a room-level approach. Microsoft's Scene Understanding for HoloLens 2 (not available on the first-generation HoloLens) computes "SceneQuads", flat surfaces "on which holograms can be placed", and can infer quad areas that were not fully scanned; Microsoft positions it as a simpler, structured alternative to the raw spatial mapping mesh.[29] On Meta Quest headsets, planes come from a stored Scene Model rather than live per-app detection: users capture their room in Space Setup, and the system represents it as anchors with semantic labels "such as the floor, the ceiling, walls, a table, and a couch".[30] Meta lists Scene support on Meta Quest 2, Meta Quest Pro and Meta Quest 3 with system software version 40 or later.[31] With assisted Space Setup the headset runs a quick 3D scan that creates "a simple representation of the surfaces in your room, including walls, tables and other furniture".[32] MIXED reported in April 2024 that Quest 3's Space Setup, which previously detected only walls automatically, began outlining and labeling furniture after the v64 update, though complex wall structures and some large objects were still missed.[33]

On Apple Vision Pro, ARKit for visionOS provides a PlaneDetectionProvider, available since visionOS 1.0, which delivers PlaneAnchor objects for horizontal and vertical planes; a slanted alignment was added in visionOS 2.0.[34][35][36] Each plane comes with a classification such as table or floor, and plane detection requires the user to grant world-sensing authorization.[37] On Android XR, Jetpack XR's ARCore library disables plane tracking by default; an app enables it with PlaneTrackingMode.HORIZONTAL_AND_VERTICAL, needs the android.permission.SCENE_UNDERSTANDING_COARSE runtime permission, and receives planes labeled wall, floor, ceiling or table.[38]

Web and cross-platform standards

The WebXR Plane Detection Module lets web pages request the "plane-detection" feature and read the planes still being tracked in each frame through XRFrame.detectedPlanes. As of its 30 March 2026 Editor's Draft it is edited by Alex Cooper of Google and Rik Cabanier of Meta.[2] Chromium engineers announced an origin trial of the API for Chrome 91 to 92 in March 2021, limited to Android because of device support.[39] In the Meta Quest Browser, detected planes come from the user's room setup, and Meta's documentation says that for now these polygons "are always horizontal or vertical rectangles on Meta Quest headsets".[40] Google's list of WebXR features supported by Chrome on Android XR, updated in August 2026, does not include plane detection.[41]

In OpenXR, plane detection was first offered through the unratified XR_EXT_plane_detection extension (extension number 430), which the registry now marks as deprecated by XR_EXT_spatial_plane_tracking.[42] The Khronos Group released that extension as part of its Spatial Entities set on 10 June 2025, describing the set as enabling "consistent cross-platform support for plane and marker detection and tracking, precise spatial anchors, and cross-session persistence"; the announcement carried statements of support from PICO, Collabora, Godot, Google, Meta, Unity and Varjo.[43] The registry lists XR_EXT_spatial_plane_tracking as ratified, with semantic labels for floor, wall, ceiling and table plus an "uncategorized" value.[44][45] In Unity, AR Foundation wraps the native APIs in an ARPlaneManager that creates an ARPlane trackable for each detected plane, with providers for ARCore, ARKit, visionOS, Unity OpenXR: Meta and XR Simulation.[46][47]

Platform comparison

Platform Interface Orientations reported Semantic labels
ARKit (iOS, iPadOS) ARPlaneAnchor via planeDetection[6] Horizontal (iOS 11.0), vertical (iOS 11.3)[9] Wall, floor, ceiling, table, seat, door, window (iOS 12, supported devices)[26]
ARCore (Android) Plane via PlaneFindingMode[28] Horizontal upward, horizontal downward, vertical[10] Not part of the plane type
ARKit for visionOS PlaneDetectionProvider, PlaneAnchor[34] Horizontal, vertical; slanted (visionOS 2.0)[36] Ceiling, door, floor, seat, table, wall, window[37]
Jetpack XR (Android XR) Plane via PlaneTrackingMode[38] Horizontal and vertical Wall, floor, ceiling, table
Meta Scene (Meta Horizon OS) Scene anchors from Space Setup[30] Room planes (floor, ceiling, walls) Floor, ceiling, walls, table, couch and others
WebXR Plane Detection Module XRFrame.detectedPlanes[2] Horizontal, vertical, or null Optional semanticLabel string
OpenXR XR_EXT_spatial_plane_tracking Spatial entity components[44] Horizontal upward, horizontal downward, vertical, arbitrary[11] Uncategorized, floor, wall, ceiling, table[45]

Applications in VR and AR

Placing content is the core use. Apple's visionOS guide describes flat surfaces as "an ideal place to position content" and suggests filtering planes by size, distance from the user, orientation or class; its example detects horizontal and vertical planes but ignores those classified as windows.[37] ARCore combines planes with hit testing: it projects a ray from a screen coordinate into the camera view and returns the planes or feature points it intersects, and apps create anchors at those hits so that content stays in place as the system's understanding of the room improves.[1] On Android XR the same hit test can be filtered for a specific label, for example the first plane labeled as a table.[38]

Headset mixed reality uses planes for room-aware content. Meta's documentation describes the Scene Model as usable for physics, occlusion and navigation, and Microsoft describes placement, occlusion, physics and navigation as core scenarios for Scene understanding, with SceneQuads designed for placement and watertight meshes aimed at physics and navigation.[30][29] The Dense Planar SLAM work showed walls and other surfaces used as large display areas for applications, an approach its author proposed for see-through head-mounted displays.[22]

Research and evaluation

Independent tests have compared phone implementations. In a 2023 IST-Africa conference paper, Mfundo Maneli and Omowunmi Isafiade tested ARCore and ARKit plane detection on several Android and Apple phones under different lighting conditions and found ARKit "on average more reliable and accurate at plane detection and mapping", with a 14.84% computational optimization lead, while ARCore used RAM more efficiently.[48]

Privacy

Plane data describes the shape of a user's home or workplace, so platforms gate it. The WebXR draft lists mitigations a browser can apply: "decreasing the level of detail of the plane's polygon", quantizing plane poses, or "removing the plane altogether" when it is too small or too detailed.[2] visionOS requires world-sensing authorization before an app can use plane detection, and Android XR requires the scene-understanding runtime permission.[37][38]

See also

References

  1. ↑ 1.0 1.1 1.2 1.3 1.4 "Fundamental concepts - ARCore". Google for Developers. Google. https://developers.google.com/ar/develop/fundamentals. Retrieved 2026-09-29.
  2. ↑ 2.0 2.1 2.2 2.3 2.4 Alex Cooper, Rik Cabanier (2026-03-30). "WebXR Plane Detection Module (Editor's Draft, 30 March 2026)". Immersive Web Working Group. W3C. https://immersive-web.github.io/plane-detection/. Retrieved 2026-09-29.
  3. ↑ 3.0 3.1 3.2 3.3 Anuj Gosalia (2018-05-08). "Experience augmented reality together with new updates to ARCore". The Keyword. Google. https://blog.google/products/google-ar-vr/experience-augmented-reality-together-new-updates-arcore/. Retrieved 2026-09-29.
  4. ↑ 4.0 4.1 4.2 Matthew Panzarino (2018-01-24). "Apple's augmented reality tool kit can now detect walls and 2D images in beta". TechCrunch. https://techcrunch.com/2018/01/24/apples-augmented-reality-tool-kit-can-now-detect-walls-and-2d-images-in-beta. Retrieved 2026-09-29.
  5. ↑ 5.0 5.1 Martin A. Fischler, Robert C. Bolles (1981-06). "Random sample consensus: a paradigm for model fitting with applications to image analysis and automated cartography". Communications of the ACM, vol. 24, no. 6, pp. 381-395. doi:10.1145/358669.358692. https://doi.org/10.1145/358669.358692. Retrieved 2026-09-29.
  6. ↑ 6.0 6.1 "ARPlaneAnchor". Apple Developer Documentation. Apple. https://developer.apple.com/documentation/arkit/arplaneanchor. Retrieved 2026-09-29.
  7. ↑ 7.0 7.1 "Plane - ARCore Java API reference". Google for Developers. Google. https://developers.google.com/ar/reference/java/com/google/ar/core/Plane. Retrieved 2026-09-29.
  8. ↑ "Tracking and visualizing planes". Apple Developer Documentation. Apple. https://developer.apple.com/documentation/arkit/tracking-and-visualizing-planes. Retrieved 2026-09-29.
  9. ↑ 9.0 9.1 9.2 "vertical - ARWorldTrackingConfiguration.PlaneDetection". Apple Developer Documentation. Apple. https://developer.apple.com/documentation/arkit/arworldtrackingconfiguration/planedetection-swift.struct/vertical. Retrieved 2026-09-29.
  10. ↑ 10.0 10.1 "Plane.Type - ARCore Java API reference". Google for Developers. Google. https://developers.google.com/ar/reference/java/com/google/ar/core/Plane.Type. Retrieved 2026-09-29.
  11. ↑ 11.0 11.1 "XrSpatialPlaneAlignmentEXT(3)". OpenXR Registry. Khronos Group. https://registry.khronos.org/OpenXR/specs/1.1/man/html/XrSpatialPlaneAlignmentEXT.html. Retrieved 2026-09-29.
  12. ↑ 12.0 12.1 Dave Burke (2017-08-29). "ARCore: Augmented reality at Android scale". Android Developers Blog. Google. https://android-developers.googleblog.com/2017/08/arcore-augmented-reality-at-android.html. Retrieved 2026-09-29.
  13. ↑ 13.0 13.1 Georg Klein, David Murray (2007). "Parallel Tracking and Mapping for Small AR Workspaces". 6th IEEE and ACM International Symposium on Mixed and Augmented Reality (ISMAR 2007). doi:10.1109/ISMAR.2007.4538852. https://www.robots.ox.ac.uk/~gk/publications/KleinMurray2007ISMAR.pdf. Retrieved 2026-09-29.
  14. ↑ R. Schnabel, R. Wahl, R. Klein (2007). "Efficient RANSAC for Point-Cloud Shape Detection". Computer Graphics Forum, vol. 26, no. 2, pp. 214-226. doi:10.1111/j.1467-8659.2007.01016.x. https://doi.org/10.1111/j.1467-8659.2007.01016.x. Retrieved 2026-09-29.
  15. ↑ Chen Feng, Yuichi Taguchi, Vineet R. Kamat (2014). "Fast plane extraction in organized point clouds using agglomerative hierarchical clustering". 2014 IEEE International Conference on Robotics and Automation (ICRA), pp. 6218-6225. doi:10.1109/ICRA.2014.6907776. https://doi.org/10.1109/ICRA.2014.6907776. Retrieved 2026-09-29.
  16. ↑ Juli Clover (2020-03-24). "Apple Releases ARKit 3.5 for Developers With Support for iPad Pro's LiDAR Scanner". MacRumors. https://www.macrumors.com/2020/03/24/apple-releases-arkit-3-5-lidar-scanner-support/. Retrieved 2026-09-29.
  17. ↑ "ARKit 3.5 Now Available". Apple Developer News. Apple. 2020-03-24. https://developer.apple.com/news/?id=03242020a. Retrieved 2026-09-29.
  18. ↑ Chen Liu, Jimei Yang, Duygu Ceylan, Ersin Yumer, Yasutaka Furukawa (2018-04-17). "PlaneNet: Piece-wise Planar Reconstruction from a Single RGB Image". arXiv (CVPR 2018). arXiv:1804.06278. https://arxiv.org/abs/1804.06278. Retrieved 2026-09-29.
  19. ↑ Chen Liu, Kihwan Kim, Jinwei Gu, Yasutaka Furukawa, Jan Kautz (2018-12-10). "PlaneRCNN: 3D Plane Detection and Reconstruction from a Single Image". arXiv (CVPR 2019). arXiv:1812.04072. https://arxiv.org/abs/1812.04072. Retrieved 2026-09-29.
  20. ↑ Gilles Simon, Andrew W. Fitzgibbon, Andrew Zisserman (2000). "Markerless Tracking using Planar Structures in the Scene". Proceedings IEEE and ACM International Symposium on Augmented Reality (ISAR 2000), pp. 120-128. doi:10.1109/ISAR.2000.880935. https://inria.hal.science/inria-00099115. Retrieved 2026-09-29.
  21. ↑ Renato F. Salas-Moreno, Ben Glocker, Paul H. J. Kelly, Andrew J. Davison (2014). "Dense planar SLAM". 2014 IEEE International Symposium on Mixed and Augmented Reality (ISMAR), pp. 157-164. doi:10.1109/ISMAR.2014.6948422. https://doi.org/10.1109/ISMAR.2014.6948422. Retrieved 2026-09-29.
  22. ↑ 22.0 22.1 22.2 Renato F. Salas-Moreno (2014). "Dense Semantic SLAM (PhD thesis)". Department of Computing, Imperial College London. https://www.doc.ic.ac.uk/~ajd/Publications/Salas-Moreno-R-2014-PhD-Thesis.pdf. Retrieved 2026-09-29.
  23. ↑ "iOS 11 brings powerful new features to iPhone and iPad this fall". Apple Newsroom. Apple. 2017-06-05. https://www.apple.com/newsroom/2017/06/ios-11-brings-new-features-to-iphone-and-ipad-this-fall/. Retrieved 2026-09-29.
  24. ↑ 24.0 24.1 "ARWorldTrackingConfiguration.PlaneDetection". Apple Developer Documentation. Apple. https://developer.apple.com/documentation/arkit/arworldtrackingconfiguration/planedetection-swift.struct. Retrieved 2026-09-29.
  25. ↑ "geometry - ARPlaneAnchor". Apple Developer Documentation. Apple. https://developer.apple.com/documentation/arkit/arplaneanchor/geometry. Retrieved 2026-09-29.
  26. ↑ 26.0 26.1 "ARPlaneAnchor.Classification". Apple Developer Documentation. Apple. https://developer.apple.com/documentation/arkit/arplaneanchor/classification-swift.enum. Retrieved 2026-09-29.
  27. ↑ Ben Schoon (2018-05-09). "ARCore 1.2 arrives w/ 'Cloud Anchors' for shared experiences, vertical plane detection". 9to5Google. https://9to5google.com/2018/05/09/arcore-1-2-shared-experience-vertical-plane/. Retrieved 2026-09-29.
  28. ↑ 28.0 28.1 "Config.PlaneFindingMode - ARCore Java API reference". Google for Developers. Google. https://developers.google.com/ar/reference/java/com/google/ar/core/Config.PlaneFindingMode. Retrieved 2026-09-29.
  29. ↑ 29.0 29.1 "Scene understanding". Microsoft Learn. Microsoft. https://learn.microsoft.com/en-us/windows/mixed-reality/design/scene-understanding. Retrieved 2026-09-29.
  30. ↑ 30.0 30.1 30.2 "Unity Scene Overview". Meta Horizon OS Developers. Meta. https://developers.meta.com/horizon/documentation/unity/unity-scene-overview/. Retrieved 2026-09-29.
  31. ↑ "OpenXR Scene Overview". Meta Horizon OS Developers. Meta. https://developers.meta.com/horizon/documentation/native/android/openxr-scene-overview/. Retrieved 2026-09-29.
  32. ↑ "Suggested boundary and assisted Space Setup on Meta Quest". Meta Quest Help. Meta. https://www.meta.com/help/quest/articles/getting-started/getting-started-with-quest-3/suggested-boundary-assisted-space-setup/. Retrieved 2026-09-29.
  33. ↑ Tomislav Bezmalinovic (2024-04-16). "Quest 3's Space Setup gained an undocumented superpower". MIXED. https://mixed-news.com/en/quest-3-improved-space-setup/. Retrieved 2026-09-29.
  34. ↑ 34.0 34.1 "PlaneDetectionProvider". Apple Developer Documentation. Apple. https://developer.apple.com/documentation/arkit/planedetectionprovider. Retrieved 2026-09-29.
  35. ↑ "PlaneAnchor". Apple Developer Documentation. Apple. https://developer.apple.com/documentation/arkit/planeanchor. Retrieved 2026-09-29.
  36. ↑ 36.0 36.1 "PlaneAnchor.Alignment.slanted". Apple Developer Documentation. Apple. https://developer.apple.com/documentation/arkit/planeanchor/alignment-swift.enum/slanted. Retrieved 2026-09-29.
  37. ↑ 37.0 37.1 37.2 37.3 "Placing content on detected planes". Apple Developer Documentation. Apple. https://developer.apple.com/documentation/visionos/placing-content-on-detected-planes. Retrieved 2026-09-29.
  38. ↑ 38.0 38.1 38.2 38.3 "Detect planes using ARCore for Jetpack XR". Android Developers. Google. 2026-09-22. https://developer.android.com/develop/xr/jetpack-xr-sdk/arcore/planes. Retrieved 2026-09-29.
  39. ↑ Piotr Bialecki (2021-03-31). "Intent to Experiment: WebXR Plane Detection API". blink-dev mailing list. Chromium. https://groups.google.com/a/chromium.org/g/blink-dev/c/51Yd2t6quik/m/6AWd7G07CAAJ. Retrieved 2026-09-29.
  40. ↑ "Mixed Reality Support in Browser". Meta Horizon OS Developers. Meta. https://developers.meta.com/horizon/documentation/web/webxr-mixed-reality/. Retrieved 2026-09-29.
  41. ↑ "Develop for the web on Android XR". Android Developers. Google. 2026-08-31. https://developer.android.com/develop/xr/web. Retrieved 2026-09-29.
  42. ↑ "XR_EXT_plane_detection(3)". OpenXR Registry. Khronos Group. https://registry.khronos.org/OpenXR/specs/1.1/man/html/XR_EXT_plane_detection.html. Retrieved 2026-09-29.
  43. ↑ "OpenXR Spatial Entities Extensions Released for Developer Feedback". Khronos Group Blog. Khronos Group. 2025-06-10. https://www.khronos.org/blog/openxr-spatial-entities-extensions-released-for-developer-feedback. Retrieved 2026-09-29.
  44. ↑ 44.0 44.1 "XR_EXT_spatial_plane_tracking(3)". OpenXR Registry. Khronos Group. https://registry.khronos.org/OpenXR/specs/1.1/man/html/XR_EXT_spatial_plane_tracking.html. Retrieved 2026-09-29.
  45. ↑ 45.0 45.1 "XrSpatialPlaneSemanticLabelEXT(3)". OpenXR Registry. Khronos Group. https://registry.khronos.org/OpenXR/specs/1.1/man/html/XrSpatialPlaneSemanticLabelEXT.html. Retrieved 2026-09-29.
  46. ↑ "Plane detection - AR Foundation 6.0". Unity Documentation. Unity Technologies. https://docs.unity3d.com/Packages/[email protected]/manual/features/plane-detection.html. Retrieved 2026-09-29.
  47. ↑ "Plane detection platform support - AR Foundation 6.0". Unity Documentation. Unity Technologies. https://docs.unity3d.com/Packages/[email protected]/manual/features/plane-detection/platform-support.html. Retrieved 2026-09-29.
  48. ↑ Mfundo A. Maneli, Omowunmi E. Isafiade (2023). "A Comparative Evaluation of Augmented Reality Frameworks: A Plane Mapping and Resource Utilisation Perspective". 2023 IST-Africa Conference (IST-Africa), pp. 1-9. doi:10.23919/IST-Africa60249.2023.10187850. https://doi.org/10.23919/IST-Africa60249.2023.10187850. Retrieved 2026-09-29.
Retrieved from "https://vrarwiki.com/index.php?title=Plane_detection&oldid=46115"