【iOS ARKit】ARWorldMap

      ARWorldMap 用于存储 ARSession 检测扫描到的空间信息数据，包罗地标（Landmark）、特征点（Feature Point）、平面（Plane）等，以及利用者的利用信息，如利用者添加的 ARAnchor 和开发者自定义的一些信息。ARWorldMap 可以看作 ARSession 运行时的一次状态快照。
      在技能上，每个具备世界跟踪的 ARSession 都会时刻维护一个内部的世界舆图（internal world map），ARKit 正是利用这个舆图定位跟踪用户设备的姿态，利用 getCurrent WorldMap（completionHandler：）方法获取的 ARWroldMap只是特定时刻内部世界舆图的一个快照。    
ARWorldMap 概述

     长期化地存储应用进程数据，ARKit 提供了 ARWorldMap 功能，ARWorldMap 本质是将 AR 场景状态信息转换为可存储可传输的情势（即序列化）保存到文件系统或者数据库中，当利用者再次加载这些景状态信息后即可规复应用进程。ARWorldMap 不仅保存了应用进程状态信息，还保存了场景特征点云息，在利用者再次加载这些状态数据后，ARKit 可通过保存的特征点云信息与当前用户摄像头获取的特点云信息进行对比匹配从而更新当前用户的坐标，确保两个坐标系的匹配。
存储与加载 ARWorldMap

     存储 ARWorldMap最重要的是从 ARSession 中获取场景的 ARWorldMap 并序列化之，然后保件系统中。加载 ARWorldMap 则首先要从文件系统中获取ARWorldMap 并反序列化之，然后利用这个ARWorldMap 重启 ARSession。存储与加载 ARWorldMap 完整代码如下所示，稍后我们将对代码中所用技能进行详细分析。

1. //
2. //  ARWorldMapSaveAndLoad.swift
3. //  ARKitDeamo
4. //
5. //  Created by zhaoquan du on 2024/2/20.
6. //
8. import SwiftUI
9. import ARKit
10. import RealityKit
11. import Combine
13. struct ARWorldMapSaveAndLoad: View {
14.     var viewModel: ViewModel = ViewModel()
15.    
16.     var body: some View {
17.         ARWorldMapSaveAndLoadContainer(viewModel: viewModel)
18.             .overlay(
19.                 VStack{
20.                     Spacer()
21.                     
22.                     HStack{
23.                         Button(action: {loadWorldMap()}) {
24.                             Text("加载信息")
25.                                 .frame(width:150,height:50)
26.                                 .font(.system(size: 17))
27.                                 .foregroundColor(.black)
28.                                 .background(Color.white)
29.                            
30.                                 .opacity(0.6)
31.                         }
32.                         .cornerRadius(10)
33.                         
34.                         Button(action: {saveWorldMap()}) {
35.                             Text("保存信息")
36.                                 .frame(width:150,height:50)
37.                                 .font(.system(size: 17))
38.                                 .foregroundColor(.black)
39.                                 .background(Color.white)
40.                            
41.                                 .opacity(0.6)
42.                         }
43.                         .cornerRadius(10)
44.                     }
45.                     Spacer().frame(height: 40)
46.                 }
47.             ).edgesIgnoringSafeArea(.all).navigationTitle("保存与加载ARWorldMap")
48.     }
49.     var mapSaveURL: URL = {
50.         do {
51.             return try FileManager.default
52.                 .url(for: .documentDirectory,
53.                      in: .userDomainMask,
54.                      appropriateFor: nil,
55.                      create: true)
56.                 .appendingPathComponent("arworldmap.arexperience")
57.         } catch {
58.             fatalError("获取路径出错: \(error.localizedDescription)")
59.         }
60.     }()
62.     func saveWorldMap() {
63.         print("save:\(String(describing: viewModel.arView))")
64.         
65.         self.viewModel.arView?.session.getCurrentWorldMap(completionHandler: { loadWorld, error in
66.             guard let worldMap = loadWorld else {
67.                 print("当前无法获取ARWorldMap:\(error!.localizedDescription)")
68.                 return
69.             }
70.            
71.             do {
72.                 let data = try NSKeyedArchiver.archivedData(withRootObject: worldMap, requiringSecureCoding: true)
73.                 try data.write(to: mapSaveURL, options: [.atomic])
74.                 print("ARWorldMap保存成功")
75.             } catch {
76.                 fatalError("无法保存ARWorldMap: \(error.localizedDescription)")
77.             }
78.         })
79.     }
80.     func loadWorldMap() {
81.         print("load:\(String(describing: viewModel.arView))")
82.         guard let data = try? Data(contentsOf: mapSaveURL) else {
83.             print("load world map faile")
84.             return
85.         }
86.         var worldMap: ARWorldMap?
87.         do {
88.             worldMap = try NSKeyedUnarchiver.unarchivedObject(ofClass: ARWorldMap.self, from: data)
89.         } catch let error {
90.             print("ARWorldMap文件格式不正确:\(error)")
91.         }
92.         guard let worldMap = worldMap else {
93.             print("无法解压ARWorldMap")
94.             return
95.         }
96.         let config = ARWorldTrackingConfiguration()
97.         config.planeDetection = .horizontal
98.         config.initialWorldMap = worldMap
99.         
100.         self.viewModel.arView?.session.run(config,options: [.resetTracking, .removeExistingAnchors])
101.             
102.     }
103.    
104.     class ViewModel: NSObject,ARSessionDelegate{
105.         var arView: ARView? = nil
106.         
107.       
108.         var planeEntity : ModelEntity? = nil
109.         var raycastResult : ARRaycastResult?
110.         var isPlaced = false
111.         var robotAnchor: AnchorEntity?
112.         let robotAnchorName = "drummerRobot"
113.         var planeAnchor = AnchorEntity()
114.         
115.         func createPlane()  {
116.            
117.             guard let arView = arView else {
118.                 return
119.             }
120.          
121.             if let an = arView.scene.anchors.first(where: { an in
122.                 an.name == "setModelPlane"
123.             }){
124.                 arView.scene.anchors.remove(an)
125.             }
126.             do {
127.                 let planeMesh = MeshResource.generatePlane(width: 0.15, depth: 0.15)
128.                 var planeMaterial = SimpleMaterial(color: SimpleMaterial.Color.red, isMetallic: false)
129.                 planeMaterial.color =  try SimpleMaterial.BaseColor(tint:UIColor.yellow.withAlphaComponent(0.9999), texture: MaterialParameters.Texture(TextureResource.load(named: "AR_Placement_Indicator")))
130.                 planeEntity = ModelEntity(mesh: planeMesh, materials: [planeMaterial])
131.                
132.                 planeAnchor = AnchorEntity(plane: .horizontal)
133.                 planeAnchor.addChild(planeEntity!)
134.                 planeAnchor.name = "setModelPlane"
135.                
136.                 arView.scene.addAnchor(planeAnchor)
137.             } catch let error {
138.                 print("加载文件失败:\(error)")
139.             }
140.         }
141.         
142.         func setupGesture(){
143.             
144.             let tap = UITapGestureRecognizer(target: self, action: #selector(handleTap))
145.             self.arView?.addGestureRecognizer(tap)
146.         }
147.         @objc func handleTap(sender: UITapGestureRecognizer){
148.             sender.isEnabled = false
149.             sender.removeTarget(nil, action: nil)
150.             isPlaced = true
151.             let anchor = ARAnchor(name: robotAnchorName, transform: raycastResult?.worldTransform ?? simd_float4x4())
152.             self.arView?.session.add(anchor: anchor)
153.             
154.             robotAnchor = AnchorEntity(anchor: anchor)
155.             
156.             
157.             do {
158.                 let robot =  try ModelEntity.load(named: "toy_drummer")
159.                 robotAnchor?.addChild(robot)
160.                 robot.scale = [0.01,0.01,0.01]
161.                 self.arView?.scene.addAnchor(robotAnchor!)
162.                 print("Total animation count : \(robot.availableAnimations.count)")
163.                 robot.playAnimation(robot.availableAnimations[0].repeat())
164.             } catch {
165.                 print("找不到USDZ文件")
166.             }
167.             
168. //            var cancellable: Cancellable?
169. //            cancellable = ModelEntity.loadModelAsync(named: "toy_drummer.usdz")
170. //                .sink(receiveCompletion: { error in
171. //                    print("laod error:\(error)")
172. //                    cancellable?.cancel()
173. //                }, receiveValue: {[weak self] model in
174. //                    guard let robotAnchor = self?.robotAnchor else {
175. //                        return
176. //                    }
177. //                    robotAnchor.addChild(model)
178. //                    model.scale = [0.01,0.01,0.01]
179. //                    self?.arView?.scene.addAnchor(robotAnchor)
180. //                    //用异步方法加载模型开启骨骼动画会crash，不知到是啥原因
181. //                    //model.playAnimation(model.availableAnimations[0].repeat())
182. //                    cancellable?.cancel()
183. //                })
184.             planeEntity?.removeFromParent()
185.             planeEntity = nil
186.         }
187.         
188.         func session(_ session: ARSession, didUpdate frame: ARFrame) {
189.             guard !isPlaced, let arView = arView else{
190.                 return
191.             }
192.             //射线检测
193.             guard let result = arView.raycast(from: arView.center, allowing: .estimatedPlane, alignment: .horizontal).first else {
194.                 return
195.             }
196.             raycastResult = result
197.             planeEntity?.setTransformMatrix(result.worldTransform, relativeTo: nil)
198.         }
199.         
200.         func session(_ session: ARSession, didAdd anchors: [ARAnchor]) {
201.             guard !anchors.isEmpty,robotAnchor == nil else {
202.                
203.                 return
204.             }
205.             var panchor: ARAnchor? = nil
206.             for anchor in anchors {
207.                 if anchor.name == robotAnchorName {
208.                     panchor = anchor
209.                     break
210.                 }
211.             }
212.             guard let pAnchor = panchor else {
213.                 return
214.             }
215.             //放置虚拟元素
216.             robotAnchor = AnchorEntity(anchor: pAnchor)
217.             do {
218.                 let robot =  try ModelEntity.load(named: "toy_drummer")
219.                 robotAnchor?.addChild(robot)
220.                 robot.scale = [0.01,0.01,0.01]
221.                 self.arView?.scene.addAnchor(robotAnchor!)
222.                 print("Total animation count : \(robot.availableAnimations.count)")
223.                 robot.playAnimation(robot.availableAnimations[0].repeat())
224.             } catch {
225.                 print("找不到USDZ文件")
226.             }
227.             isPlaced = true
228.             planeEntity?.removeFromParent()
229.             planeEntity = nil
230.             print("加载模型成功")
231.         }
232.         
233.     }
234. }
236. struct ARWorldMapSaveAndLoadContainer: UIViewRepresentable {
237.     var viewModel: ARWorldMapSaveAndLoad.ViewModel
238.    
239.     func makeUIView(context: Context) -> some ARView {
240.         let arView = ARView(frame: .zero)
241.       
242.         
243.         return arView
244.     }
245.    
246.     func updateUIView(_ uiView: UIViewType, context: Context) {
247.         
248.         let config = ARWorldTrackingConfiguration()
249.         config.planeDetection = .horizontal
250.         uiView.session.run(config)
251.         
252.         viewModel.arView = uiView
253.         uiView.session.delegate = viewModel
254.         
255.         viewModel.createPlane()
256.         viewModel.setupGesture()
257.         
258.     }
259.    
260. }
261. #Preview {
262.     ARWorldMapSaveAndLoad()
263. }

复制代码

代码实现的功能如下：
（1）进行平面检测，在检测到可用平面时实例化一个指示图标用于指示放置位置。
（2）添加屏幕单击手势，在平面可用时通过单击屏幕会在指示图标位置放置虛拟呆板人模型。
（3） 当用户单击“保存AR信息”按钮时会从当前 ARSesion 中获取 ARWorldMap 并序列化之，然后保存到文件系统中。
（4）当用户单击“加载AR信息”按钮时会从文件系统中加载ARWorldMap 并反序列化之，然后利用该ARWorldMap 重启 ARSession。
        在第（2）项功能中，即 bandleTap（）方法中的代码，我们首先将屏幕单击手势禁用，以防止添加多个呆板人模型，然后禁止表现指示图标。随后利用命申点的坐标天生了一个ARAnchor，并将其添加到 ARSession中，注意这里设置了 ARAnchor 的名字（name）属性，这步很关键，因为后续我们须要利用该ARAnchor 的名字来规复虚拟元素。后续代码是利用异步方式加载呆板人模型，不赘述。
       在第（3）项功能中，即 saveAR WorldMap（）方法中代码，首先利用 getCurrent WorldMap（）方法从 ARSession中获取 ARWorldVap，在闭包中，利用 let data = try NSKeyedArchiver. archivedData （with RootObject: map，requiringSecureCoding: true）语句对获取的ARWorldMap 进行序列化，然后利用 try data. write （to：mapSaveURL.， options： ［.atomic］）方法将序列化后的 ARWorldMap 写人到文件系统中。
       在第（4）项功能中，即 loadARWorldMap（）方法中代码，首先从文件系统中读取存储的 ARWorldMap文件，并利用 let worldMap = try NSKeyedUnarchiver. unarchivedObject （ofClass: AR WorldMap. self，from:data）语句将其反序列化。在得到反序列化后的ARWorldMap 后，就可以利用其作为配置文件的initialWorldMap 属性重启 ARSession，当用户设备所在的物理情况与 ARWorldMap 保存时的物理情况一致时（即情况特征点信息匹配时），ARKit 就会校正用户设备坐标信息，将当前用户设备的坐标信息与ARWorldMap 中存储的用户设备坐标信息关联起来，并规复相应的ARAnchor 信息，这时规复的ARAnchor 姿态与ARWorldMap 中存储的姿态就是一致的，即ARAnchor 在物理情况中的位置与方向是一致的，这就达到了应用进程数据存储与加载的目的。
      正如前文所述，ARWorldMap 并不会存储虚拟元素本身，因此，须要手动规复虚拟元素，因为虚拟元素总是与ARAnchor 关联，利用 ARAnchor 的名字（name）属性我们就可以规复关联的虚拟元素。在代码中，session（_：didAdd：）方法就用于规复关联的虚拟元素，在该方法中，通过ARAnchor.name 进行ARAnchor的对比，假如名字一样且当前没有加载呆板人模型则利用异步方法加载之。通过这种方式，我们就可以逐一地规复全部的虚拟元素，从而规复整个场景。
       运行案例，在检测到的平面上添加虚拟元素后单击“保存舆图”按钮保存 AR WorldMap，稍后单击“加载舆图”按钮，或者关闭应用，在重新运行后单击“加载舆图”按钮，可以看到虚拟呆板人模型会出如今物理世界中的固定位置，如图所示。

      究竟上，在将 ARWorldMap 设置 ARWorldTrackingConfiguration. initialWorldMap 属性启动ARSession 时，ARKit 会进入重定位（relocalize）过程，在这个过程中，ARKit 会尝试将当前设备摄像头采集的情况信息与 ARWorldMap 中存储的情况特征信息进行匹配。因此，保持当前设备姿态与存储ARWorldMap 时的设备姿态一致时（即提高情况特征点匹配成功率）可以更快速地重定位。   
具体代码地点：GitHub - duzhaoquan/ARkitDemo

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。