Merge pull request #502 from jet47:opengl-updates

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
 {
@@ -1069,26 +1074,14 @@ void _InputArray::getMatVector(vector<Mat>& mv) const
 
 GlBuffer _InputArray::getGlBuffer() const
 {
-    int k = kind();
-
-    CV_Assert(k == OPENGL_BUFFER);
-    //if( k == OPENGL_BUFFER )
-    {
-        const GlBuffer* buf = (const GlBuffer*)obj;
-        return *buf;
-    }
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+    return GlBuffer(GlBuffer::ARRAY_BUFFER);
 }
 
 GlTexture _InputArray::getGlTexture() const
 {
-    int k = kind();
-
-    CV_Assert(k == OPENGL_TEXTURE);
-    //if( k == OPENGL_TEXTURE )
-    {
-        const GlTexture* tex = (const GlTexture*)obj;
-        return *tex;
-    }
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+    return GlTexture();
 }
 
 gpu::GpuMat _InputArray::getGpuMat() const
@@ -1096,11 +1089,29 @@ gpu::GpuMat _InputArray::getGpuMat() 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;
-    }
+
+    const gpu::GpuMat* d_mat = (const gpu::GpuMat*)obj;
+    return *d_mat;
+}
+
+ogl::Buffer _InputArray::getOGlBuffer() const
+{
+    int k = kind();
+
+    CV_Assert(k == OPENGL_BUFFER);
+
+    const ogl::Buffer* gl_buf = (const ogl::Buffer*)obj;
+    return *gl_buf;
+}
+
+ogl::Texture2D _InputArray::getOGlTexture2D() const
+{
+    int k = kind();
+
+    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/core/src/opengl_interop_deprecated.cpp

@@ -0,0 +1,331 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/core/opengl_interop_deprecated.hpp"
+#include "opencv2/core/gpumat.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::gpu;
+
+CvOpenGlFuncTab::~CvOpenGlFuncTab()
+{
+}
+
+void icvSetOpenGlFuncTab(const CvOpenGlFuncTab*)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+////////////////////////////////////////////////////////////////////////
+// GlBuffer
+
+class cv::GlBuffer::Impl
+{
+};
+
+cv::GlBuffer::GlBuffer(Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+cv::GlBuffer::GlBuffer(int, int, int, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+cv::GlBuffer::GlBuffer(Size, int, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+cv::GlBuffer::GlBuffer(InputArray, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlBuffer::create(int, int, int, Usage)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlBuffer::release()
+{
+}
+
+void cv::GlBuffer::copyFrom(InputArray)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlBuffer::bind() const
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlBuffer::unbind() const
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+Mat cv::GlBuffer::mapHost()
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+    return Mat();
+}
+
+void cv::GlBuffer::unmapHost()
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+GpuMat cv::GlBuffer::mapDevice()
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+    return GpuMat();
+}
+
+void cv::GlBuffer::unmapDevice()
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+template <> void cv::Ptr<cv::GlBuffer::Impl>::delete_obj()
+{
+    if (obj) delete obj;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// GlTexture
+
+class cv::GlTexture::Impl
+{
+};
+
+cv::GlTexture::GlTexture() : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+cv::GlTexture::GlTexture(int, int, int) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+cv::GlTexture::GlTexture(Size, int) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+cv::GlTexture::GlTexture(InputArray, bool) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlTexture::create(int, int, int)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlTexture::release()
+{
+}
+
+void cv::GlTexture::copyFrom(InputArray, bool)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlTexture::bind() const
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlTexture::unbind() const
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+template <> void cv::Ptr<cv::GlTexture::Impl>::delete_obj()
+{
+    if (obj) delete obj;
+}
+
+////////////////////////////////////////////////////////////////////////
+// GlArrays
+
+void cv::GlArrays::setVertexArray(InputArray)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlArrays::setColorArray(InputArray, bool)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlArrays::setNormalArray(InputArray)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlArrays::setTexCoordArray(InputArray)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlArrays::bind() const
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlArrays::unbind() const
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+////////////////////////////////////////////////////////////////////////
+// GlFont
+
+cv::GlFont::GlFont(const string& _family, int _height, Weight _weight, Style _style)
+    : family_(_family), height_(_height), weight_(_weight), style_(_style), base_(0)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlFont::draw(const char*, int) const
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+Ptr<GlFont> cv::GlFont::get(const std::string&, int, Weight, Style)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+    return Ptr<GlFont>();
+}
+
+////////////////////////////////////////////////////////////////////////
+// Rendering
+
+void cv::render(const GlTexture&, Rect_<double>, Rect_<double>)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::render(const GlArrays&, int, Scalar)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::render(const string&, const Ptr<GlFont>&, Scalar, Point2d)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+////////////////////////////////////////////////////////////////////////
+// GlCamera
+
+cv::GlCamera::GlCamera() :
+    eye_(0.0, 0.0, -5.0), center_(0.0, 0.0, 0.0), up_(0.0, 1.0, 0.0),
+    pos_(0.0, 0.0, -5.0), yaw_(0.0), pitch_(0.0), roll_(0.0),
+    useLookAtParams_(false),
+
+    scale_(1.0, 1.0, 1.0),
+
+    projectionMatrix_(),
+    fov_(45.0), aspect_(0.0),
+    left_(0.0), right_(1.0), bottom_(1.0), top_(0.0),
+    zNear_(-1.0), zFar_(1.0),
+    perspectiveProjection_(false)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlCamera::lookAt(Point3d, Point3d, Point3d)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlCamera::setCameraPos(Point3d, double, double, double)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlCamera::setScale(Point3d)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlCamera::setProjectionMatrix(const Mat&, bool)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlCamera::setPerspectiveProjection(double, double, double, double)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlCamera::setOrthoProjection(double, double, double, double, double, double)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlCamera::setupProjectionMatrix() const
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+void cv::GlCamera::setupModelViewMatrix() const
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+}
+
+////////////////////////////////////////////////////////////////////////
+// Error handling
+
+bool icvCheckGlError(const char*, const int, const char*)
+{
+    CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it");
+    return false;
+}