🙎🏾 🤤 👨🏿‍🤝‍👨🏻 क्यूटी और मोबाइल कैमरा। भाग 1, सिम्बियन 🦏 👨🏻‍🍳 ✝️

शुभ दिन, हेब्र!

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

तो, सिम्बियन कैमरा के साथ काम करने के लिए क्यूटी।

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

QtMobility की कुछ विशेषताओं के कारण पहली बार निर्णय जंगली में पैदा हुआ था। यदि हम दृश्यदर्शी (QVideoWidget या इसके वंशज QCameraViewfinder) पर चित्र प्रदर्शित करने के लिए सबसे सरल प्रत्यक्ष विधि का उपयोग करते हैं, तो हम निम्नलिखित समस्याओं का सामना करते हैं:

QVideoWidget खुद के ऊपर पारभासी विगेट्स प्रदान करने की अनुमति नहीं देता है (केवल काले रंग की आयतें पारदर्शिता के लिए प्राप्त की जाती हैं)
आप केवल फ़ाइल सिस्टम में इसकी अनिवार्य बचत (QCameraImageCapture का उपयोग करके) के साथ एक तस्वीर के रूप में एक वस्तु के रूप में एक छवि प्राप्त कर सकते हैं
ऊपर से यह इस प्रकार है कि दृश्यदर्शी के अंदर "छवि" को नियंत्रित करना असंभव है, अर्थात्, स्क्रीन पर हम केवल वही देखेंगे जो कैमरा खुद देखता है

इसके अलावा, अगर हम QWidget के माध्यम से दृश्यदर्शी पर प्रदर्शित होने के बाद छवि प्राप्त करने का प्रयास करते हैं :: रेंडर (), तो फिर से हम केवल एक काले आयत देखेंगे, क्योंकि QVideoWidget स्वयं प्रत्येक फ्रेम पर फिर से नहीं बनता है। इसी कारण से, दृश्यदर्शी के लिए QWidget :: paintEvent () विधि को फिर से परिभाषित करना बेकार है।

जब कार्य पहली बार हल किया गया था, तो हम अंततः देशी सिम्बियन कोड के उपयोग के लिए आए। परिणाम एक QObject है, जो प्रत्येक नए फ्रेम पर QPixmap के साथ एक सिंगल भेज रहा है। इस पिक्समैप को आवेदन में भी संसाधित किया गया था - इसे खींचा गया, भेजा गया, आदि।
और यद्यपि यह विकल्प पूरी तरह से चालू था, लेकिन यह आसानी से और जल्दी से अन्य प्लेटफार्मों पर पोर्ट करना संभव था, या किसी अन्य के लिए - मीगो।

आगे, मैं केवल Qt और QtMobility का उपयोग करके समस्या के समाधान का प्रस्ताव करता हूं, जो, वैसे, सरल है (विशेष रूप से उन लोगों के लिए जो सिम्बियन।सी ++ से परिचित नहीं हैं)।
नीचे दिया गया कोड आंशिक रूप से एक आधिकारिक उदाहरण पर आधारित है, जिसमें हमारे लिए बहुत कुछ है जो अप्रासंगिक है।

इसलिए, हम अलग-अलग ऑब्जेक्ट्स के रूप में Qt टूल्स का उपयोग करके सिम्बियन ^ 3 या सिम्बियन 5th संस्करण फोन पर कैमरे से वीडियो फ्रेम प्राप्त करते हैं। ऐसा करने के लिए, हम अपने स्वयं के दृश्यदर्शी लिखेंगे, प्रत्येक नए फ्रेम पर नए सिरे से प्रस्तुत किया जाएगा।
संचालन की योजना इस प्रकार है:

हम QAbstractVideoSurface सार वर्ग के वंशज बनाते हैं और दो शुद्ध आभासी विधियों को परिभाषित करते हैं QAbstractVideoSurface :: supportPixelFormats () और QAbstractVideoSurface :: present () इसमें। यह फ्रेम हैंडलर होगा जिससे कैमरे से डेटा प्रसारित किया जाएगा।
वर्तमान () विधि में, हम एक वीडियो फ्रेम को क्यूमैज ऑब्जेक्ट में बदलते हैं और इसे कॉलबैक में स्थानांतरित करते हैं
हम कैमरे को अपने एप्लिकेशन से कनेक्ट करते हैं और इसके लिए एक नया "सतह" (फ्रेम हैंडलर) सेट करते हैं - पहले पैराग्राफ से हमारी कक्षा का एक ऑब्जेक्ट
कॉलबैक विधि में QImage ऑब्जेक्ट प्राप्त करने पर, हम इसे अपने विवेक पर संसाधित करते हैं, इस मामले में हम इसे अपने व्यूफाइंडर के पेंट एवेंट () में आकर्षित करेंगे।

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

#include <QAbstractVideoSurface>

> वीडियोसर्फ़सिमेगेज़ोस्वर

 class VideoSurfaceImageObserver { public: virtual void newImage(QImage) = 0; };

आगे QAbstractVideoSurface से विरासत में मिली एक श्रेणी का निर्माण है:
> myvideosurface.h

 class myVideoSurface : public QAbstractVideoSurface { Q_OBJECT public: myVideoSurface(VideoSurfaceImageObserver *mObserver, QObject *parent = 0); bool present(const QVideoFrame &frame); QList<QVideoFrame::PixelFormat> supportedPixelFormats(QAbstractVideoBuffer::HandleType type=QAbstractVideoBuffer::NoHandle ) const; private: QVideoFrame m_frame; QImage::Format m_imageFormat; QVideoSurfaceFormat m_videoFormat; VideoSurfaceImageObserver *observer; };

> myvideosurface.cpp

 myVideoSurface::myVideoSurface(VideoSurfaceImageObserver *mObserver, QObject *parent) : QAbstractVideoSurface(parent) { //   ,   newImage()  //    observer = mObserver; m_imageFormat = QImage::Format_Invalid; } /** *  ,     *  video surface' * Symbian      */ QList<QVideoFrame::PixelFormat> myVideoSurface::supportedPixelFormats( QAbstractVideoBuffer::HandleType handleType) const { if (handleType == QAbstractVideoBuffer::NoHandle) { return QList<QVideoFrame::PixelFormat>() << QVideoFrame::Format_RGB32 << QVideoFrame::Format_ARGB32 << QVideoFrame::Format_ARGB32_Premultiplied << QVideoFrame::Format_RGB565 << QVideoFrame::Format_RGB555; } else { return QList<QVideoFrame::PixelFormat>(); } } /** *   . *,       QVideoFrame, *     QImage     */ bool myVideoSurface::present(const QVideoFrame &frame){ m_frame = frame; // " " -       //,    surface'. //       , //       if(surfaceFormat().pixelFormat() != m_frame.pixelFormat() || surfaceFormat().frameSize() != m_frame.size()) { stop(); return false; } else { //   QImage... if (m_frame.map(QAbstractVideoBuffer::ReadOnly)) { QImage image( m_frame.bits(), m_frame.width(), m_frame.height(), m_frame.bytesPerLine(), m_imageFormat); //...      observer->newImage(image); } return true; } }

अंत में, हमारे दृश्यदर्शी वर्ग बनाएँ।
> myviewfinder.h

 class myViewFinder: public QWidget, public VideoSurfaceImageObserver { Q_OBJECT public: explicit myViewFinder(QWidget *parent = 0); virtual ~myViewFinder(); //     void newImage(QImage); private: void paintEvent(QPaintEvent *); private: QCamera* camera_; myVideoSurface *surface; QImage *pix; };

> myviewfinder.pp

 myViewFinder::myViewFinder(QWidget *parent) : QWidget(parent), camera_(0), viewfinder_(0), pix(0) { //,   -  camera_ = new QCamera; //  video surface     //   surface = new myVideoSurface(this, this); //     pix = new QImage(); //---      //---  video surface QVideoRendererControl *control = qobject_cast<QVideoRendererControl *>( camera_->service()->requestControl("com.nokia.Qt.QVideoRendererControl/1.0")); if(control){ control->setSurface(surface); } //--- // ,     // myVideoSurface    camera_->start(); } /** *      , *  QImage */ void myViewFinder::newImage(QImage img){ // ... &pix = img; //...   . //  update() //   paintEvent() //  update(); } void myViewFinder::paintEvent(QPaintEvent *event){ QPainter painter(this); //  . // -  . painter.fillRect(this->geometry(), Qt::black); if(!pix) return; //     //  .    //    video surface //    if(!pix->isNull() && this->geometry().width() != 0 && this->geometry().height() != 0 && pix->width() != 0 && pix->height() != 0) { //   ... QRect pixR(pix->rect()); pixR.moveCenter(this->geometry().center()); //... ! painter.save(); painter.drawImage(pixR, *pix); painter.restore(); } } myViewFinder::~myViewFinder() { camera_->unload(); delete viewfinder_; delete camera_; delete pix; }

अब इमेज को रेंडर करने से पहले व्यूफाइंडर को काले रंग से क्यों भरें। सिम्बियन ^ 3 और सिम्बियन 5th संस्करण फोन का स्क्रीन आकार 640x360 है, और कैमरा रिज़ॉल्यूशन कम से कम 640x480 है। इसलिए यदि, उदाहरण के लिए, आपके पास दृश्यदर्शी के अलावा पूर्ण-स्क्रीन अनुप्रयोग में कुछ भी नहीं है, तो पहलू अनुपात आपको कैमरा छवि के साथ पूरी स्क्रीन को भरने की अनुमति नहीं देगा। ऐसा करने के लिए, पहले कैनवास को काले (या किसी अन्य रंग या चित्र) से भरें ताकि डेस्कटॉप या अन्य विजेट दृश्यदर्शी के चारों ओर न चमकें।

किनारों पर काली पट्टियों के बिना दृश्यदर्शी के साथ पूरे विजेट को भरने के लिए, लेकिन छवि के किनारों को क्रॉप करने के साथ, दर्द को दूर किया जा सकता है।

 void myViewFinder::paintEvent(QPaintEvent *event){ QPainter painter(this); if(!pix) return; if(!pix->isNull() && this->geometry().width() != 0 && this->geometry().height() != 0 && pix->width() != 0 && pix->height() != 0) { //  ,      QPixmap newPix = pix->scaled(this->size(), Qt::KeepAspectRatioByExpanding); QRect pixR(newPix.rect()); pixR.moveCenter(this->geometry().center()); //... ! painter.save(); painter.drawImage(pixR, newPix ); painter.restore(); } }

इस प्रकार, हमें एक पूर्ण दृश्यदर्शी मिला, जिसे आगे एक नियमित विजेट के रूप में उपयोग किया जा सकता है। इसके अलावा, फ्रेम के न्यूमेज () में आने के बाद, आप इसके साथ कुछ भी कर सकते हैं, जो QVideoWidget पर एक फायदा देता है।

अगले लेख में, मैं इस कोड को मीगो 1.2 हरमाटन में पोर्ट करने और बाद में चलने वाले उपकरणों में कैमरे की हार्डवेयर विशेषताओं से संबंधित इसके संशोधनों के बारे में बात करूंगा।

उपयोग किए गए स्रोत:

एक ही उदाहरण
अन्य अधिकारी Qt और QtMobility पर डॉक करते हैं

आपका ध्यान देने के लिए धन्यवाद।

क्यूटी और मोबाइल कैमरा। भाग 1, सिम्बियन

More articles: