Merge pull request #502 from jet47:opengl-updates

modules/core/include/opencv2/core/core.hpp

@@ -90,10 +90,18 @@ class Mat;
 class SparseMat;
 typedef Mat MatND;
 
+namespace ogl {
+    class Buffer;
+    class Texture2D;
+    class Arrays;
+}
+
+// < Deprecated
 class GlBuffer;
 class GlTexture;
 class GlArrays;
 class GlCamera;
+// >
 
 namespace gpu {
     class GpuMat;
@@ -1327,15 +1335,23 @@ public:
     template<typename _Tp, int m, int n> _InputArray(const Matx<_Tp, m, n>& matx);
     _InputArray(const Scalar& s);
     _InputArray(const double& val);
+    // < Deprecated
     _InputArray(const GlBuffer& buf);
     _InputArray(const GlTexture& tex);
+    // >
     _InputArray(const gpu::GpuMat& d_mat);
+    _InputArray(const ogl::Buffer& buf);
+    _InputArray(const ogl::Texture2D& tex);
 
     virtual Mat getMat(int i=-1) const;
     virtual void getMatVector(vector<Mat>& mv) const;
+    // < Deprecated
     virtual GlBuffer getGlBuffer() const;
     virtual GlTexture getGlTexture() const;
+    // >
     virtual gpu::GpuMat getGpuMat() const;
+    /*virtual*/ ogl::Buffer getOGlBuffer() const;
+    /*virtual*/ ogl::Texture2D getOGlTexture2D() const;
 
     virtual int kind() const;
     virtual Size size(int i=-1) const;
@@ -1387,6 +1403,8 @@ public:
     template<typename _Tp, int m, int n> _OutputArray(Matx<_Tp, m, n>& matx);
     template<typename _Tp> _OutputArray(_Tp* vec, int n);
     _OutputArray(gpu::GpuMat& d_mat);
+    _OutputArray(ogl::Buffer& buf);
+    _OutputArray(ogl::Texture2D& tex);
 
     _OutputArray(const Mat& m);
     template<typename _Tp> _OutputArray(const vector<_Tp>& vec);
@@ -1397,12 +1415,16 @@ public:
     template<typename _Tp, int m, int n> _OutputArray(const Matx<_Tp, m, n>& matx);
     template<typename _Tp> _OutputArray(const _Tp* vec, int n);
     _OutputArray(const gpu::GpuMat& d_mat);
+    _OutputArray(const ogl::Buffer& buf);
+    _OutputArray(const ogl::Texture2D& tex);
 
     virtual bool fixedSize() const;
     virtual bool fixedType() const;
     virtual bool needed() const;
     virtual Mat& getMatRef(int i=-1) const;
     /*virtual*/ gpu::GpuMat& getGpuMatRef() const;
+    /*virtual*/ ogl::Buffer& getOGlBufferRef() const;
+    /*virtual*/ ogl::Texture2D& getOGlTexture2DRef() const;
     virtual void create(Size sz, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
     virtual void create(int rows, int cols, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
     virtual void create(int dims, const int* size, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;

modules/core/include/opencv2/core/internal.hpp

@@ -751,7 +751,9 @@ typedef struct CvBigFuncTable
     (tab).fn_2d[CV_64F] = (void*)FUNCNAME##_64f##FLAG
 
 #ifdef __cplusplus
-//! OpenGL extension table
+
+// < Deprecated
+
 class CV_EXPORTS CvOpenGlFuncTab
 {
 public:
@@ -777,10 +779,16 @@ CV_EXPORTS void icvSetOpenGlFuncTab(const CvOpenGlFuncTab* tab);
 
 CV_EXPORTS bool icvCheckGlError(const char* file, const int line, const char* func = "");
 
+// >
+
+namespace cv { namespace ogl {
+CV_EXPORTS bool checkError(const char* file, const int line, const char* func = "");
+}}
+
 #if defined(__GNUC__)
-    #define CV_CheckGlError() CV_DbgAssert( (::icvCheckGlError(__FILE__, __LINE__, __func__)) )
+    #define CV_CheckGlError() CV_DbgAssert( (cv::ogl::checkError(__FILE__, __LINE__, __func__)) )
 #else
-    #define CV_CheckGlError() CV_DbgAssert( (::icvCheckGlError(__FILE__, __LINE__)) )
+    #define CV_CheckGlError() CV_DbgAssert( (cv::ogl::checkError(__FILE__, __LINE__)) )
 #endif
 
 #endif //__cplusplus

modules/core/src/matrix.cpp

@@ -43,6 +43,7 @@
 #include "precomp.hpp"
 #include "opencv2/core/gpumat.hpp"
 #include "opencv2/core/opengl_interop.hpp"
+#include "opencv2/core/opengl_interop_deprecated.hpp"
 
 /****************************************************************************************\
 *                           [scaled] Identity matrix initialization                      *
@@ -925,9 +926,13 @@ _InputArray::_InputArray(const Mat& m) : flags(MAT), obj((void*)&m) {}
 _InputArray::_InputArray(const vector<Mat>& vec) : flags(STD_VECTOR_MAT), obj((void*)&vec) {}
 _InputArray::_InputArray(const double& val) : flags(FIXED_TYPE + FIXED_SIZE + MATX + CV_64F), obj((void*)&val), sz(Size(1,1)) {}
 _InputArray::_InputArray(const MatExpr& expr) : flags(FIXED_TYPE + FIXED_SIZE + EXPR), obj((void*)&expr) {}
-_InputArray::_InputArray(const GlBuffer& buf) : flags(FIXED_TYPE + FIXED_SIZE + OPENGL_BUFFER), obj((void*)&buf) {}
-_InputArray::_InputArray(const GlTexture& tex) : flags(FIXED_TYPE + FIXED_SIZE + OPENGL_TEXTURE), obj((void*)&tex) {}
+// < Deprecated
+_InputArray::_InputArray(const GlBuffer&) : flags(0), obj(0) {}
+_InputArray::_InputArray(const GlTexture&) : flags(0), obj(0) {}
+// >
 _InputArray::_InputArray(const gpu::GpuMat& d_mat) : flags(GPU_MAT), obj((void*)&d_mat) {}
+_InputArray::_InputArray(const ogl::Buffer& buf) : flags(OPENGL_BUFFER), obj((void*)&buf) {}
+_InputArray::_InputArray(const ogl::Texture2D& tex) : flags(OPENGL_TEXTURE), obj((void*)&tex) {}
 
 Mat _InputArray::getMat(int i) const
 {
@@ -1068,39 +1073,45 @@ void _InputArray::getMatVector(vector<Mat>& mv) const
 }
 
 GlBuffer _InputArray::getGlBuffer() const
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+    return GlBuffer(GlBuffer::ARRAY_BUFFER);
+}
+
+GlTexture _InputArray::getGlTexture() const
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+    return GlTexture();
+}
+
+gpu::GpuMat _InputArray::getGpuMat() const
 {
     int k = kind();
 
-    CV_Assert(k == OPENGL_BUFFER);
-    //if( k == OPENGL_BUFFER )
-    {
-        const GlBuffer* buf = (const GlBuffer*)obj;
-        return *buf;
-    }
+    CV_Assert(k == GPU_MAT);
+
+    const gpu::GpuMat* d_mat = (const gpu::GpuMat*)obj;
+    return *d_mat;
 }
 
-GlTexture _InputArray::getGlTexture() const
+ogl::Buffer _InputArray::getOGlBuffer() const
 {
     int k = kind();
 
-    CV_Assert(k == OPENGL_TEXTURE);
-    //if( k == OPENGL_TEXTURE )
-    {
-        const GlTexture* tex = (const GlTexture*)obj;
-        return *tex;
-    }
+    CV_Assert(k == OPENGL_BUFFER);
+
+    const ogl::Buffer* gl_buf = (const ogl::Buffer*)obj;
+    return *gl_buf;
 }
 
-gpu::GpuMat _InputArray::getGpuMat() const
+ogl::Texture2D _InputArray::getOGlTexture2D() const
 {
     int k = kind();
 
-    CV_Assert(k == GPU_MAT);
-    //if( k == GPU_MAT )
-    {
-        const gpu::GpuMat* d_mat = (const gpu::GpuMat*)obj;
-        return *d_mat;
-    }
+    CV_Assert(k == OPENGL_TEXTURE);
+
+    const ogl::Texture2D* gl_tex = (const ogl::Texture2D*)obj;
+    return *gl_tex;
 }
 
 int _InputArray::kind() const
@@ -1167,14 +1178,14 @@ Size _InputArray::size(int i) const
     if( k == OPENGL_BUFFER )
     {
         CV_Assert( i < 0 );
-        const GlBuffer* buf = (const GlBuffer*)obj;
+        const ogl::Buffer* buf = (const ogl::Buffer*)obj;
         return buf->size();
     }
 
     if( k == OPENGL_TEXTURE )
     {
         CV_Assert( i < 0 );
-        const GlTexture* tex = (const GlTexture*)obj;
+        const ogl::Texture2D* tex = (const ogl::Texture2D*)obj;
         return tex->size();
     }
 
@@ -1235,10 +1246,7 @@ int _InputArray::type(int i) const
     }
 
     if( k == OPENGL_BUFFER )
-        return ((const GlBuffer*)obj)->type();
-
-    if( k == OPENGL_TEXTURE )
-        return ((const GlTexture*)obj)->type();
+        return ((const ogl::Buffer*)obj)->type();
 
     CV_Assert( k == GPU_MAT );
     //if( k == GPU_MAT )
@@ -1290,10 +1298,10 @@ bool _InputArray::empty() const
     }
 
     if( k == OPENGL_BUFFER )
-        return ((const GlBuffer*)obj)->empty();
+        return ((const ogl::Buffer*)obj)->empty();
 
     if( k == OPENGL_TEXTURE )
-        return ((const GlTexture*)obj)->empty();
+        return ((const ogl::Texture2D*)obj)->empty();
 
     CV_Assert( k == GPU_MAT );
     //if( k == GPU_MAT )
@@ -1308,10 +1316,14 @@ _OutputArray::~_OutputArray() {}
 _OutputArray::_OutputArray(Mat& m) : _InputArray(m) {}
 _OutputArray::_OutputArray(vector<Mat>& vec) : _InputArray(vec) {}
 _OutputArray::_OutputArray(gpu::GpuMat& d_mat) : _InputArray(d_mat) {}
+_OutputArray::_OutputArray(ogl::Buffer& buf) : _InputArray(buf) {}
+_OutputArray::_OutputArray(ogl::Texture2D& tex) : _InputArray(tex) {}
 
 _OutputArray::_OutputArray(const Mat& m) : _InputArray(m) {flags |= FIXED_SIZE|FIXED_TYPE;}
 _OutputArray::_OutputArray(const vector<Mat>& vec) : _InputArray(vec) {flags |= FIXED_SIZE;}
 _OutputArray::_OutputArray(const gpu::GpuMat& d_mat) : _InputArray(d_mat) {flags |= FIXED_SIZE|FIXED_TYPE;}
+_OutputArray::_OutputArray(const ogl::Buffer& buf) : _InputArray(buf) {flags |= FIXED_SIZE|FIXED_TYPE;}
+_OutputArray::_OutputArray(const ogl::Texture2D& tex) : _InputArray(tex) {flags |= FIXED_SIZE|FIXED_TYPE;}
 
 
 bool _OutputArray::fixedSize() const
@@ -1341,6 +1353,13 @@ void _OutputArray::create(Size _sz, int mtype, int i, bool allowTransposed, int
         ((gpu::GpuMat*)obj)->create(_sz, mtype);
         return;
     }
+    if( k == OPENGL_BUFFER && i < 0 && !allowTransposed && fixedDepthMask == 0 )
+    {
+        CV_Assert(!fixedSize() || ((ogl::Buffer*)obj)->size() == _sz);
+        CV_Assert(!fixedType() || ((ogl::Buffer*)obj)->type() == mtype);
+        ((ogl::Buffer*)obj)->create(_sz, mtype);
+        return;
+    }
     int sizes[] = {_sz.height, _sz.width};
     create(2, sizes, mtype, i, allowTransposed, fixedDepthMask);
 }
@@ -1362,6 +1381,13 @@ void _OutputArray::create(int rows, int cols, int mtype, int i, bool allowTransp
         ((gpu::GpuMat*)obj)->create(rows, cols, mtype);
         return;
     }
+    if( k == OPENGL_BUFFER && i < 0 && !allowTransposed && fixedDepthMask == 0 )
+    {
+        CV_Assert(!fixedSize() || ((ogl::Buffer*)obj)->size() == Size(cols, rows));
+        CV_Assert(!fixedType() || ((ogl::Buffer*)obj)->type() == mtype);
+        ((ogl::Buffer*)obj)->create(rows, cols, mtype);
+        return;
+    }
     int sizes[] = {rows, cols};
     create(2, sizes, mtype, i, allowTransposed, fixedDepthMask);
 }
@@ -1581,6 +1607,18 @@ void _OutputArray::release() const
         return;
     }
 
+    if( k == OPENGL_BUFFER )
+    {
+        ((ogl::Buffer*)obj)->release();
+        return;
+    }
+
+    if( k == OPENGL_TEXTURE )
+    {
+        ((ogl::Texture2D*)obj)->release();
+        return;
+    }
+
     if( k == NONE )
         return;
 
@@ -1646,6 +1684,20 @@ gpu::GpuMat& _OutputArray::getGpuMatRef() const
     return *(gpu::GpuMat*)obj;
 }
 
+ogl::Buffer& _OutputArray::getOGlBufferRef() const
+{
+    int k = kind();
+    CV_Assert( k == OPENGL_BUFFER );
+    return *(ogl::Buffer*)obj;
+}
+
+ogl::Texture2D& _OutputArray::getOGlTexture2DRef() const
+{
+    int k = kind();
+    CV_Assert( k == OPENGL_TEXTURE );
+    return *(ogl::Texture2D*)obj;
+}
+
 static _OutputArray _none;
 OutputArray noArray() { return _none; }
 

modules/gpu/test/test_precomp.hpp

@@ -70,6 +70,7 @@
     #include <cuda_runtime.h>
 
     #include "opencv2/core/core.hpp"
+    #include "opencv2/core/opengl_interop.hpp"
     #include "opencv2/highgui/highgui.hpp"
     #include "opencv2/calib3d/calib3d.hpp"
     #include "opencv2/imgproc/imgproc.hpp"

modules/highgui/include/opencv2/highgui/highgui.hpp

@@ -132,8 +132,10 @@ CV_EXPORTS void setOpenGlContext(const string& winname);
 
 CV_EXPORTS void updateWindow(const string& winname);
 
+// < Deperecated
 CV_EXPORTS void pointCloudShow(const string& winname, const GlCamera& camera, const GlArrays& arr);
 CV_EXPORTS void pointCloudShow(const string& winname, const GlCamera& camera, InputArray points, InputArray colors = noArray());
+// >
 
 //Only for Qt
 

modules/highgui/src/precomp.hpp

@@ -206,9 +206,6 @@ void cvSetRatioWindow_QT(const char* name,double prop_value);
 double cvGetOpenGlProp_QT(const char* name);
 #endif
 
-// OpenGL
-typedef void (CV_CDECL *CvOpenGlCleanCallback)(void* userdata);
-void icvSetOpenGlCleanCallback(const char* window_name, CvOpenGlCleanCallback callback, void* userdata);
 
 
 /*namespace cv

modules/highgui/src/window_QT.h

@@ -141,7 +141,6 @@ public slots:
     void enablePropertiesButtonEachWindow();
 
     void setOpenGlDrawCallback(QString name, void* callback, void* userdata);
-    void setOpenGlCleanCallback(QString name, void* callback, void* userdata);
     void setOpenGlContext(QString name);
     void updateWindow(QString name);
     double isOpenGl(QString name);
@@ -312,7 +311,6 @@ public:
     static void addSlider2(CvWindow* w, QString name, int* value, int count, CvTrackbarCallback2 on_change CV_DEFAULT(NULL), void* userdata CV_DEFAULT(0));
 
     void setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userdata);
-    void setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata);
     void makeCurrentOpenGlContext();
     void updateGl();
     bool isOpenGl();
@@ -397,7 +395,6 @@ public:
     virtual void startDisplayInfo(QString text, int delayms) = 0;
 
     virtual void setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userdata) = 0;
-    virtual void setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata) = 0;
     virtual void makeCurrentOpenGlContext() = 0;
     virtual void updateGl() = 0;
 
@@ -429,7 +426,6 @@ public:
     void startDisplayInfo(QString text, int delayms);
 
     void setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userdata);
-    void setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata);
     void makeCurrentOpenGlContext();
     void updateGl();
 
@@ -456,11 +452,6 @@ private:
     CvOpenGlDrawCallback glDrawCallback;
     void* glDrawData;
 
-    CvOpenGlCleanCallback glCleanCallback;
-    void* glCleanData;
-
-    CvOpenGlFuncTab* glFuncTab;
-
     void icvmouseHandler(QMouseEvent* event, type_mouse_event category, int& cv_event, int& flags);
     void icvmouseProcessing(QPointF pt, int cv_event, int flags);
 };
@@ -491,7 +482,6 @@ public:
     void startDisplayInfo(QString text, int delayms);
 
     void setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userdata);
-    void setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata);
     void makeCurrentOpenGlContext();
     void updateGl();