ABBYY RTR SDK और django के साथ एंड्रॉइड थिंग्स पर ग्रंथों को पहचानना

नमस्ते! मेरा नाम अज़ात कलिमकोव है, मैं एप्लाइड मैथेमेटिक्स और कंप्यूटर साइंस संकाय के दूसरे वर्ष का छात्र हूँ, जो हायर स्कूल ऑफ़ इकोनॉमिक्स में कंप्यूटर विज्ञान का संकाय है और एबीबीवाई के मोबाइल विकास विभाग में प्रशिक्षु है। इस लेख में मैं अपनी छोटी परियोजना के बारे में बात करूंगा, जिसे एक ग्रीष्मकालीन इंटर्नशिप के हिस्से के रूप में किया गया था।

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

Android चीजें

एंड्रॉइड थिंग्स स्टार्टर किट नामक एक अद्भुत चीज Google I / O सम्मेलन से हमारे ABBYY कार्यालय में आई। अच्छाई गायब नहीं हुई, और हम अपनी मान्यता पुस्तकालयों का उपयोग करने के लिए विभिन्न परिदृश्यों की तलाश में इसके साथ खेलना चाहते थे। पहले आपको हमारे उपकरण को इकट्ठा करने की आवश्यकता है, और फिर चलाएं। ऐसा करना मुश्किल नहीं है, बल्कि निर्माता से निर्देशों का कड़ाई से पालन करें।

प्लेटफ़ॉर्म के बारे में और यहाँ पढ़ें।

मेरे हाथ में क्या आया

और पोस्ट के अंत में मैं आपको दिखाऊंगा कि इकट्ठे डिवाइस क्या दिखता है

हम क्या कर रहे हैं?

हम एंड्रॉइड थिंग्स प्लेटफॉर्म के लिए एक आवेदन लिखेंगे जो कैमरे से छवि को संसाधित करेगा, हमारे सर्वर को मान्यता प्राप्त पाठ और (समय-समय पर) फ़्रेम भेजेगा ताकि सशर्त ऑपरेटर समझ सके कि पाइपलाइन पर क्या हो रहा है। सर्वर django में लिखा जाएगा।

मैं यह ध्यान देने की जल्दबाजी करता हूं कि इस परियोजना के कार्यान्वयन के लिए आपको किसी निवेश की आवश्यकता नहीं होगी, साथ ही पंजीकरण और एसएमएस (ठीक है, एडब्ल्यूएस पर आपको अभी भी पंजीकरण करने और मुफ्त खाता प्राप्त करने की आवश्यकता है)।

हम लॉन्च करते हैं अंतरिक्ष में रॉकेट सर्वर

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

हम सर्वर से जुड़े हैं। हम मशीन पर आवश्यक टूलकिट स्थापित करते हैं।

पायथन तीसरे संस्करण को पूर्वस्थापित किया गया है। मामला छोटे पर छोड़ दिया जाता है।

$ sudo apt-get update $ sudo apt-get install python3-pip $ sudo pip3 install virtualenv 

कर्ता स्थापित करें, हमें बाद में इसकी आवश्यकता होगी।

 $ sudo apt-get install docker.io 

आपको पोर्ट 8000 खोलने की भी आवश्यकता है। वेब सेवा का उपयोग करते समय हम इसका उपयोग करेंगे। Ssh के लिए पोर्ट 22 डिफ़ॉल्ट रूप से खुला है।

हुर्रे! अब हमारे पास अपने अनुप्रयोगों को चलाने के लिए एक दूरस्थ कंप्यूटर है। हम सर्वर पर सीधे कोड लिखेंगे।

Django (+ चैनल)

मैंने django का उपयोग करने का निर्णय लिया, क्योंकि यह आपको एक छोटी वेब सेवा को जल्दी और आसानी से बनाने की अनुमति देगा। एक अतिरिक्त django चैनल लाइब्रेरी हमें वेब सॉकेट (अर्थात् करने के लिए) के साथ काम करने का अवसर देगी कील पृष्ठ को ताज़ा किए बिना चित्रों को स्थानांतरित करके प्रसारित करें)।

एक निर्देशिका बनाएँ जिसमें परियोजना को जगह दी जाए। दस्तावेज़ में निर्देशों से विचलित किए बिना, django चैनलों के साथ django स्थापित करें।

 $ mkdir Project $ cd Project $ virtualenv venv $ source venv/bin/activate $ pip install -U channels #       django $ pip install channels_redis #    Redis $ pip install djangorestframework $ django-admin startproject mysite $ cd mysite 

हम एक प्रोजेक्ट बनाते हैं। हमारे पास 3 उपनिर्देशिकाएँ होंगी। मुख्य में एक ही नाम होगा - mysite (स्वचालित रूप से बनाया गया), अन्य दो - स्ट्रीमिंग और अपलोड करना। पहला एक वेब पेज पर जानकारी प्रदर्शित करने के लिए जिम्मेदार होगा, और दूसरा - इसे REST API के माध्यम से डाउनलोड करने के लिए।

 $ python3 manage.py startapp streaming $ cd streaming $ rm -r migrations admin.py apps.py models.py tests.py $ cd .. $ python3 manage.py startapp uploading $ cd uploading $ rm -r migrations admin.py apps.py models.py tests.py 

Django चैनल कॉन्फ़िगर करें। WSGI_APPLICATION के साथ लाइन पर टिप्पणी करें और ASGI_APPLICATION के साथ एक नया जोड़ें। अब हमारा आवेदन एसिंक्रोनस रूप से काम करेगा।

 # mysite/settings.py # ... # WSGI_APPLICATION = ... ASGI_APPLICATION = 'mysite.routing.application' # ... 

हम INSTALLED_APPS सूची के मूल्य को भी अपडेट करते हैं।

 # mysite/settings.py # ... INSTALLED_APPS = [ 'channels', 'streaming', 'uploading', 'rest_framework', 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', ] # ... 

आर्किटेक्चर

हम आधिकारिक django चैनल ट्यूटोरियल के आधार पर कोड लिखेंगे। हमारी छोटी सेवा की संरचना इस तरह दिखाई देगी:

MYIP: 8000 / फ्रेम - एक वेब पेज जो परिणाम को दिखाएगा, सशर्त रूप से, वह पृष्ठ जिसे ऑपरेटर देख रहा है
MYIP: मान्यता प्राप्त पाठ भेजने के लिए 8000 / अपलोड / अपलोड / अपलोड / - एक पोस्ट अनुरोध के लिए पता
MYIP: 8000 / अपलोड / अपलोड / अपलोड / - PUT अनुरोध के लिए पता, व्यक्तिगत चित्र भेजना

इस तर्क को संबंधित निर्देशिकाओं की urls.py फ़ाइलों में पंजीकृत करना आवश्यक है।

 # mysite/mysite/urls.py from django.contrib import admin from django.conf.urls import include, url urlpatterns = [ url(r'^frame/', include('streaming.urls')), url(r'^upload/', include('uploading.urls')), ] 

अन्य एपीआई

हम अपने एपीआई के तर्क का वर्णन करते हैं।

 # mysite/uploading/urls.py from django.conf.urls import url from rest_framework.urlpatterns import format_suffix_patterns from . import views urlpatterns = [ url(r'^upload_text/$', views.UploadTextView.as_view()), url(r'^upload_image/$', views.UploadImageView.as_view()), ] urlpatterns = format_suffix_patterns(urlpatterns) 

 # mysite/uploading/views.py from django.shortcuts import render from rest_framework.views import APIView from rest_framework.response import Response from channels.layers import get_channel_layer from rest_framework.parsers import FileUploadParser from asgiref.sync import async_to_sync import base64 # Create your views here. class UploadTextView(APIView): def post(self, request, format=None): message = request.query_params['message'] if not message: raise ParseError("Empty content") channel_layer = get_channel_layer() async_to_sync(channel_layer.group_send)("chat", { "type": "chat.message", "message": message, }) return Response({'status': 'ok'}) class UploadImageView(APIView): parser_class = (FileUploadParser,) def put(self, request, format=None): if 'file' not in request.data: raise ParseError("Empty content") f = request.data['file'] channel_layer = get_channel_layer() async_to_sync(channel_layer.group_send)("chat", { "type": "chat.message", "image64": base64.b64encode(f.read()).decode("ascii"), }) return Response({'status': 'ok'}) 

वेब पेज

सभी जानकारी एक पृष्ठ पर फिट होगी, इसलिए तर्क सरल होगा।

 # mysite/streaming/urls.py from django.conf.urls import url from . import views urlpatterns = [ url(r'^', views.index, name='index'), ] 

 # mysite/streaming/views.py from django.shortcuts import render from django.utils.safestring import mark_safe import json # Create your views here. def index(request): return render(request, 'index.html', {}) 

परिणाम प्रदर्शित करने के लिए हमें एक छोटा HTML दस्तावेज़ लिखना होगा। इसमें एक वेब सॉकेट से कनेक्ट करने और इसे सामग्री से भरने के लिए एक अंतर्निहित स्क्रिप्ट होगी।

 <!-- mysite/streaming/templates/index.html --> <!DOCTYPE html> <html> <head> <meta charset="utf-8"/> <title>Live from Android Things</title> </head> <body> <textarea id="chat-log" cols="100" rows="20"></textarea><br/> <img id="frame"> </body> <script> var chatSocket = new WebSocket( 'ws://' + window.location.host + '/ws/chat/'); chatSocket.onmessage = function(e) { var data = JSON.parse(e.data); var message = data['message']; var image64 = data['image64']; if (image64) { document.querySelector('#frame').setAttribute( 'src', 'data:image/png;base64,' + image64 ); } else if (message) { document.querySelector('#chat-log').value += (message + '\n'); } }; chatSocket.onclose = function(e) { console.error('Chat socket closed unexpectedly'); }; </script> </html> 

रूटिंग, सॉकेट्स कॉन्फ़िगर करें

रूसी में रूटिंग शब्द का सबसे अच्छा अनुवाद क्या है? आइए इस प्रश्न को हमारे सिर से बाहर निकालने की कोशिश करें और इसे (या उसके) सेट करें।

 # mysite/mysite/settings.py # ... ALLOWED_HOSTS = ['*'] #  []  ['*'],    # ... CHANNEL_LAYERS = { 'default': { 'BACKEND': 'channels_redis.core.RedisChannelLayer', 'CONFIG': { "hosts": [('127.0.0.1', 6379)], }, }, } 

अब आपको "फ़ॉरवर्डिंग" लॉजिक को रजिस्टर करने की ज़रूरत है (राउटिंग थ्रू फ़ाइलें urls.py फ़ाइलों के समान हैं, केवल अब वेब सॉकेट के लिए)।

 # mysite/mysite/routing.py from channels.auth import AuthMiddlewareStack from channels.routing import ProtocolTypeRouter, URLRouter import streaming.routing application = ProtocolTypeRouter({ # (http->django views is added by default) 'websocket': AuthMiddlewareStack( URLRouter( streaming.routing.websocket_urlpatterns ) ), }) 

 # mysite/streaming/routing.py from django.conf.urls import url from . import consumers websocket_urlpatterns = [ url(r'^ws/chat/$', consumers.FrameConsumer), ] 

और अब हम खुद ही फ्रेमवर्क को कंज्यूमरहोम में लागू कर रहे हैं

 # mysite/streaming/consumers.py from asgiref.sync import async_to_sync from channels.generic.websocket import WebsocketConsumer, JsonWebsocketConsumer import json class FrameConsumer(WebsocketConsumer): def connect(self): self.room_group_name = 'chat' # Join room group async_to_sync(self.channel_layer.group_add)( self.room_group_name, self.channel_name ) self.accept() def disconnect(self, close_code): # Leave room group async_to_sync(self.channel_layer.group_discard)( self.room_group_name, self.channel_name ) # Receive message from WebSocket def receive(self, text_data): text_data_json = json.loads(text_data) message = text_data_json['message'] # Send message to room group async_to_sync(self.channel_layer.group_send)( self.room_group_name, { 'type': 'chat_message', 'message': message } ) # Receive message from room group def chat_message(self, event): if 'message' in event: # Send message to WebSocket self.send(text_data=json.dumps({ 'message': event['message'] })) elif 'image64' in event: self.send(text_data=json.dumps({ 'image64': event['image64'] })) 

और अंत में, पसीने से तर हथेलियों के साथ हम लॉन्च करते हैं।

 $ docker run -p 6379:6379 -d redis:2.8 $ python manage.py runserver 0.0.0.0:8000 

और अब Android के बारे में

हम पाठ्य मान्यता के लिए एबीबीवाई से आरटीआर एसडीके का उपयोग करेंगे। हमारे उद्देश्यों के लिए अंतिम पैक आरटीआर एसडीके को यहां डाउनलोड किया जा सकता है । हम प्रसंस्करण फ्रेम के लिए एक काफी सरल इंटरफ़ेस लागू करते हैं, हमारा आवेदन पिछले लिंक (/ नमूना-टेक्स्टकैपचर) से डाउनलोड किए गए संग्रह से एक नमूना पर आधारित होगा। हम विशेष रूप से एंड्रॉइड थिंग्स के साथ काम करने के लिए, और सर्वर के साथ संचार को लागू करने के लिए, आवेदन से अतिरिक्त भागों को बाहर फेंक देंगे।

लाइब्रेरी .AR फ़ाइल डाउनलोड किए गए संग्रह की lib निर्देशिका में निहित है, हम आयात करते हैं। हम अपनी परियोजना की संपत्ति में संग्रह की संपत्ति निर्देशिका की सामग्री को कॉपी करते हैं (अनिवार्य रूप से मान्यता प्रक्रिया के लिए आवश्यक फाइलें)। वहां हम संग्रह से लाइसेंस फ़ाइल को कॉपी करते हैं, इसके बिना आवेदन शुरू नहीं होगा।

एबीबीवाई आरटीआर एसडीके कार्यक्षमता को लागू करने के लिए, हमें टाइप इंजन का एक ऑब्जेक्ट बनाने की आवश्यकता है, और इसका उपयोग पहले से ही टाइप किए गए ITextCaptureService का एक ऑब्जेक्ट है, जिसे हम बाद में लॉन्च करेंगे।

 try { mEngine = Engine.load(this, LICENSE_FILE_NAME); mTextCaptureService = mEngine.createTextCaptureService(textCaptureCallback); return true; } // ... 

इस स्थिति में, आपको ITextCaptureService.Callback के ऑब्जेक्ट को पास करना होगा, इसे सीधे हमारे MainActivity क्लास में बनाएं, इसे 3 तरीकों को लागू करना होगा।

 private ITextCaptureService.Callback textCaptureCallback = new ITextCaptureService.Callback() { @Override public void onRequestLatestFrame(byte[] buffer) { //  ,       . //    . mCamera.addCallbackBuffer(buffer); } @Override public void onFrameProcessed( ITextCaptureService.TextLine[] lines, ITextCaptureService.ResultStabilityStatus resultStatus, ITextCaptureService.Warning warning) { //      ,    if (resultStatus.ordinal() >= 3) { //   ,     mSurfaceViewWithOverlay.setLines(lines, resultStatus); } else { //  ,     mSurfaceViewWithOverlay.setLines(null, ITextCaptureService.ResultStabilityStatus.NotReady); } //  warnings // ... } @Override public void onError(Exception e) { //    } }; 

हमने कैमरा ऑब्जेक्ट को फ्रेम की प्राप्ति को सौंप दिया है। मैं दिखाऊंगा कि अंदर क्या हो रहा है।

 private Camera.PreviewCallback cameraPreviewCallback = new Camera.PreviewCallback() { @Override public void onPreviewFrame(byte[] data, Camera camera) { //     (    ) if (!mIsUploading) { mIsUploading = true; //    new UploadImageTask(mCameraPreviewSize.width, mCameraPreviewSize.height).execute(data); } //     mTextCaptureService.submitRequestedFrame(data); } }; 

संदेश भेजने के लिए, हम कुछ वर्गों को लिखते हैं, जो बदले में अपलोडर वर्ग की एक वस्तु पर अपना काम सौंपेंगे।

 public static class UploadTextTask extends AsyncTask<String, Void, Void> { @Override protected Void doInBackground(String... params) { mUploader.uploadText(params[0]); return null; } } public static class UploadImageTask extends AsyncTask<byte[], Void, Void> { private int mCameraPreviewWidth; private int mCameraPreviewHeight; public UploadImageTask(int width, int height) { mCameraPreviewWidth = width; mCameraPreviewHeight = height; } @Override protected Void doInBackground(final byte[]... params) { byte[] jpegBytes = convertToJpegBytes(params[0]); if (jpegBytes != null) { mUploader.uploadImage(jpegBytes); } return null; } private byte[] convertToJpegBytes(byte[] rawBytes) { YuvImage yuvImage = new YuvImage( rawBytes, ImageFormat.NV21, mCameraPreviewWidth, mCameraPreviewHeight, null ); try (ByteArrayOutputStream os = new ByteArrayOutputStream()) { yuvImage.compressToJpeg( new Rect(0, 0, mCameraPreviewWidth, mCameraPreviewHeight), 40, os ); return os.toByteArray(); } catch (IOException e) { Log.d(TAG, "compress error"); return null; } } // ... } 

अपलोडर वर्ग में नेटवर्क के साथ संचार सुविधाजनक OkHttp3 लाइब्रेरी का उपयोग करके कार्यान्वित किया जाता है। यह आपको सर्वर के साथ बातचीत को बहुत सरल बनाने की अनुमति देता है।

परिणाम

हमें ABBYY से मान्यता प्राप्त एक कामकाजी क्लाइंट-सर्वर एप्लिकेशन मिलता है, जिसे इंटरनेट ऑफ थिंग्स में बनाया गया है - क्या यह अच्छा नहीं है?

एक एकत्रित उपकरण और मेरे नियोक्ता का एक छोटा सा देशी विज्ञापन

पाठ मान्यता प्राप्त है

कई उपकरणों के अवलोकन के साथ सेल्फी पैनोरमा

Vidos, यह सब वास्तविक जीवन में कैसे दिख सकता है

गितुब पर रिपोजिटरी:

→ AndroidThingsTextRecognition-Backend
→ AndroidThingsTextRecognition-Android

लो और उपयोग करो!