opengl.hpp

/*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*/
 
#ifndef OPENCV_CORE_OPENGL_HPP
#define OPENCV_CORE_OPENGL_HPP
 
#ifndef __cplusplus
#  error opengl.hpp header must be compiled as C++
#endif
 
#include "opencv2/core.hpp"
#include "ocl.hpp"
 
namespace cv { namespace ogl {
 
 
 
class CV_EXPORTS Buffer
{
public:
    enum Target
    {
        ARRAY_BUFFER         = 0x8892, 
        ELEMENT_ARRAY_BUFFER = 0x8893, 
        PIXEL_PACK_BUFFER    = 0x88EB, 
        PIXEL_UNPACK_BUFFER  = 0x88EC  
    };
 
    enum Access
    {
        READ_ONLY  = 0x88B8,
        WRITE_ONLY = 0x88B9,
        READ_WRITE = 0x88BA
    };
 
    Buffer();
 
    Buffer(int arows, int acols, int atype, unsigned int abufId, bool autoRelease = false);
 
    Buffer(Size asize, int atype, unsigned int abufId, bool autoRelease = false);
 
    Buffer(int arows, int acols, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false);
 
    Buffer(Size asize, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false);
 
    explicit Buffer(InputArray arr, Target target = ARRAY_BUFFER, bool autoRelease = false);
 
    void create(int arows, int acols, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false);
 
    void create(Size asize, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false);
 
    void release();
 
    void setAutoRelease(bool flag);
 
    void copyFrom(InputArray arr, Target target = ARRAY_BUFFER, bool autoRelease = false);
 
    void copyFrom(InputArray arr, cuda::Stream& stream, Target target = ARRAY_BUFFER, bool autoRelease = false);
 
    void copyTo(OutputArray arr) const;
 
    void copyTo(OutputArray arr, cuda::Stream& stream) const;
 
    Buffer clone(Target target = ARRAY_BUFFER, bool autoRelease = false) const;
 
    void bind(Target target) const;
 
    static void unbind(Target target);
 
    Mat mapHost(Access access);
 
    void unmapHost();
 
    cuda::GpuMat mapDevice();
    void unmapDevice();
 
    cuda::GpuMat mapDevice(cuda::Stream& stream);
 
    void unmapDevice(cuda::Stream& stream);
 
    int rows() const;
    int cols() const;
    Size size() const;
    bool empty() const;
 
    int type() const;
    int depth() const;
    int channels() const;
    int elemSize() const;
    int elemSize1() const;
 
    unsigned int bufId() const;
 
    class Impl;
 
private:
    Ptr<Impl> impl_;
    int rows_;
    int cols_;
    int type_;
};
 
class CV_EXPORTS Texture2D
{
public:
    enum Format
    {
        NONE            = 0,
        DEPTH_COMPONENT = 0x1902, 
        RGB             = 0x1907, 
        RGBA            = 0x1908  
    };
 
    Texture2D();
 
    Texture2D(int arows, int acols, Format aformat, unsigned int atexId, bool autoRelease = false);
 
    Texture2D(Size asize, Format aformat, unsigned int atexId, bool autoRelease = false);
 
    Texture2D(int arows, int acols, Format aformat, bool autoRelease = false);
 
    Texture2D(Size asize, Format aformat, bool autoRelease = false);
 
    explicit Texture2D(InputArray arr, bool autoRelease = false);
 
    void create(int arows, int acols, Format aformat, bool autoRelease = false);
    void create(Size asize, Format aformat, bool autoRelease = false);
 
    void release();
 
    void setAutoRelease(bool flag);
 
    void copyFrom(InputArray arr, bool autoRelease = false);
 
    void copyTo(OutputArray arr, int ddepth = CV_32F, bool autoRelease = false) const;
 
    void bind() const;
 
    int rows() const;
    int cols() const;
    Size size() const;
    bool empty() const;
 
    Format format() const;
 
    unsigned int texId() const;
 
    class Impl;
 
private:
    Ptr<Impl> impl_;
    int rows_;
    int cols_;
    Format format_;
};
 
class CV_EXPORTS Arrays
{
public:
    Arrays();
 
    void setVertexArray(InputArray vertex);
 
    void resetVertexArray();
 
    void setColorArray(InputArray color);
 
    void resetColorArray();
 
    void setNormalArray(InputArray normal);
 
    void resetNormalArray();
 
    void setTexCoordArray(InputArray texCoord);
 
    void resetTexCoordArray();
 
    void release();
 
    void setAutoRelease(bool flag);
 
    void bind() const;
 
    int size() const;
    bool empty() const;
 
private:
    int size_;
    Buffer vertex_;
    Buffer color_;
    Buffer normal_;
    Buffer texCoord_;
};
 
 
enum RenderModes {
    POINTS         = 0x0000,
    LINES          = 0x0001,
    LINE_LOOP      = 0x0002,
    LINE_STRIP     = 0x0003,
    TRIANGLES      = 0x0004,
    TRIANGLE_STRIP = 0x0005,
    TRIANGLE_FAN   = 0x0006,
    QUADS          = 0x0007,
    QUAD_STRIP     = 0x0008,
    POLYGON        = 0x0009
};
 
CV_EXPORTS void render(const Texture2D& tex,
    Rect_<double> wndRect = Rect_<double>(0.0, 0.0, 1.0, 1.0),
    Rect_<double> texRect = Rect_<double>(0.0, 0.0, 1.0, 1.0));
 
CV_EXPORTS void render(const Arrays& arr, int mode = POINTS, Scalar color = Scalar::all(255));
 
CV_EXPORTS void render(const Arrays& arr, InputArray indices, int mode = POINTS, Scalar color = Scalar::all(255));
 
 
namespace ocl {
using namespace cv::ocl;
 
// TODO static functions in the Context class
CV_EXPORTS Context& initializeContextFromGL();
 
} // namespace cv::ogl::ocl
 
CV_EXPORTS void convertToGLTexture2D(InputArray src, Texture2D& texture);
 
CV_EXPORTS void convertFromGLTexture2D(const Texture2D& texture, OutputArray dst);
 
CV_EXPORTS UMat mapGLBuffer(const Buffer& buffer, AccessFlag accessFlags = ACCESS_READ | ACCESS_WRITE);
 
CV_EXPORTS void unmapGLBuffer(UMat& u);
 
}} // namespace cv::ogl
 
namespace cv { namespace cuda {
 
CV_EXPORTS void setGlDevice(int device = 0);
 
}}
 
 
 
inline
cv::ogl::Buffer::Buffer(int arows, int acols, int atype, Target target, bool autoRelease) : rows_(0), cols_(0), type_(0)
{
    create(arows, acols, atype, target, autoRelease);
}
 
inline
cv::ogl::Buffer::Buffer(Size asize, int atype, Target target, bool autoRelease) : rows_(0), cols_(0), type_(0)
{
    create(asize, atype, target, autoRelease);
}
 
inline
void cv::ogl::Buffer::create(Size asize, int atype, Target target, bool autoRelease)
{
    create(asize.height, asize.width, atype, target, autoRelease);
}
 
inline
int cv::ogl::Buffer::rows() const
{
    return rows_;
}
 
inline
int cv::ogl::Buffer::cols() const
{
    return cols_;
}
 
inline
cv::Size cv::ogl::Buffer::size() const
{
    return Size(cols_, rows_);
}
 
inline
bool cv::ogl::Buffer::empty() const
{
    return rows_ == 0 || cols_ == 0;
}
 
inline
int cv::ogl::Buffer::type() const
{
    return type_;
}
 
inline
int cv::ogl::Buffer::depth() const
{
    return CV_MAT_DEPTH(type_);
}
 
inline
int cv::ogl::Buffer::channels() const
{
    return CV_MAT_CN(type_);
}
 
inline
int cv::ogl::Buffer::elemSize() const
{
    return CV_ELEM_SIZE(type_);
}
 
inline
int cv::ogl::Buffer::elemSize1() const
{
    return CV_ELEM_SIZE1(type_);
}
 
 
inline
cv::ogl::Texture2D::Texture2D(int arows, int acols, Format aformat, bool autoRelease) : rows_(0), cols_(0), format_(NONE)
{
    create(arows, acols, aformat, autoRelease);
}
 
inline
cv::ogl::Texture2D::Texture2D(Size asize, Format aformat, bool autoRelease) : rows_(0), cols_(0), format_(NONE)
{
    create(asize, aformat, autoRelease);
}
 
inline
void cv::ogl::Texture2D::create(Size asize, Format aformat, bool autoRelease)
{
    create(asize.height, asize.width, aformat, autoRelease);
}
 
inline
int cv::ogl::Texture2D::rows() const
{
    return rows_;
}
 
inline
int cv::ogl::Texture2D::cols() const
{
    return cols_;
}
 
inline
cv::Size cv::ogl::Texture2D::size() const
{
    return Size(cols_, rows_);
}
 
inline
bool cv::ogl::Texture2D::empty() const
{
    return rows_ == 0 || cols_ == 0;
}
 
inline
cv::ogl::Texture2D::Format cv::ogl::Texture2D::format() const
{
    return format_;
}
 
 
inline
cv::ogl::Arrays::Arrays() : size_(0)
{
}
 
inline
int cv::ogl::Arrays::size() const
{
    return size_;
}
 
inline
bool cv::ogl::Arrays::empty() const
{
    return size_ == 0;
}
 
 
#endif /* OPENCV_CORE_OPENGL_HPP */