हमने ऐतिहासिक स्थानों की समीक्षा के लिए AR एप्लिकेशन कैसे विकसित किया

हाल ही में, हमने पुरानी प्रौद्योगिकियों को आधुनिक प्रौद्योगिकियों के साथ जोड़ा, जो कि कटौती के तहत पढ़ी गई थीं।

संवर्धित वास्तविकता

शहर गाइड के रूप में संवर्धित वास्तविकता ऐप एक प्रसिद्ध विषय है और कई डेवलपर्स द्वारा कार्यान्वित किया जाता है। एआर का उपयोग करने की यह दिशा पहले में से एक थी, क्योंकि यह आपको संवर्धित वास्तविकता की सभी स्पष्ट संभावनाओं का उपयोग करने की अनुमति देता है: उपयोगकर्ताओं को इमारतों के बारे में जानकारी दिखाना, संस्था के काम के बारे में जानकारी देना और स्थलों से परिचित होना। अंतिम हैकथॉन में, जिसे कंपनी के अंदर आयोजित किया गया था, संवर्धित वास्तविकता का उपयोग करने वाली कई परियोजनाएं प्रस्तुत की गईं, और हम एक एआर-एप्लिकेशन बनाने के विचार के साथ आए, जो यह दिखाएगा कि अतीत में एक ऐतिहासिक या ऐतिहासिक स्थान कैसा दिखता था। ऐसा करने के लिए, पुरानी तस्वीरों के साथ आधुनिक संवर्धित वास्तविकता प्रौद्योगिकियों को मिलाएं। उदाहरण के लिए, सेंट आइजैक कैथेड्रल का सामना करना, आप उस पर एक स्मार्टफोन कैमरा इंगित कर सकते हैं और उसकी पहली लकड़ी की इमारत देख सकते हैं, जिसे 1715 में ध्वस्त कर दिया गया था।

काम के यांत्रिकी निम्नानुसार हैं: आवेदन मानचित्र पर शहर के दिए गए ऐतिहासिक स्थानों और स्थलों को प्रदर्शित करता है, उनके बारे में संक्षिप्त जानकारी प्रदर्शित करता है, सूचनाओं की सहायता से उपयोगकर्ता को सूचित करता है कि वह एक दिलचस्प बिंदु के पास स्थित है। जब कोई व्यक्ति 40 मीटर की दूरी पर एक ऐतिहासिक स्मारक के पास पहुंचता है, तो एआर मोड उपलब्ध हो जाता है। उसी समय, कैमरा खुलता है, और वस्तुओं के बारे में संक्षिप्त जानकारी सीधे उपयोगकर्ता के आसपास के स्थान में प्रदर्शित होती है। उत्तरार्द्ध में आभासी वस्तुओं के साथ बातचीत करने की क्षमता है: एक ऐतिहासिक स्थान के कार्ड को छूकर, आप छवियों के साथ एल्बम को देखने के लिए आगे बढ़ सकते हैं।

ऐसा लगता है कि आवेदन बहुत सरल है, लेकिन यहां भी कुछ नुकसान थे। मैं आपको एक कहानी के साथ तुच्छ चीजों के कार्यान्वयन के बारे में बोर नहीं करूंगा जैसे कि सर्वर से डेटा डाउनलोड करना या मानचित्र पर अंक प्रदर्शित करना, मैं सीधे उन कार्यों पर जाऊंगा जो समस्याओं का कारण बने।

समस्या 1. फ्लोटिंग पॉइंट

इसलिए, पहली बात यह थी कि वर्तमान स्थान के सापेक्ष ऐतिहासिक स्थानों की वास्तविक स्थिति और उपयोगकर्ता के टकटकी की दिशा के अनुसार अंतरिक्ष में मार्कर पॉइंट लगाए जाएं।

आरंभ करने के लिए, हमने iOS: ARKit-CoreLocation के लिए पहले से तैयार लाइब्रेरी का उपयोग करने का निर्णय लिया। यह परियोजना मुख्य डोमेन के कोड के अलावा, सार्वजनिक डोमेन में GitHub पर निहित है, एकीकरण के उदाहरण हैं और हमें उस कार्य को पूरा करने की अनुमति देता है जिसे हम कुछ घंटों में रुचि रखते हैं। केवल लाइब्रेरी को अंक और एक मार्कर के रूप में उपयोग की जाने वाली छवि के निर्देशांक को खिलाने के लिए आवश्यक है।

आश्चर्य नहीं कि इस सहजता को चुकाना पड़ा। मार्कर अंक लगातार अंतरिक्ष में तैरते रहे: वे या तो छत पर चढ़ गए, या कहीं अंडरफुट में आ गए। प्रत्येक उपयोगकर्ता अपनी रुचि की जानकारी से परिचित होने के लिए कई मिनट तक एआर-ऑब्जेक्ट को फोकस में पकड़ने के लिए सहमत नहीं होगा।

जैसा कि यह निकला, कई ने इस पुस्तकालय बग का सामना किया, लेकिन अभी तक कोई समाधान नहीं मिला है। GitHub पर कोड, दुर्भाग्य से, छह महीने से अधिक समय तक अपडेट नहीं किया गया है, इसलिए मुझे इसे बाईपास करना पड़ा।

हमने निर्देशांक में निश्चित ऊंचाई के बजाय ऊंचाई का उपयोग करने की कोशिश की, जिसे उपयोगकर्ता के वर्तमान स्थान के लिए स्थान प्रबंधक ने वापस कर दिया। हालांकि, इससे समस्या पूरी तरह से समाप्त नहीं हुई। लोकेशन मैनेजर से आने वाले डेटा को 60 मीटर तक फैलने के साथ कूदना शुरू किया, जैसे ही डिवाइस को हाथ में घुमाया गया। नतीजतन, तस्वीर अस्थिर थी, जो निश्चित रूप से हमें फिर से सूट नहीं करती थी।

नतीजतन, ARKit-CoreLocation लाइब्रेरी को छोड़ने और अपने दम पर अंतरिक्ष में जगह बिंदुओं को छोड़ने का निर्णय लिया गया। क्रिस्टोफर वेब-ओरेनस्टीन द्वारा लिखित लेख ARKit और CoreLocation ने इसमें बहुत मदद की। मुझे थोड़ा और समय बिताना था और अपनी स्मृति में कुछ गणितीय पहलुओं को ताज़ा करना था, लेकिन परिणाम इसके लायक था: एआर-ऑब्जेक्ट आखिरकार अपनी जगहों पर थे। उसके बाद, यह केवल वाई अक्ष के साथ उन्हें तितर बितर करने के लिए रहता है ताकि लेबल और अंक पढ़ना आसान हो, और वर्तमान स्थिति से बिंदु और जेड ऑब्जेक्ट के समन्वय के बीच की दूरी के बीच एक पत्राचार स्थापित करना, ताकि निकटतम निकटतम स्थानों के बारे में जानकारी अग्रभूमि में हो।

निर्देशांक पर ध्यान केंद्रित करते हुए, अंतरिक्ष में नई SCNNode स्थिति की गणना करना आवश्यक था:

let place = PlaceNode() let locationTransform = MatrixHelper.transformMatrix(for: matrix_identity_float4x4, originLocation: curUserLocation, location: nodeLocation, yPosition: pin.yPos, shouldScaleByDistance: false) let nodeAnchor = ARAnchor(transform: locationTransform) scene.session.add(anchor: nodeAnchor) scene.scene.rootNode.addChildNode(place) 

मैट्रिक्सहेल्पर क्लास में सहायक कार्य हैं:

 class MatrixHelper { static func transformMatrix(for matrix: simd_float4x4, originLocation: CLLocation, location: CLLocation, yPosition: Float) -> simd_float4x4 { let distanceToPoint = Float(location.distance(from: originLocation)) let distanceToNode = (10 + distanceToPoint/1000.0) let bearing = GLKMathDegreesToRadians(Float(originLocation.coordinate.direction(to: location.coordinate))) let position = vector_float4(0.0, yPosition, -distanceToNode, 0.0) let translationMatrix = MatrixHelper.translationMatrix(with: matrix_identity_float4x4, for: position) let rotationMatrix = MatrixHelper.rotateAroundY(with: matrix_identity_float4x4, for: bearing) let transformMatrix = simd_mul(rotationMatrix, translationMatrix) return simd_mul(matrix, transformMatrix) } static func translationMatrix(with matrix: matrix_float4x4, for translation : vector_float4) -> matrix_float4x4 { var matrix = matrix matrix.columns.3 = translation return matrix } static func rotateAroundY(with matrix: matrix_float4x4, for degrees: Float) -> matrix_float4x4 { var matrix : matrix_float4x4 = matrix matrix.columns.0.x = cos(degrees) matrix.columns.0.z = -sin(degrees) matrix.columns.2.x = sin(degrees) matrix.columns.2.z = cos(degrees) return matrix.inverse } } 

दिगंश गणना करने के लिए विस्तार CLLocationCoordinate2D जोड़ा

 extension CLLocationCoordinate2D { func calculateBearing(to coordinate: CLLocationCoordinate2D) -> Double { let a = sin(coordinate.longitude.toRadians() - longitude.toRadians()) * cos(coordinate.latitude.toRadians()) let b = cos(latitude.toRadians()) * sin(coordinate.latitude.toRadians()) - sin(latitude.toRadians()) * cos(coordinate.latitude.toRadians()) * cos(coordinate.longitude.toRadians() - longitude.toRadians()) return atan2(a, b) } func direction(to coordinate: CLLocationCoordinate2D) -> CLLocationDirection { return self.calculateBearing(to: coordinate).toDegrees() } } 

समस्या 2. अतिरिक्त वस्तुएँ

अगली समस्या जो हमें मिली, वह थी एआर वस्तुओं की एक बड़ी मात्रा। हमारे शहर में बहुत सारी ऐतिहासिक जगहें और जगहें हैं, इसलिए जानकारी के साथ पासा एक दूसरे में विलीन हो जाता है और क्रॉल हो जाता है। उपयोगकर्ता के लिए शिलालेख का हिस्सा बनाना बहुत मुश्किल होगा, और यह एक प्रतिकारक प्रभाव बना सकता है। कॉन्फ्रेंस करने के बाद, हमने वर्तमान स्थान से 500 मीटर के दायरे में केवल एक बिंदु को छोड़कर, एक साथ प्रदर्शित एआर ऑब्जेक्ट्स की संख्या को सीमित करने का निर्णय लिया।

हालांकि, कुछ क्षेत्रों में, अंकों की एकाग्रता अभी भी बहुत अधिक थी। इसलिए, दृश्यता बढ़ाने के लिए, उन्होंने क्लस्टरिंग का उपयोग करने का निर्णय लिया। मैप स्क्रीन पर, यह सुविधा MapKit में एम्बेडेड तर्क के कारण डिफ़ॉल्ट रूप से उपलब्ध है, लेकिन AR मोड में इसे मैन्युअल रूप से लागू करना आवश्यक था।

क्लस्टरिंग वर्तमान स्थिति से लक्ष्य की दूरी पर आधारित थी। इस प्रकार, यदि बिंदु उपयोगकर्ता के बीच की दूरी और सूची से पिछले आकर्षण के बराबर त्रिज्या के साथ क्षेत्र में गिर गया, तो यह बस छिप गया और क्लस्टर का हिस्सा था। जैसे ही उपयोगकर्ता ने संपर्क किया, दूरी कम हो गई, और क्लस्टर ज़ोन की त्रिज्या तदनुसार कम हो गई, इसलिए आस-पास स्थित जगहें क्लस्टर में विलय नहीं हुईं। एकल बिंदुओं से क्लस्टर को अलग करने के लिए, हमने मार्कर का रंग बदलने और जगह के नाम के बजाय एआर में वस्तुओं की संख्या प्रदर्शित करने का निर्णय लिया।



AR ऑब्जेक्ट्स की अन्तरक्रियाशीलता सुनिश्चित करने के लिए, एक UITapGestureRecognizer को ARSCNView पर लटका दिया गया था और हैंडलर में हिटटेस्ट विधि का उपयोग करके यह जाँच की गई थी कि SCNNode ऑब्जेक्ट्स में से किस पर उपयोगकर्ता ने क्लिक किया है। यदि यह आस-पास के आकर्षण की तस्वीर बन गया, तो एप्लिकेशन ने पूर्ण स्क्रीन मोड में संबंधित एल्बम को खोल दिया।

समस्या 3. रडार

आवेदन के कार्यान्वयन के दौरान, एक छोटे से रडार पर अंक दिखाना आवश्यक था। सिद्धांत रूप में, कोई गलतफहमी नहीं होनी चाहिए, क्योंकि हमने पहले ही बिंदु पर दूरी और दूरी की गणना कर ली है, यहां तक ​​कि उन्हें 3 डी निर्देशांक में बदलने में कामयाब रहे। यह केवल स्क्रीन पर दो-आयामी स्थान में अंक रखने के लिए बनी रही।



पहिया को सुदृढ़ नहीं करने के लिए, उन्होंने रडार लाइब्रेरी का रुख किया, जिसका ओपन सोर्स कोड गिटहब पर प्रकाशित किया गया था। उदाहरण के ज्वलंत पूर्वावलोकन और लचीली सेटिंग्स उत्साहजनक थीं, लेकिन वास्तव में अंकों को अंतरिक्ष में वास्तविक स्थान के सापेक्ष स्थानांतरित कर दिया गया था। सूत्रों को सही करने की कोशिश में कुछ समय बिताने के बाद, हम कम खूबसूरत, लेकिन अधिक विश्वसनीय विकल्प के रूप में iPhone संवर्धित यथार्थवादी टूलकिट में वर्णित हैं:

 func place(dot: Dot) { var y: CGFloat = 0.0 var x: CGFloat = 0.0 if degree < 0 { degree += 360 } let bearing = dot.bearing.toRadians() let radius: CGFloat = 60.0 // radius of the radar view if (bearing > 0 && bearing < .pi / 2) { //the 1 quadrant of the radar x = radius + CGFloat(cosf(Float((.pi / 2) - bearing)) * Float(dot.distance)) y = radius - CGFloat(sinf(Float((.pi / 2) - bearing)) * Float(dot.distance)) } else if (bearing > .pi / 2.0 && bearing < .pi) { //the 2 quadrant of the radar x = radius + CGFloat(cosf(Float(bearing - (.pi / 2))) * Float(dot.distance)) y = radius + CGFloat(sinf(Float(bearing - (.pi / 2))) * Float(dot.distance)) } else if (bearing > .pi && bearing < (3 * .pi / 2)) { //the 3 quadrant of the radar x = radius - CGFloat(cosf(Float((3 * .pi / 2) - bearing)) * Float(dot.distance)) y = radius + CGFloat(sinf(Float((3 * .pi / 2) - bearing)) * Float(dot.distance)) } else if (bearing > (3 * .pi / 2.0) && bearing < (2 * .pi)) { //the 4 quadrant of the radar x = radius - CGFloat(cosf(Float(bearing - (3 * .pi / 2))) * Float(dot.distance)) y = radius - CGFloat(sinf(Float(bearing - (3 * .pi / 2))) * Float(dot.distance)) } else if (bearing == 0) { x = radius y = radius - CGFloat(dot.distance) } else if (bearing == .pi / 2) { x = radius + CGFloat(dot.distance) y = radius } else if (bearing == .pi) { x = radius y = radius + CGFloat(dot.distance) } else if (bearing == 3 * .pi / 2) { x = radius - CGFloat(dot.distance) y = radius } else { x = radius y = radius - CGFloat(dot.distance) } let newPosition = CGPoint(x: x, y: y) dot.layer.position = newPosition 

बैकएंड

यह भंडारण डॉट्स और फ़ोटो की समस्या को हल करने के लिए बनी हुई है। इन उद्देश्यों के लिए, कंटेंटफुल का उपयोग करने का निर्णय लिया गया, और परियोजना के वर्तमान कार्यान्वयन में उन्होंने हमें पूरी तरह से अनुकूल बनाया।


मोबाइल एप्लिकेशन के विकास के समय, सभी मधुमक्खीपालक वाणिज्यिक परियोजनाओं में लगे हुए थे, और विवादास्पद लोगों के लिए कई सुविधाएं प्रदान करने की अनुमति थी:

• मोबाइल डेवलपर - सुविधाजनक बैकएंड
• सामग्री प्रबंधक - डेटा भरने के लिए एक सुविधाजनक व्यवस्थापक क्षेत्र

बैकएंड के समान कार्यान्वयन का उपयोग मूल रूप से उन टीमों द्वारा किया गया था जिन्होंने हैकथॉन में भाग लिया था (लेख की शुरुआत में उल्लेख किया गया था), जो एक बार फिर साबित करता है कि हैकथॉन जैसी चीजें आपको परियोजनाओं पर अपनी दबाव की समस्याओं को हल करने से बचने की अनुमति देती हैं, कुछ को फिर से बनाना और कुछ प्रयास करना संभव बनाती हैं। एकदम नया।

निष्कर्ष

एआर एप्लिकेशन को विकसित करना बहुत दिलचस्प था, इस प्रक्रिया में हमने कई तैयार किए गए पुस्तकालयों की कोशिश की, लेकिन साथ ही हमें गणित को याद रखना और खुद बहुत सारी चीजें लिखना था।

सरल, पहली नज़र में, इस परियोजना को एल्गोरिदम को लागू करने और परिष्कृत करने के लिए बहुत काम के घंटों की आवश्यकता थी, इस तथ्य के बावजूद कि हमने ऐप्पल से मानक एसडीके का उपयोग किया था।

हमने हाल ही में एप्लिकेशन को AppStore में पोस्ट किया है। यहाँ यह काम पर कैसा दिखता है।


अब तक, हमारे डेटाबेस में केवल टैगान्रोग के लिए बिंदु हैं, हालांकि, हर कोई "कवरेज क्षेत्र" के विस्तार में भाग ले सकता है।