OpenCV डेवलपर की सेवा पर Qt डिज़ाइनर और रनटाइम Qt लाइब्रेरीज़, या Qaleabel पर IplImage घसीटना

परिचय

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

टिप्पणी

• कॉफ़ीस्मोक के लेखक सरल सत्य, तरीके, और सूक्ष्मता को "चबा" नहीं पाते हैं । कोड स्पष्ट है। फ़ंक्शंस 20 लाइनों से अधिक नहीं हैं।
• लिनक्स के लिए Qt क्रिएटर पर परियोजना और उपयोग का मामला लागू किया गया है। विंडोज एप्लिकेशन डेवलपर्स को अपने ओएस के अनुसार .pro फाइलों में सेटिंग्स सेट करनी चाहिए
• लेखक "अन्यथा बेहतर होगा" जैसी चर्चाओं में प्रवेश नहीं करता है। सबसे अच्छा समाधान मिला, इसे लागू करें।
• लेखक Qt क्रिएटर और / या Qt डिज़ाइनर की सेटिंग के बारे में प्रश्नों का उत्तर नहीं देता है। आपकी मदद के लिए खोज इंजन!
• उपवास केवल मार्गदर्शन के लिए है और आपके विचारों की दिशा को इंगित करने के लिए कार्य करता है। वे कहां जाते हैं, आप बेहतर जानते हैं।

डिजाइन और कार्यान्वयन

क्रियान्वयन

हम थोड़ी देर के लिए छवियों के साथ काम करने के लिए ओपनसीवी लाइब्रेरी छोड़ देंगे। हमारा कार्य एक सार्वभौमिक रनटाइम लाइब्रेरी (कोड रनटाइम लाइब्रेरी) है।
शायद अब मैं जो दिखाऊंगा वह सार्वभौमिक रूप से उपयोग किया जाता है। हालाँकि, मैं Qt डिज़ाइनर के समान प्लग-इन के निर्माण के विषय पर खुले स्थानों में नहीं मिला।
परियोजना में Qt Designera प्लग-इन लाइब्रेरी को "खींचें" करने के लिए नहीं है, लेकिन रनटाइम लाइब्रेरी के साथ प्राप्त करने के लिए। जाहिर है, Qt Dessigner पैलेट में एक घटक प्रस्तुति विजेट के साथ रनटाइम लाइब्रेरी को "फंसाया" जा सकता है

डिजाइनर में एक सरल QLabel घटक होता है जो पिक्समैप संपत्ति का उपयोग करके एक छवि प्रसारित कर सकता है। हमारे उद्देश्यों के लिए यह पर्याप्त है। Qt डिज़ाइनर मॉड्यूल जोड़ना प्रलेखन के अनुवाद की ओर मुड़ना
और क्यूटी डिज़ाइनर के साथ कस्टम विजेट का उपयोग करके लिंक का उपयोग करने वाली जानकारी का सबसे स्रोत । सबसे उपयोगी कस्टम प्लगइन पुस्तकालयों के स्थान के बारे में जानकारी है! अब हम गंतव्य पथ को जानते हैं: $ $ qtdir / plugin / डिज़ाइनर
आइए नए घटक के आवरण को एक तरफ छोड़ दें। हम रनटाइम लाइब्रेरी के घटक से सीधे निपटेंगे। हमारे नए विजेट के CQtOpenCVImage वर्ग के साथ गतिशील रूप से भरी हुई लाइब्रेरी बनाएं।
हैडर फ़ाइल cqtopencvimage.h

#ifndef QTOPENCVIMAGE_H #define QTOPENCVIMAGE_H 

#include <QtDesigner / QDesignerExportWidget>

 #include <QWidget> #include <QUrl> #include <QLabel> #include "opencv2/opencv.hpp" #include <QScopedPointer> /*----------------------------------------------------------------------------*/ 

वर्ग CQtOpenCVImagePStreet;

 /*----------------------------------------------------------------------------*/ class #if defined(QDESIGNER_EXPORT_WIDGETS) QDESIGNER_WIDGET_EXPORT #else Q_DECL_EXPORT #endif 

CQtOpenCVImage

  : public QWidget { Q_OBJECT Q_PROPERTY(QUrl capture READ getCapture WRITE slot_setCapture) Q_PROPERTY(QString text READ getLabelText WRITE slot_setLabelText) Q_PROPERTY(QPixmap pixmap READ getPixmap WRITE slot_setPixmap) Q_PROPERTY(bool scaledContents READ hasScaledContents WRITE slot_setScaledContents) Q_PROPERTY(bool grayscale READ isGrayscale WRITE slot_setGrayscale) Q_PROPERTY(Qt::Alignment alignment READ getAlignment WRITE setAlignment) public: explicit CQtOpenCVImage(QWidget* parent = 0, Qt::WindowFlags f = 0); virtual ~CQtOpenCVImage(); QUrl& getCapture (); QString getLabelText () const; const QPixmap* getPixmap () const; const QImage* getImage () const; Qt::Alignment getAlignment() const; void setAlignment(Qt::Alignment); const QLabel* getQLabel () const; bool hasScaledContents() const; bool isGrayscale() const; public Q_SLOTS: void slot_setCapture ( const QUrl& ); void slot_setLabelText ( const QString& ); void slot_setPixmap ( const QPixmap& ); void slot_setImage ( const QImage& ); void slot_setQLabel ( const QLabel& ); void slot_setGrayscale(bool); void slot_setScaledContents(bool); Q_SIGNALS: void signal_Grayscale(bool); void signal_ImageChanged(); void signal_CaptureChanged(); void signal_PixmapChanged(); void signal_LabelChanged(); void signal_AlignmentChanged(); private: Q_DISABLE_COPY(CQtOpenCVImage) Q_DECLARE_PRIVATE(CQtOpenCVImage) 

QScopedPointer d_ptr;

 }; /*----------------------------------------------------------------------------*/ #endif // QTOPENCVIMAGE_H 

एक विशेष फ़ॉन्ट के साथ चिह्नित क्षेत्रों पर ध्यान दें ।

• QtDesigner / QDesignerExportWidget शीर्षलेख फ़ाइल शामिल करना सुनिश्चित करता है कि प्रोजेक्ट फ़ाइल में निर्देश का उपयोग करते समय आवश्यक QDESIGNER_WIDGET_EXPORT मैक्रो शामिल है

   DEFINES += QDESIGNER_EXPORT_WIDGETS 

• CQtOpenCVImagePrivate वर्ग CQtOpenCVImage मुख्य वर्ग की घोषणा से आंतरिक चर और संकेत छुपाता है। यह मुझे लगता है कि यह सही है: आपको अनावश्यक जानकारी वाले विज्ञापनों को अधिभार नहीं देना चाहिए;
• एक एकल निजी सूचक चर घोषित करें

   QScopedPointer<CQtOpenCVImagePrivate> d_ptr; 

  क्यूटी नियमों के ढांचे के भीतर एल्गोरिदम और डेटा के आंतरिक कार्यान्वयन की संरचना पर। IMHO, "अच्छा स्वर।"

हमारी CQtOpenCVImage क्लास दृश्य छवि नियंत्रण के लिए Qt डिज़ाइनर गुण (Q_PROPERTY) प्रदान करती है। संपत्ति रिकॉर्डिंग विधियों को शून्य स्लॉट _ **** (***) स्लॉट्स द्वारा कार्यान्वित किया जाता है।
और इसलिए, दृश्य डिजाइन के दौरान QWidget से विरासत में प्राप्त वेब (IP) कैमरा से प्राप्त छवि का प्रतिनिधित्व करने का वर्ग गुणों तक पहुँच देता है:

• कैप्चर - वीडियो कैप्चर डिवाइस या वेबकैम नंबर का URL;
• पाठ - पाठ शिलालेख। पाठ संपत्ति QLabel का एनालॉग;
• Pixmap - QPixmap के ऑब्जेक्ट के लिए एक पॉइंटर। Pixmap QLabel संपत्ति का एनालॉग;
• scaledContents - छवि मापनीयता। संपत्ति का एनालॉग स्केलडॉन्ट्स QLabel;
• ग्रेस्केल - छवि आउटपुट के रंग मोड के लिए एक बूलियन स्विच, जहां सच ग्रेस्केल और रंग के लिए गलत है (आरजीबी);
• संरेखण - पाठ और पिक्समैप की सामग्री का संरेखण। संरेखण संपत्ति QLabel का एनालॉग;

मुझे लगता है कि यह क्लास के तरीकों के उद्देश्य का वर्णन करने के लिए कोई मतलब नहीं है: नाम खुद के लिए बोलता है।

चलिए कक्षा कार्यान्वयन कोड (फ़ाइल cqtopencvimage.cpp ) पर चलते हैं ।

छिपे हुए वर्ग CQtOpenCVImagePrivate , इसकी विशेषताओं और विधियों पर विचार करें।

 class CQtOpenCVImagePrivate { Q_DECLARE_PUBLIC(CQtOpenCVImage) public: CQtOpenCVImagePrivate(CQtOpenCVImage* owner); virtual ~CQtOpenCVImagePrivate(); CQtOpenCVImage* q_ptr; //      QGridLayout* f_grid_layout; //          QLabel* f_label;//   QLabel    QUrl f_capture_path;// URL      QImage* p_qt_image; //      QImage CvCapture* p_capture; //         OpenCV IplImage* p_opencv_frame; //      p_capture uint f_grayscaled:1; //       void init (); //   void close (); //     void free_qt_image (); //    p_qt_image void new_qt_image ();//     p_qt_image void free_capture (); //    p_capture void new_capture (); //     p_capture }; 

चलो विधियों के कार्यान्वयन के लिए आगे बढ़ते हैं।

 /*----------------------------------------------------------------------------*/ void CQtOpenCVImagePrivate::init () { Q_ASSERT(q_ptr); f_grid_layout = new QGridLayout(q_ptr); Q_ASSERT(f_grid_layout); f_label = new QLabel(q_ptr/*, Qt::WindowNoState*/); Q_ASSERT(f_label); f_grid_layout->addWidget (f_label); p_qt_image = 0, p_capture = 0, p_opencv_frame = 0, f_grayscaled = 0; } /*----------------------------------------------------------------------------*/ inline void CQtOpenCVImagePrivate::close () { free_qt_image (); free_capture (); } /*----------------------------------------------------------------------------*/ CQtOpenCVImagePrivate::CQtOpenCVImagePrivate(CQtOpenCVImage* owner) : q_ptr(owner) { init (); } /*----------------------------------------------------------------------------*/ CQtOpenCVImagePrivate::~CQtOpenCVImagePrivate () { close (); if(!(f_label->parent ())) delete f_label; if(!(f_grid_layout->parent ())) delete f_grid_layout; } /*----------------------------------------------------------------------------*/ inline void CQtOpenCVImagePrivate::free_qt_image () { if(p_qt_image) { delete p_qt_image; p_qt_image = 0; } } /*----------------------------------------------------------------------------*/ inline void CQtOpenCVImagePrivate::free_capture () { if(p_capture) { cvReleaseCapture(&p_capture); p_capture = 0; } } 

कोड स्पष्ट और पठनीय है। कोई सवाल नहीं उठना चाहिए। निर्माता का CQtOpenCVImage * स्वामी पैरामीटर एक CQtOpenCVImage ऑब्जेक्ट के लिए एक पॉइंटर का प्रतिनिधित्व करता है, जिसमें चर CQtOpenCVImage के रूप में छिपे हुए वर्ग का एक उदाहरण होता है :: __ptr।
डॉक्टर के शब्दों में, फिल्म "फॉर्मूला ऑफ लव" से लियोनिद ब्रोनवॉय के नायक, "तो, मैं जारी रखूंगा ..."।

पर कब्जा डिवाइस की परिभाषा पर विचार करें new_capture विधि का उपयोग ।

 /*----------------------------------------------------------------------------*/ void CQtOpenCVImagePrivate::new_capture () { free_capture ();//   bool b_ok; int i_index = f_capture_path.toString ().toInt (&b_ok); //   ,   ,   URL /*   :  ,     CGI  ,     if(b_ok) { p_capture = cvCreateCameraCapture(i_index); if(p_capture) if(!p_opencv_frame) p_opencv_frame = cvQueryFrame (p_capture); } else { while((p_capture =cvCaptureFromFile(f_capture_path.toString ().toStdString ().c_str ()))) { p_opencv_frame = cvQueryFrame (p_capture); new_qt_image (); cvWaitKey (1000); } } */ // ,  ,  .     OpenCV. p_capture = b_ok ? cvCreateCameraCapture(i_index) : cvCaptureFromFile(f_capture_path.toString ().toStdString ().c_str ()); p_opencv_frame = p_capture ? cvQueryFrame (p_capture) : 0; //     OpenCV new_qt_image (); //   QImage } 

OpenCV के विस्तृत परिचय के लिए, सामग्री तालिका पढ़ें

प्रकार की इमेजिंग QImage:

 /*----------------------------------------------------------------------------*/ void CQtOpenCVImagePrivate::new_qt_image () { if(!p_capture) return; free_qt_image (); //     if(p_opencv_frame) { //  OpenCV       IplImage *_tmp = f_grayscaled ? cvCreateImage( cvSize( p_opencv_frame->width, p_opencv_frame->height ), IPL_DEPTH_8U, 1 ) : cvCloneImage (p_opencv_frame) ; try { //    RGB    cvCvtColor( p_opencv_frame, _tmp, f_grayscaled ? CV_RGB2GRAY : CV_BGR2RGB ); //    QImage p_qt_image = new QImage( (const uchar*)(_tmp->imageData), _tmp->width, _tmp->height, _tmp->widthStep, (f_grayscaled ? QImage::Format_Indexed8 : QImage::Format_RGB888) ); emit q_ptr->signal_ImageChanged (); //    q_ptr->slot_setPixmap (QPixmap::fromImage (*p_qt_image)); //    QLabel } catch(...) { // ...  --  ,  ! close (); } //     ! cvReleaseImage(&_tmp); } } 

मुझे लगता है कि आइसबर्ग के पानी के नीचे के हिस्से से सब कुछ स्पष्ट है

मुख्य वर्ग का कार्यान्वयन और भी सरल है। समझाने में भी आलसी। अपने लिए देखें:

 /*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/ CQtOpenCVImage::CQtOpenCVImage(QWidget* parent, Qt::WindowFlags f) : QWidget(parent, f), d_ptr(new CQtOpenCVImagePrivate(this)) { } /*----------------------------------------------------------------------------*/ CQtOpenCVImage::~CQtOpenCVImage() { } /*----------------------------------------------------------------------------*/ QUrl& CQtOpenCVImage::getCapture () { return (d_func ()->f_capture_path); } /*----------------------------------------------------------------------------*/ QString CQtOpenCVImage::getLabelText () const { return (d_func ()->f_label->text ()); } /*----------------------------------------------------------------------------*/ bool CQtOpenCVImage::hasScaledContents() const { return d_func ()->f_label->hasScaledContents (); } /*----------------------------------------------------------------------------*/ void CQtOpenCVImage::slot_setScaledContents(bool Value ) { d_func ()->f_label->setScaledContents (Value); } /*----------------------------------------------------------------------------*/ bool CQtOpenCVImage::isGrayscale() const { return d_func ()->f_grayscaled; } /*----------------------------------------------------------------------------*/ void CQtOpenCVImage::slot_setGrayscale( bool Value ) { if(d_func ()->f_grayscaled != Value) { d_func ()->f_grayscaled = Value; if(!(d_func ()->p_capture)) d_func ()->new_capture (); else d_func ()->new_qt_image (); emit signal_Grayscale (d_func ()->f_grayscaled); } } /*----------------------------------------------------------------------------*/ void CQtOpenCVImage::slot_setLabelText ( const QString& Value ) { d_func ()->f_label->setText (Value); } /*----------------------------------------------------------------------------*/ void CQtOpenCVImage::slot_setCapture ( const QUrl& Value ) { //       // if(getCapture ().toString () != Value.toString () || !d_func ()->p_opencv_frame) // { d_func ()->f_capture_path = Value.toString ().trimmed (); d_func ()->new_capture (); emit signal_CaptureChanged (); // } } /*----------------------------------------------------------------------------*/ const QPixmap* CQtOpenCVImage::getPixmap () const { return ((const QPixmap*)(d_func ()->f_label->pixmap ())); } /*----------------------------------------------------------------------------*/ void CQtOpenCVImage::slot_setPixmap ( const QPixmap& Value ) { d_func ()->f_label->setPixmap (Value); emit signal_PixmapChanged (); } /*----------------------------------------------------------------------------*/ const QImage* CQtOpenCVImage::getImage () const { return(d_func ()->p_qt_image); } /*----------------------------------------------------------------------------*/ void CQtOpenCVImage::slot_setImage ( const QImage& Value ) { d_func ()->free_qt_image (); d_func ()->p_qt_image = new QImage(Value); slot_setPixmap (QPixmap::fromImage (*(d_func ()->p_qt_image))); emit signal_ImageChanged (); } /*----------------------------------------------------------------------------*/ void CQtOpenCVImage::slot_setQLabel ( const QLabel& Value) { d_func ()->f_label->setText (Value.text ()); emit signal_LabelChanged (); } /*----------------------------------------------------------------------------*/ Qt::Alignment CQtOpenCVImage::getAlignment() const { return(d_func ()->f_label->alignment ()); } /*----------------------------------------------------------------------------*/ void CQtOpenCVImage::setAlignment(Qt::Alignment Value) { d_func ()->f_label->setAlignment (Value); emit signal_AlignmentChanged (); } /*----------------------------------------------------------------------------*/ const QLabel* CQtOpenCVImage::getQLabel () const { return ((const QLabel*)(d_func ()->f_label)); } 

हम एक रनटाइम लाइब्रेरी बनाते हैं। हम प्रोजेक्ट फ़ाइल images.pro का वर्णन करते हैं:

 TARGET = QtOpenCVImages TARGET = $$qtLibraryTarget($$TARGET) TEMPLATE = lib CONFIG += debug_and_release 

शामिल करने के लिए मत भूलना:

 DEFINES += QDESIGNER_EXPORT_WIDGETS 

लाइब्रेरी फ़ाइलों के लिए पथ को परिभाषित करें:

 unix:!symbian { target.path = $$PWD/../../../../lib DESTDIR = $$PWD/../../../../lib INSTALLS += target } 

वर्ग फ़ाइलें जोड़ें:

 SOURCES += \ cqtopencvimage.cpp HEADERS += \ cqtopencvimage.h 

OpenCV लाइब्रेरी फ़ाइलों के हेडर के पथ और प्रोजेक्ट निर्भरता के रास्तों को परिभाषित करें:

 INCLUDEPATH += /usr/include/opencv2 DEPENDPATH += /usr/include/opencv2 

हमारी परियोजना में OpenCV लाइब्रेरी (कोर और हाईगुई) जोड़ें:

 #win32:CONFIG(release): LIBS += -L/usr/lib/ -lopencv_core #else:win32:CONFIG(debug, debug|release): LIBS += -L/usr/lib/ -lopencv_cored #else: unix: LIBS += -L/usr/lib/ -lopencv_core #win32:CONFIG(release, debug|release): LIBS += -L$$PWD/../../../../../../usr/lib/release/ -lopencv_highgui #else:win32:CONFIG(debug, debug|release): LIBS += -L$$PWD/../../../../../../usr/lib/debug/ -lopencv_highguid #win32:CONFIG(release): LIBS += -L/usr/lib/release/ -lopencv_highgui #else:symbian: LIBS += -lopencv_highgui #else: unix: LIBS += -L/usr/lib/ -lopencv_highgui 

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

* NIX oids, /usr/lib निर्देशिका में एक स्थान से अपने पुस्तकालयों के लिंक बनाने के लिए ln -s कमांड का उपयोग करें

एक बार जब आप लिंक बना लेते हैं, तो बस प्रोजेक्ट का पुनर्निर्माण करें, और सब कुछ ठीक चलेगा!

इसलिए, हमने OpenCV टूल का उपयोग करके वेब कैमरा से प्राप्त एक चित्र प्रदर्शित करने के लिए विज़ुअल घटक की एक गतिशील Qt लाइब्रेरी बनाई है।

स्रोत कोड: वू एक ला (शाब्दिक)

डिज़ाइन

यह हमारे रनटाइम लाइब्रेरी को Qt डिज़ाइनर के लिए प्लग-इन के रैपर क्लास से जोड़ने का समय है।
एक प्लगइन पुस्तकालय परियोजना बनाएँ:

 TARGET = QtOpenCVWidgets TARGET = $$qtLibraryTarget($$TARGET) TEMPLATE = lib CONFIG += designer plugin release DEFINES += QDESIGNER_EXPORT_WIDGETS SOURCES += \ qtopencvimageplugin.cpp \ ../qtopencvwidgets.cpp HEADERS +=\ qtopencvimageplugin.h \ ../qtopencvwidgets.h \ ../runtime/images/cqtopencvimage.h RESOURCES += \ qtopencvimages.qrc unix:!symbian { target.path = $$PWD/../../../lib DESTDIR = $$PWD/../../../lib INSTALLS += target } INCLUDEPATH += /usr/include/opencv2 DEPENDPATH += /usr/include/opencv2 #win32:CONFIG(release, debug|release): LIBS += -L/usr/lib/ -lQtOpenCVImages #else:win32:CONFIG(debug, debug|release): LIBS += -L/usr/lib -lQtOpenCVImages #else:symbian: LIBS += -lQtOpenCVImages #else: unix: LIBS += -L/usr/lib -lQtOpenCVImages INCLUDEPATH += $$PWD/../runtime/images DEPENDPATH += $$PWD/../runtime/images 

एक रनटाइम प्रोजेक्ट की तरह लगता है, है ना? आइए कुछ अंतरों पर विचार करें:

• लाइब्रेरी का नाम बदल गया है: TARGET = QtOpenCVWidgets ;
• CONFIG + = डिज़ाइनर प्लगइन रिलीज़ पैरामीटर में प्लगइन और डिज़ाइनर टैग शामिल हैं;
• प्लगइन दो फ़ाइलों में से एक हैडर के प्रति और क्वोटोकेनविमेजप्लगिन के कार्यान्वयन के लिए लागू किया जाता है। * Qtopencvwidgets। * <। I>;
  अभी भी OpenCV लाइब्रेरी हेडर पर निर्भरता है हमारे QtOpenCVImages विजेट के शामिल cqtopencvimage.h हेडर पर निर्भरता;
  डायनेमिक रनटाइम लाइब्रेरी libQtOpenCVImages को /usr/lib/libQtOpenCVImages.so प्रतीकात्मक लिंक द्वारा सक्षम किया /usr/lib/libQtOpenCVImages.so , जो परियोजना निर्देशिका में इसके वास्तविक स्थान को दर्शाता है।
  

हम Qt के सभी कैनन के अनुसार Qt डिज़ाइनर प्लगइन विजेट बनाते हैं: Qt डिज़ाइनर के लिए कस्टम विजेट बनाना ( coffeesmoke , जैसा कि ज़ोर से कहा जाता है!)।
qtopencvimageplugin.h

 #ifndef QTOPENCVIMAGEPLUGIN_H #define QTOPENCVIMAGEPLUGIN_H #include <QObject> #include <QDesignerCustomWidgetInterface> class QtOpenCVImagePlugin : public QObject, public QDesignerCustomWidgetInterface { Q_OBJECT Q_INTERFACES(QDesignerCustomWidgetInterface) public: explicit QtOpenCVImagePlugin(QObject *parent = 0); QString name() const; QString includeFile() const; QString group() const; QIcon icon() const; QString toolTip() const; QString whatsThis() const; bool isContainer() const; QWidget* createWidget(QWidget *parent); void initialize(QDesignerFormEditorInterface *core); bool isInitialized() const; QString domXml() const; signals: public slots: private: bool f_init; }; #endif // QTOPENCVIMAGEPLUGIN_H 

मुख्य विचार: Q_INTERFACE के रूप में घोषित करने के लिए, QDesignerCustomWidgetInterface से विरासत में मिला और अपनी आवश्यकताओं के अनुसार डिज़ाइनर इंटरफ़ेस वर्ग के तरीकों को अधिभारित किया।

qtopencvimageplugin.cpp

 #include "qtopencvimageplugin.h" #include "cqtopencvimage.h" QtOpenCVImagePlugin::QtOpenCVImagePlugin(QObject *parent) : QObject(parent), f_init(false) { } QString QtOpenCVImagePlugin::name() const { return "CQtOpenCVImage";//    } QString QtOpenCVImagePlugin::includeFile() const { return QLatin1String("cqtopencvimage.h"); //     ui_*.h   } QString QtOpenCVImagePlugin::group() const { return tr("OpenCV Widgets"); //       Qt Designer } QIcon QtOpenCVImagePlugin::icon() const { return QIcon(":QtOpenCVLogo.png"); //   } QString QtOpenCVImagePlugin::toolTip() const { return QString(); } QString QtOpenCVImagePlugin::whatsThis() const { return QString(); } bool QtOpenCVImagePlugin::isContainer() const { return false; } QWidget* QtOpenCVImagePlugin::createWidget(QWidget *parent) { return new CQtOpenCVImage(parent); //  ,     ! } void QtOpenCVImagePlugin::initialize(QDesignerFormEditorInterface *core) { //        if (f_init) return; f_init = true; } bool QtOpenCVImagePlugin::isInitialized() const { return f_init; } QString QtOpenCVImagePlugin::domXml() const { //     return "<ui language=\"c++\">\n" " <widget class=\"CQtOpenCVImage\" name=\"QtOpenCVImage\">\n" " <property name=\"geometry\">\n" " <rect>\n" " <x>0</x>\n" " <y>0</y>\n" " <width>400</width>\n" " <height>200</height>\n" " </rect>\n" " </property>\n" " </widget>\n" "</ui>"; } 

बहुत कम बचा है: Qt <-> OpenCV समूह के हमारे सभी विजेट के लिए एक सामान्य आवरण-कंटेनर बनाएं
qtopencvwidgets.h

 #ifndef QTOPENCVWIDGETS_H #define QTOPENCVWIDGETS_H #include <QObject> #include <QtPlugin> #include <QDesignerCustomWidgetCollectionInterface> class QtOpenCVWidgets : public QObject, public QDesignerCustomWidgetCollectionInterface { Q_OBJECT Q_INTERFACES(QDesignerCustomWidgetCollectionInterface) public: explicit QtOpenCVWidgets(QObject *parent = 0); QList<QDesignerCustomWidgetInterface*> customWidgets() const { return f_plugins; } private: QList<QDesignerCustomWidgetInterface *> f_plugins; }; #endif // QTOPENCVWIDGETS_H 

qtopencvwidgets.cpp

 #include "qtopencvwidgets.h" #include "images/qtopencvimageplugin.h" QtOpenCVWidgets::QtOpenCVWidgets(QObject *parent) : QObject(parent) { f_plugins << new QtOpenCVImagePlugin(this); } //Q_DECLARE_INTERFACE(QtOpenCVWidgets, "com.trolltech.Qt.Designer.QtOpenCV") Q_EXPORT_PLUGIN2(qtopencvwidgetsplugin, QtOpenCVWidgets) 

ब्याज की रचना है, अर्थात्: f_plugins << new QtOpenCVImagePlugin(this); । अगली बार जब आप संग्रह में नए घटक जोड़ते हैं, तो यह एक और f_plugins ऑपरेटर जोड़कर निर्माता को फिर से लिखने के लिए पर्याप्त होगा << नया <अगला> प्लगइन (यह);

आवेदन

Qt डिज़ाइनर खोलें और घटक पैलेट में हमारे QtOpenCVImage को देखें। हम इसे एक नए रूप में रखते हैं। कैप्चर को वांछित URL में बदलें 192.168.0.20:8080/image.jpg 192.168.0.20:8080/image.jpg । इस मामले में, यह कैमरा सर्वर का जावा एपलेट है जो वर्तमान में अनुरोधित फ्रेम प्रदान करता है
grayscale संपत्ति की grayscale
स्रोत कोड: यदि आपने पहले डाउनलोड किया है, तो उस पर क्लिक न करें ।

निष्कर्ष

• हमने सीखा कि क्यूटी के दृश्य घटकों के आधार पर हमारे अपने वर्ग को लागू करने के लिए एक रनटाइम लाइब्रेरी कैसे बनाई जाए;
• हमने सीखा कि रनटाइम लाइब्रेरी को क्यूटी डिज़ाइनर प्लगइन में कैसे फ्रेम किया जाए, जिससे एप्लिकेशन को रनटाइम में डिज़ाइनर प्लगइन से स्वतंत्र बनाया जा सके;

क्षुधा

साधारण परीक्षण का मामला

आइए एक मानक क्यूटी जीयूआई एप्लिकेशन बनाएं, विंडो का मुख्य रूप खोलें, इसमें से हमारे घटक को रखें, कुछ सेवा नियंत्रण बनाएं, इसे बनाएं और चलाएं।
मान 0 (अंतर्निहित वीडियो कैमरा) में "पता ..." बदलें और छवि परिवर्तन देखें।

स्रोत कोड: यदि आपने पहले डाउनलोड किया है, तो उस पर क्लिक न करें ।

आगे क्या है?

• वर्तमान परियोजना का अनुकूलन;
• कैनी पद्धति का उपयोग करके छवि की सीमाओं को खोजने के लिए सिद्ध दृश्य घटक का विवरण: CQtOpenCVCanny वर्ग के आधार पर CQtOpenCVCannyWidget;
• QtOpenCVImage और QtOpenCVCanny के बीच संबंध

ऑल द बेस्ट।