From e06c3ec7c55cad7ac9fe5f687f11a4d1628c3d41 Mon Sep 17 00:00:00 2001 From: Vladislav Vinogradov Date: Tue, 19 Feb 2013 14:13:11 +0400 Subject: [PATCH 01/24] updated OpenGL functionality: * removed OpenGLFuncTab, now extensions are loaded internally * added support of GlBuffer and GlTexture2D to InputArray/OutputArray * added ELEMENT_ARRAY_BUFFER and PIXEL_PACK_BUFFER targets * added copyFrom/copyTo method for GlBuffer and GlTexture2D * removed GlFont * removed pointCloudShow * removed OpenGLCleanCallback * added Access parameter to GlBuffer::mapHost * added autoRelease parameter to all create methods --- modules/core/include/opencv2/core/core.hpp | 6 + .../core/include/opencv2/core/internal.hpp | 35 - .../include/opencv2/core/opengl_interop.hpp | 289 +- modules/core/src/gl_core_3_1.cpp | 2718 +++++++++++++++++ modules/core/src/gl_core_3_1.hpp | 1331 ++++++++ modules/core/src/matrix.cpp | 51 +- modules/core/src/opengl_interop.cpp | 1987 ++++++------ modules/gpu/test/test_opengl.cpp | 508 +++ modules/gpu/test/test_precomp.hpp | 1 + .../include/opencv2/highgui/highgui.hpp | 5 +- modules/highgui/src/precomp.hpp | 3 - modules/highgui/src/window.cpp | 247 +- modules/highgui/src/window_QT.cpp | 305 -- modules/highgui/src/window_QT.h | 10 - modules/highgui/src/window_gtk.cpp | 308 -- modules/highgui/src/window_w32.cpp | 315 -- samples/cpp/point_cloud.cpp | 353 --- samples/gpu/brox_optical_flow.cpp | 47 +- samples/gpu/highgui_gpu.cpp | 135 - samples/gpu/opengl.cpp | 125 + samples/gpu/pyrlk_optical_flow.cpp | 56 - 21 files changed, 5875 insertions(+), 2960 deletions(-) create mode 100644 modules/core/src/gl_core_3_1.cpp create mode 100644 modules/core/src/gl_core_3_1.hpp create mode 100644 modules/gpu/test/test_opengl.cpp delete mode 100644 samples/cpp/point_cloud.cpp delete mode 100644 samples/gpu/highgui_gpu.cpp create mode 100644 samples/gpu/opengl.cpp diff --git a/modules/core/include/opencv2/core/core.hpp b/modules/core/include/opencv2/core/core.hpp index 9d25916cd6..17dafb0ed4 100644 --- a/modules/core/include/opencv2/core/core.hpp +++ b/modules/core/include/opencv2/core/core.hpp @@ -1387,6 +1387,8 @@ public: template _OutputArray(Matx<_Tp, m, n>& matx); template _OutputArray(_Tp* vec, int n); _OutputArray(gpu::GpuMat& d_mat); + _OutputArray(GlBuffer& buf); + _OutputArray(GlTexture& tex); _OutputArray(const Mat& m); template _OutputArray(const vector<_Tp>& vec); @@ -1397,12 +1399,16 @@ public: template _OutputArray(const Matx<_Tp, m, n>& matx); template _OutputArray(const _Tp* vec, int n); _OutputArray(const gpu::GpuMat& d_mat); + _OutputArray(const GlBuffer& buf); + _OutputArray(const GlTexture& 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*/ GlBuffer& getGlBufferRef() const; + /*virtual*/ GlTexture& getGlTextureRef() 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; diff --git a/modules/core/include/opencv2/core/internal.hpp b/modules/core/include/opencv2/core/internal.hpp index 93e56c3ab3..c042ccaf1f 100644 --- a/modules/core/include/opencv2/core/internal.hpp +++ b/modules/core/include/opencv2/core/internal.hpp @@ -750,39 +750,4 @@ typedef struct CvBigFuncTable (tab).fn_2d[CV_32F] = (void*)FUNCNAME##_32f##FLAG; \ (tab).fn_2d[CV_64F] = (void*)FUNCNAME##_64f##FLAG -#ifdef __cplusplus -//! OpenGL extension table -class CV_EXPORTS CvOpenGlFuncTab -{ -public: - virtual ~CvOpenGlFuncTab(); - - virtual void genBuffers(int n, unsigned int* buffers) const = 0; - virtual void deleteBuffers(int n, const unsigned int* buffers) const = 0; - - virtual void bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const = 0; - virtual void bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const = 0; - - virtual void bindBuffer(unsigned int target, unsigned int buffer) const = 0; - - virtual void* mapBuffer(unsigned int target, unsigned int access) const = 0; - virtual void unmapBuffer(unsigned int target) const = 0; - - virtual void generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const = 0; - - virtual bool isGlContextInitialized() const = 0; -}; - -CV_EXPORTS void icvSetOpenGlFuncTab(const CvOpenGlFuncTab* tab); - -CV_EXPORTS bool icvCheckGlError(const char* file, const int line, const char* func = ""); - -#if defined(__GNUC__) - #define CV_CheckGlError() CV_DbgAssert( (::icvCheckGlError(__FILE__, __LINE__, __func__)) ) -#else - #define CV_CheckGlError() CV_DbgAssert( (::icvCheckGlError(__FILE__, __LINE__)) ) -#endif - -#endif //__cplusplus - #endif // __OPENCV_CORE_INTERNAL_HPP__ diff --git a/modules/core/include/opencv2/core/opengl_interop.hpp b/modules/core/include/opencv2/core/opengl_interop.hpp index 24aa546a43..8f7fe8fdc2 100644 --- a/modules/core/include/opencv2/core/opengl_interop.hpp +++ b/modules/core/include/opencv2/core/opengl_interop.hpp @@ -47,117 +47,169 @@ #include "opencv2/core/core.hpp" -namespace cv -{ +namespace cv { + +CV_EXPORTS bool checkGlError(const char* file, const int line, const char* func = ""); + +#if defined(__GNUC__) + #define CV_CheckGlError() CV_DbgAssert( (cv::checkGlError(__FILE__, __LINE__, __func__)) ) +#else + #define CV_CheckGlError() CV_DbgAssert( (cv::checkGlError(__FILE__, __LINE__)) ) +#endif + +/////////////////// OpenGL Objects /////////////////// + //! Smart pointer for OpenGL buffer memory with reference counting. class CV_EXPORTS GlBuffer { public: - enum Usage + enum Target { - ARRAY_BUFFER = 0x8892, // buffer will use for OpenGL arrays (vertices, colors, normals, etc) - TEXTURE_BUFFER = 0x88EC // buffer will ise for OpenGL textures + ARRAY_BUFFER = 0x8892, //!< The buffer will be used as a source for vertex data + ELEMENT_ARRAY_BUFFER = 0x8893, //!< The buffer will be used for indices (in glDrawElements, for example) + PIXEL_PACK_BUFFER = 0x88EB, //!< The buffer will be used for reading from OpenGL textures + PIXEL_UNPACK_BUFFER = 0x88EC //!< The buffer will be used for writing to OpenGL textures + }; + + enum Access + { + READ_ONLY = 0x88B8, + WRITE_ONLY = 0x88B9, + READ_WRITE = 0x88BA }; //! create empty buffer - explicit GlBuffer(Usage usage); + GlBuffer(); + + //! create buffer from existed buffer id + GlBuffer(int arows, int acols, int atype, unsigned int abufId, bool autoRelease = false); + GlBuffer(Size asize, int atype, unsigned int abufId, bool autoRelease = false); //! create buffer - GlBuffer(int rows, int cols, int type, Usage usage); - GlBuffer(Size size, int type, Usage usage); + GlBuffer(int arows, int acols, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false); + GlBuffer(Size asize, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false); //! copy from host/device memory - GlBuffer(InputArray mat, Usage usage); + explicit GlBuffer(InputArray arr, Target target = ARRAY_BUFFER, bool autoRelease = false); - void create(int rows, int cols, int type, Usage usage); - void create(Size size, int type, Usage usage); - void create(int rows, int cols, int type); - void create(Size size, int type); + //! create buffer + 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) { create(asize.height, asize.width, atype, target, autoRelease); } + //! release memory and delete buffer object void release(); - //! copy from host/device memory - void copyFrom(InputArray mat); + //! set auto release mode (if true, release will be called in object's destructor) + void setAutoRelease(bool flag); - void bind() const; - void unbind() const; + //! copy from host/device memory + void copyFrom(InputArray arr, Target target = ARRAY_BUFFER, bool autoRelease = false); + + //! copy to host/device memory + void copyTo(OutputArray arr, Target target = ARRAY_BUFFER, bool autoRelease = false) const; + + //! create copy of current buffer + GlBuffer clone(Target target = ARRAY_BUFFER, bool autoRelease = false) const; + + //! bind buffer for specified target + void bind(Target target) const; + + //! unbind any buffers from specified target + static void unbind(Target target); //! map to host memory - Mat mapHost(); + Mat mapHost(Access access); void unmapHost(); //! map to device memory gpu::GpuMat mapDevice(); void unmapDevice(); - inline int rows() const { return rows_; } - inline int cols() const { return cols_; } - inline Size size() const { return Size(cols_, rows_); } - inline bool empty() const { return rows_ == 0 || cols_ == 0; } + int rows() const { return rows_; } + int cols() const { return cols_; } + Size size() const { return Size(cols_, rows_); } + bool empty() const { return rows_ == 0 || cols_ == 0; } - inline int type() const { return type_; } - inline int depth() const { return CV_MAT_DEPTH(type_); } - inline int channels() const { return CV_MAT_CN(type_); } - inline int elemSize() const { return CV_ELEM_SIZE(type_); } - inline int elemSize1() const { return CV_ELEM_SIZE1(type_); } + int type() const { return type_; } + int depth() const { return CV_MAT_DEPTH(type_); } + int channels() const { return CV_MAT_CN(type_); } + int elemSize() const { return CV_ELEM_SIZE(type_); } + int elemSize1() const { return CV_ELEM_SIZE1(type_); } - inline Usage usage() const { return usage_; } + unsigned int bufId() const; class Impl; + private: + Ptr impl_; int rows_; int cols_; int type_; - Usage usage_; - - Ptr impl_; }; template <> CV_EXPORTS void Ptr::delete_obj(); -//! Smart pointer for OpenGL 2d texture memory with reference counting. +//! Smart pointer for OpenGL 2D texture memory with reference counting. class CV_EXPORTS GlTexture { public: + enum Format + { + NONE = 0, + DEPTH_COMPONENT = 0x1902, //!< Depth + RGB = 0x1907, //!< Red, Green, Blue + RGBA = 0x1908 //!< Red, Green, Blue, Alpha + }; + //! create empty texture GlTexture(); + //! create texture from existed texture id + GlTexture(int arows, int acols, Format aformat, unsigned int atexId, bool autoRelease = false); + GlTexture(Size asize, Format aformat, unsigned int atexId, bool autoRelease = false); + //! create texture - GlTexture(int rows, int cols, int type); - GlTexture(Size size, int type); + GlTexture(int arows, int acols, Format aformat, bool autoRelease = false); + GlTexture(Size asize, Format aformat, bool autoRelease = false); //! copy from host/device memory - explicit GlTexture(InputArray mat, bool bgra = true); + explicit GlTexture(InputArray arr, bool autoRelease = false); - void create(int rows, int cols, int type); - void create(Size size, int type); + //! create texture + void create(int arows, int acols, Format aformat, bool autoRelease = false); + void create(Size asize, Format aformat, bool autoRelease = false) { create(asize.height, asize.width, aformat, autoRelease); } + + //! release memory and delete texture object void release(); + //! set auto release mode (if true, release will be called in object's destructor) + void setAutoRelease(bool flag); + //! copy from host/device memory - void copyFrom(InputArray mat, bool bgra = true); + void copyFrom(InputArray arr, bool autoRelease = false); + //! copy to host/device memory + void copyTo(OutputArray arr, int ddepth = CV_32F, bool autoRelease = false) const; + + //! bind texture to current active texture unit for GL_TEXTURE_2D target void bind() const; - void unbind() const; - inline int rows() const { return rows_; } - inline int cols() const { return cols_; } - inline Size size() const { return Size(cols_, rows_); } - inline bool empty() const { return rows_ == 0 || cols_ == 0; } + int rows() const { return rows_; } + int cols() const { return cols_; } + Size size() const { return Size(cols_, rows_); } + bool empty() const { return rows_ == 0 || cols_ == 0; } - inline int type() const { return type_; } - inline int depth() const { return CV_MAT_DEPTH(type_); } - inline int channels() const { return CV_MAT_CN(type_); } - inline int elemSize() const { return CV_ELEM_SIZE(type_); } - inline int elemSize1() const { return CV_ELEM_SIZE1(type_); } + Format format() const { return format_; } + + unsigned int texId() const; class Impl; + private: + Ptr impl_; int rows_; int cols_; - int type_; - - Ptr impl_; - GlBuffer buf_; + Format format_; }; template <> CV_EXPORTS void Ptr::delete_obj(); @@ -166,83 +218,38 @@ template <> CV_EXPORTS void Ptr::delete_obj(); class CV_EXPORTS GlArrays { public: - inline GlArrays() - : vertex_(GlBuffer::ARRAY_BUFFER), color_(GlBuffer::ARRAY_BUFFER), bgra_(true), normal_(GlBuffer::ARRAY_BUFFER), texCoord_(GlBuffer::ARRAY_BUFFER) - { - } + GlArrays(); void setVertexArray(InputArray vertex); - inline void resetVertexArray() { vertex_.release(); } + void resetVertexArray(); - void setColorArray(InputArray color, bool bgra = true); - inline void resetColorArray() { color_.release(); } + void setColorArray(InputArray color); + void resetColorArray(); void setNormalArray(InputArray normal); - inline void resetNormalArray() { normal_.release(); } + void resetNormalArray(); void setTexCoordArray(InputArray texCoord); - inline void resetTexCoordArray() { texCoord_.release(); } + void resetTexCoordArray(); + + void release(); + + void setAutoRelease(bool flag); void bind() const; - void unbind() const; - inline int rows() const { return vertex_.rows(); } - inline int cols() const { return vertex_.cols(); } - inline Size size() const { return vertex_.size(); } - inline bool empty() const { return vertex_.empty(); } + int size() const { return size_; } + bool empty() const { return size_ == 0; } private: + int size_; GlBuffer vertex_; GlBuffer color_; - bool bgra_; GlBuffer normal_; GlBuffer texCoord_; }; -//! OpenGL Font -class CV_EXPORTS GlFont -{ -public: - enum Weight - { - WEIGHT_LIGHT = 300, - WEIGHT_NORMAL = 400, - WEIGHT_SEMIBOLD = 600, - WEIGHT_BOLD = 700, - WEIGHT_BLACK = 900 - }; - - enum Style - { - STYLE_NORMAL = 0, - STYLE_ITALIC = 1, - STYLE_UNDERLINE = 2 - }; - - static Ptr get(const std::string& family, int height = 12, Weight weight = WEIGHT_NORMAL, Style style = STYLE_NORMAL); - - void draw(const char* str, int len) const; - - inline const std::string& family() const { return family_; } - inline int height() const { return height_; } - inline Weight weight() const { return weight_; } - inline Style style() const { return style_; } - -private: - GlFont(const std::string& family, int height, Weight weight, Style style); - - std::string family_; - int height_; - Weight weight_; - Style style_; - - unsigned int base_; - - GlFont(const GlFont&); - GlFont& operator =(const GlFont&); -}; - -//! render functions +/////////////////// Render Functions /////////////////// //! render texture rectangle in window CV_EXPORTS void render(const GlTexture& tex, @@ -267,67 +274,13 @@ namespace RenderMode { //! render OpenGL arrays CV_EXPORTS void render(const GlArrays& arr, int mode = RenderMode::POINTS, Scalar color = Scalar::all(255)); +CV_EXPORTS void render(const GlArrays& arr, InputArray indices, int mode = RenderMode::POINTS, Scalar color = Scalar::all(255)); -CV_EXPORTS void render(const std::string& str, const Ptr& font, Scalar color, Point2d pos); - -//! OpenGL camera -class CV_EXPORTS GlCamera -{ -public: - GlCamera(); - - void lookAt(Point3d eye, Point3d center, Point3d up); - void setCameraPos(Point3d pos, double yaw, double pitch, double roll); - - void setScale(Point3d scale); - - void setProjectionMatrix(const Mat& projectionMatrix, bool transpose = true); - void setPerspectiveProjection(double fov, double aspect, double zNear, double zFar); - void setOrthoProjection(double left, double right, double bottom, double top, double zNear, double zFar); - - void setupProjectionMatrix() const; - void setupModelViewMatrix() const; - -private: - Point3d eye_; - Point3d center_; - Point3d up_; - - Point3d pos_; - double yaw_; - double pitch_; - double roll_; - - bool useLookAtParams_; - - Point3d scale_; - - Mat projectionMatrix_; - - double fov_; - double aspect_; - - double left_; - double right_; - double bottom_; - double top_; - - double zNear_; - double zFar_; - - bool perspectiveProjection_; -}; - -inline void GlBuffer::create(Size _size, int _type, Usage _usage) { create(_size.height, _size.width, _type, _usage); } -inline void GlBuffer::create(int _rows, int _cols, int _type) { create(_rows, _cols, _type, usage()); } -inline void GlBuffer::create(Size _size, int _type) { create(_size.height, _size.width, _type, usage()); } -inline void GlTexture::create(Size _size, int _type) { create(_size.height, _size.width, _type); } - -namespace gpu -{ +namespace gpu { //! set a CUDA device to use OpenGL interoperability CV_EXPORTS void setGlDevice(int device = 0); } + } // namespace cv #endif // __cplusplus diff --git a/modules/core/src/gl_core_3_1.cpp b/modules/core/src/gl_core_3_1.cpp new file mode 100644 index 0000000000..3bc74faa19 --- /dev/null +++ b/modules/core/src/gl_core_3_1.cpp @@ -0,0 +1,2718 @@ +#include +#include +#include "cvconfig.h" +#include "opencv2/core/core.hpp" +#include "gl_core_3_1.hpp" + +#ifdef HAVE_OPENGL + #if defined(__APPLE__) + #include + + static void* AppleGLGetProcAddress (const char* name) + { + static const struct mach_header* image = 0; + if (!image) + image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR); + + // prepend a '_' for the Unix C symbol mangling convention + std::string symbolName = "_"; + symbolName += std::string(name); + + NSSymbol symbol = image ? NSLookupSymbolInImage(image, &symbolName[0], NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : 0; + + return symbol ? NSAddressOfSymbol(symbol) : 0; + } + #endif // __APPLE__ + + #if defined(__sgi) || defined (__sun) + #include + #include + + static void* SunGetProcAddress (const char* name) + { + typedef void* (func_t*)(const GLubyte*); + + static void* h = 0; + static func_t gpa = 0; + + if (!h) + { + h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL); + if (!h) + return 0; + gpa = (func_t) dlsym(h, "glXGetProcAddress"); + } + + return gpa ? gpa((const GLubyte*) name) : dlsym(h, name); + } + #endif // __sgi || __sun + + #if defined(_WIN32) + #ifdef _MSC_VER + #pragma warning(disable: 4055) + #pragma warning(disable: 4054) + #endif + + static int TestPointer(const PROC pTest) + { + if(!pTest) + return 0; + + ptrdiff_t iTest = (ptrdiff_t) pTest; + + if (iTest == 1 || iTest == 2 || iTest == 3 || iTest == -1) + return 0; + + return 1; + } + + static PROC WinGetProcAddress(const char* name) + { + PROC pFunc = wglGetProcAddress((LPCSTR) name); + if (TestPointer(pFunc)) + return pFunc; + + HMODULE glMod = GetModuleHandleA("OpenGL32.dll"); + return (PROC) GetProcAddress(glMod, (LPCSTR) name); + } + #endif // _WIN32 + + #if defined(_WIN32) + #define CV_GL_GET_PROC_ADDRESS(name) WinGetProcAddress(name) + #elif defined(__APPLE__) + #define CV_GL_GET_PROC_ADDRESS(name) AppleGLGetProcAddress(name) + #elif defined(__sgi) || defined(__sun) + #define CV_GL_GET_PROC_ADDRESS(name) SunGetProcAddress(name) + #else // GLX + #include + + #define CV_GL_GET_PROC_ADDRESS(name) glXGetProcAddressARB((const GLubyte*) name) + #endif + + static void* IntGetProcAddress(const char* name) + { + void* func = (void*) CV_GL_GET_PROC_ADDRESS(name); + if (!func) + { + std::ostringstream msg; + msg << "Can't load OpenGL extension [" << name << "]"; + CV_Error(CV_OpenGlApiCallError, msg.str()); + } + return func; + } +#else + static void* IntGetProcAddress(const char*) + { + CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); + return 0; + } +#endif + +namespace gl +{ + ////////////////////////////////////////////// + // Function pointer types + + // Extension: 1.1 + typedef void (CODEGEN_FUNCPTR *PFNCULLFACEPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNFRONTFACEPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNHINTPROC)(GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNLINEWIDTHPROC)(GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNPOINTSIZEPROC)(GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNPOLYGONMODEPROC)(GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNSCISSORPROC)(GLint , GLint , GLsizei , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERFPROC)(GLenum , GLenum , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERFVPROC)(GLenum , GLenum , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIPROC)(GLenum , GLenum , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIVPROC)(GLenum , GLenum , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNTEXIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNTEXIMAGE2DPROC)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNDRAWBUFFERPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNCLEARPROC)(GLbitfield ); + typedef void (CODEGEN_FUNCPTR *PFNCLEARCOLORPROC)(GLfloat , GLfloat , GLfloat , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNCLEARSTENCILPROC)(GLint ); + typedef void (CODEGEN_FUNCPTR *PFNCLEARDEPTHPROC)(GLdouble ); + typedef void (CODEGEN_FUNCPTR *PFNSTENCILMASKPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNCOLORMASKPROC)(GLboolean , GLboolean , GLboolean , GLboolean ); + typedef void (CODEGEN_FUNCPTR *PFNDEPTHMASKPROC)(GLboolean ); + typedef void (CODEGEN_FUNCPTR *PFNDISABLEPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNENABLEPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNFINISHPROC)(); + typedef void (CODEGEN_FUNCPTR *PFNFLUSHPROC)(); + typedef void (CODEGEN_FUNCPTR *PFNBLENDFUNCPROC)(GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNLOGICOPPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNSTENCILFUNCPROC)(GLenum , GLint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNSTENCILOPPROC)(GLenum , GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNDEPTHFUNCPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNPIXELSTOREFPROC)(GLenum , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNPIXELSTOREIPROC)(GLenum , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNREADBUFFERPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNREADPIXELSPROC)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNGETBOOLEANVPROC)(GLenum , GLboolean *); + typedef void (CODEGEN_FUNCPTR *PFNGETDOUBLEVPROC)(GLenum , GLdouble *); + typedef GLenum (CODEGEN_FUNCPTR *PFNGETERRORPROC)(); + typedef void (CODEGEN_FUNCPTR *PFNGETFLOATVPROC)(GLenum , GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNGETINTEGERVPROC)(GLenum , GLint *); + typedef const GLubyte * (CODEGEN_FUNCPTR *PFNGETSTRINGPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNGETTEXIMAGEPROC)(GLenum , GLint , GLenum , GLenum , GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERFVPROC)(GLenum , GLenum , GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIVPROC)(GLenum , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETTEXLEVELPARAMETERFVPROC)(GLenum , GLint , GLenum , GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNGETTEXLEVELPARAMETERIVPROC)(GLenum , GLint , GLenum , GLint *); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISENABLEDPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNDEPTHRANGEPROC)(GLdouble , GLdouble ); + typedef void (CODEGEN_FUNCPTR *PFNVIEWPORTPROC)(GLint , GLint , GLsizei , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNDRAWARRAYSPROC)(GLenum , GLint , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNDRAWELEMENTSPROC)(GLenum , GLsizei , GLenum , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNGETPOINTERVPROC)(GLenum , GLvoid* *); + typedef void (CODEGEN_FUNCPTR *PFNPOLYGONOFFSETPROC)(GLfloat , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXIMAGE1DPROC)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXIMAGE2DPROC)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNBINDTEXTUREPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDELETETEXTURESPROC)(GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNGENTEXTURESPROC)(GLsizei , GLuint *); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISTEXTUREPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNINDEXUBPROC)(GLubyte ); + typedef void (CODEGEN_FUNCPTR *PFNINDEXUBVPROC)(const GLubyte *); + + // Extension: 1.2 + typedef void (CODEGEN_FUNCPTR *PFNBLENDCOLORPROC)(GLfloat , GLfloat , GLfloat , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNBLENDEQUATIONPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNDRAWRANGEELEMENTSPROC)(GLenum , GLuint , GLuint , GLsizei , GLenum , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei ); + + // Extension: 1.3 + typedef void (CODEGEN_FUNCPTR *PFNACTIVETEXTUREPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNSAMPLECOVERAGEPROC)(GLfloat , GLboolean ); + typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE3DPROC)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE2DPROC)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE1DPROC)(GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNGETCOMPRESSEDTEXIMAGEPROC)(GLenum , GLint , GLvoid *); + + // Extension: 1.4 + typedef void (CODEGEN_FUNCPTR *PFNBLENDFUNCSEPARATEPROC)(GLenum , GLenum , GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNMULTIDRAWARRAYSPROC)(GLenum , const GLint *, const GLsizei *, GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNMULTIDRAWELEMENTSPROC)(GLenum , const GLsizei *, GLenum , const GLvoid* const *, GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERFPROC)(GLenum , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERFVPROC)(GLenum , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERIPROC)(GLenum , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERIVPROC)(GLenum , const GLint *); + + // Extension: 1.5 + typedef void (CODEGEN_FUNCPTR *PFNGENQUERIESPROC)(GLsizei , GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNDELETEQUERIESPROC)(GLsizei , const GLuint *); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISQUERYPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNBEGINQUERYPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNENDQUERYPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNGETQUERYIVPROC)(GLenum , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETQUERYOBJECTIVPROC)(GLuint , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETQUERYOBJECTUIVPROC)(GLuint , GLenum , GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDELETEBUFFERSPROC)(GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNGENBUFFERSPROC)(GLsizei , GLuint *); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISBUFFERPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNBUFFERDATAPROC)(GLenum , GLsizeiptr , const GLvoid *, GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNBUFFERSUBDATAPROC)(GLenum , GLintptr , GLsizeiptr , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERSUBDATAPROC)(GLenum , GLintptr , GLsizeiptr , GLvoid *); + typedef GLvoid* (CODEGEN_FUNCPTR *PFNMAPBUFFERPROC)(GLenum , GLenum ); + typedef GLboolean (CODEGEN_FUNCPTR *PFNUNMAPBUFFERPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERPARAMETERIVPROC)(GLenum , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERPOINTERVPROC)(GLenum , GLenum , GLvoid* *); + + // Extension: 2.0 + typedef void (CODEGEN_FUNCPTR *PFNBLENDEQUATIONSEPARATEPROC)(GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNDRAWBUFFERSPROC)(GLsizei , const GLenum *); + typedef void (CODEGEN_FUNCPTR *PFNSTENCILOPSEPARATEPROC)(GLenum , GLenum , GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNSTENCILFUNCSEPARATEPROC)(GLenum , GLenum , GLint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNSTENCILMASKSEPARATEPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNATTACHSHADERPROC)(GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNBINDATTRIBLOCATIONPROC)(GLuint , GLuint , const GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNCOMPILESHADERPROC)(GLuint ); + typedef GLuint (CODEGEN_FUNCPTR *PFNCREATEPROGRAMPROC)(); + typedef GLuint (CODEGEN_FUNCPTR *PFNCREATESHADERPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNDELETEPROGRAMPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDELETESHADERPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDETACHSHADERPROC)(GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDISABLEVERTEXATTRIBARRAYPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNENABLEVERTEXATTRIBARRAYPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEATTRIBPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLint *, GLenum *, GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLint *, GLenum *, GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNGETATTACHEDSHADERSPROC)(GLuint , GLsizei , GLsizei *, GLuint *); + typedef GLint (CODEGEN_FUNCPTR *PFNGETATTRIBLOCATIONPROC)(GLuint , const GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNGETPROGRAMIVPROC)(GLuint , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETPROGRAMINFOLOGPROC)(GLuint , GLsizei , GLsizei *, GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNGETSHADERIVPROC)(GLuint , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETSHADERINFOLOGPROC)(GLuint , GLsizei , GLsizei *, GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNGETSHADERSOURCEPROC)(GLuint , GLsizei , GLsizei *, GLchar *); + typedef GLint (CODEGEN_FUNCPTR *PFNGETUNIFORMLOCATIONPROC)(GLuint , const GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMFVPROC)(GLuint , GLint , GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMIVPROC)(GLuint , GLint , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBDVPROC)(GLuint , GLenum , GLdouble *); + typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBFVPROC)(GLuint , GLenum , GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIVPROC)(GLuint , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBPOINTERVPROC)(GLuint , GLenum , GLvoid* *); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISPROGRAMPROC)(GLuint ); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISSHADERPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNLINKPROGRAMPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNSHADERSOURCEPROC)(GLuint , GLsizei , const GLchar* const *, const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNUSEPROGRAMPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1FPROC)(GLint , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2FPROC)(GLint , GLfloat , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3FPROC)(GLint , GLfloat , GLfloat , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4FPROC)(GLint , GLfloat , GLfloat , GLfloat , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1IPROC)(GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2IPROC)(GLint , GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3IPROC)(GLint , GLint , GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4IPROC)(GLint , GLint , GLint , GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1FVPROC)(GLint , GLsizei , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2FVPROC)(GLint , GLsizei , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3FVPROC)(GLint , GLsizei , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4FVPROC)(GLint , GLsizei , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1IVPROC)(GLint , GLsizei , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2IVPROC)(GLint , GLsizei , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3IVPROC)(GLint , GLsizei , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4IVPROC)(GLint , GLsizei , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNVALIDATEPROGRAMPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBPOINTERPROC)(GLuint , GLint , GLenum , GLboolean , GLsizei , const GLvoid *); + + // Extension: 2.1 + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2X3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3X2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2X4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4X2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3X4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4X3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + + // Extension: ARB_vertex_array_object + typedef void (CODEGEN_FUNCPTR *PFNBINDVERTEXARRAYPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDELETEVERTEXARRAYSPROC)(GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNGENVERTEXARRAYSPROC)(GLsizei , GLuint *); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISVERTEXARRAYPROC)(GLuint ); + + // Extension: ARB_map_buffer_range + typedef GLvoid* (CODEGEN_FUNCPTR *PFNMAPBUFFERRANGEPROC)(GLenum , GLintptr , GLsizeiptr , GLbitfield ); + typedef void (CODEGEN_FUNCPTR *PFNFLUSHMAPPEDBUFFERRANGEPROC)(GLenum , GLintptr , GLsizeiptr ); + + // Extension: ARB_framebuffer_object + typedef GLboolean (CODEGEN_FUNCPTR *PFNISRENDERBUFFERPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNBINDRENDERBUFFERPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDELETERENDERBUFFERSPROC)(GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNGENRENDERBUFFERSPROC)(GLsizei , GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNRENDERBUFFERSTORAGEPROC)(GLenum , GLenum , GLsizei , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNGETRENDERBUFFERPARAMETERIVPROC)(GLenum , GLenum , GLint *); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISFRAMEBUFFERPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNBINDFRAMEBUFFERPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDELETEFRAMEBUFFERSPROC)(GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNGENFRAMEBUFFERSPROC)(GLsizei , GLuint *); + typedef GLenum (CODEGEN_FUNCPTR *PFNCHECKFRAMEBUFFERSTATUSPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE1DPROC)(GLenum , GLenum , GLenum , GLuint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE2DPROC)(GLenum , GLenum , GLenum , GLuint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE3DPROC)(GLenum , GLenum , GLenum , GLuint , GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERRENDERBUFFERPROC)(GLenum , GLenum , GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum , GLenum , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGENERATEMIPMAPPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNBLITFRAMEBUFFERPROC)(GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLbitfield , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum , GLsizei , GLenum , GLsizei , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURELAYERPROC)(GLenum , GLenum , GLuint , GLint , GLint ); + + // Extension: 3.0 + typedef void (CODEGEN_FUNCPTR *PFNCOLORMASKIPROC)(GLuint , GLboolean , GLboolean , GLboolean , GLboolean ); + typedef void (CODEGEN_FUNCPTR *PFNGETBOOLEANI_VPROC)(GLenum , GLuint , GLboolean *); + typedef void (CODEGEN_FUNCPTR *PFNGETINTEGERI_VPROC)(GLenum , GLuint , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNENABLEIPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDISABLEIPROC)(GLenum , GLuint ); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISENABLEDIPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNBEGINTRANSFORMFEEDBACKPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNENDTRANSFORMFEEDBACKPROC)(); + typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERRANGEPROC)(GLenum , GLuint , GLuint , GLintptr , GLsizeiptr ); + typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERBASEPROC)(GLenum , GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNTRANSFORMFEEDBACKVARYINGSPROC)(GLuint , GLsizei , const GLchar* const *, GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLsizei *, GLenum *, GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNCLAMPCOLORPROC)(GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNBEGINCONDITIONALRENDERPROC)(GLuint , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNENDCONDITIONALRENDERPROC)(); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBIPOINTERPROC)(GLuint , GLint , GLenum , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIIVPROC)(GLuint , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIUIVPROC)(GLuint , GLenum , GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1IPROC)(GLuint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2IPROC)(GLuint , GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3IPROC)(GLuint , GLint , GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4IPROC)(GLuint , GLint , GLint , GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1UIPROC)(GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2UIPROC)(GLuint , GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3UIPROC)(GLuint , GLuint , GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UIPROC)(GLuint , GLuint , GLuint , GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1IVPROC)(GLuint , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2IVPROC)(GLuint , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3IVPROC)(GLuint , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4IVPROC)(GLuint , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1UIVPROC)(GLuint , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2UIVPROC)(GLuint , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3UIVPROC)(GLuint , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UIVPROC)(GLuint , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4BVPROC)(GLuint , const GLbyte *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4SVPROC)(GLuint , const GLshort *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UBVPROC)(GLuint , const GLubyte *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4USVPROC)(GLuint , const GLushort *); + typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMUIVPROC)(GLuint , GLint , GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNBINDFRAGDATALOCATIONPROC)(GLuint , GLuint , const GLchar *); + typedef GLint (CODEGEN_FUNCPTR *PFNGETFRAGDATALOCATIONPROC)(GLuint , const GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1UIPROC)(GLint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2UIPROC)(GLint , GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3UIPROC)(GLint , GLuint , GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4UIPROC)(GLint , GLuint , GLuint , GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1UIVPROC)(GLint , GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2UIVPROC)(GLint , GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3UIVPROC)(GLint , GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4UIVPROC)(GLint , GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIIVPROC)(GLenum , GLenum , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIUIVPROC)(GLenum , GLenum , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIIVPROC)(GLenum , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIUIVPROC)(GLenum , GLenum , GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERIVPROC)(GLenum , GLint , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERUIVPROC)(GLenum , GLint , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERFVPROC)(GLenum , GLint , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERFIPROC)(GLenum , GLint , GLfloat , GLint ); + typedef const GLubyte * (CODEGEN_FUNCPTR *PFNGETSTRINGIPROC)(GLenum , GLuint ); + + // Extension: ARB_uniform_buffer_object + typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMINDICESPROC)(GLuint , GLsizei , const GLchar* const *, GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMSIVPROC)(GLuint , GLsizei , const GLuint *, GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMNAMEPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLchar *); + typedef GLuint (CODEGEN_FUNCPTR *PFNGETUNIFORMBLOCKINDEXPROC)(GLuint , const GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMBLOCKIVPROC)(GLuint , GLuint , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMBLOCKBINDINGPROC)(GLuint , GLuint , GLuint ); + + // Extension: ARB_copy_buffer + typedef void (CODEGEN_FUNCPTR *PFNCOPYBUFFERSUBDATAPROC)(GLenum , GLenum , GLintptr , GLintptr , GLsizeiptr ); + + // Extension: 3.1 + typedef void (CODEGEN_FUNCPTR *PFNDRAWARRAYSINSTANCEDPROC)(GLenum , GLint , GLsizei , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNDRAWELEMENTSINSTANCEDPROC)(GLenum , GLsizei , GLenum , const GLvoid *, GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNTEXBUFFERPROC)(GLenum , GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNPRIMITIVERESTARTINDEXPROC)(GLuint ); + + // Legacy + typedef void (CODEGEN_FUNCPTR *PFNENABLECLIENTSTATEPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNDISABLECLIENTSTATEPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXPOINTERPROC)(GLint , GLenum , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNNORMALPOINTERPROC)(GLenum , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNCOLORPOINTERPROC)(GLint , GLenum , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNTEXCOORDPOINTERPROC)(GLint , GLenum , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNTEXENVIPROC)(GLenum , GLenum , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNMATRIXMODEPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNLOADIDENTITYPROC)(void); + typedef void (CODEGEN_FUNCPTR *PFNORTHOPROC)(GLdouble , GLdouble , GLdouble , GLdouble , GLdouble , GLdouble ); + typedef void (CODEGEN_FUNCPTR *PFNCOLOR3DPROC)(GLdouble , GLdouble , GLdouble ); + + ////////////////////////////////////////////// + // Function pointers + + // Extension: 1.1 + PFNCULLFACEPROC CullFace; + PFNFRONTFACEPROC FrontFace; + PFNHINTPROC Hint; + PFNLINEWIDTHPROC LineWidth; + PFNPOINTSIZEPROC PointSize; + PFNPOLYGONMODEPROC PolygonMode; + PFNSCISSORPROC Scissor; + PFNTEXPARAMETERFPROC TexParameterf; + PFNTEXPARAMETERFVPROC TexParameterfv; + PFNTEXPARAMETERIPROC TexParameteri; + PFNTEXPARAMETERIVPROC TexParameteriv; + PFNTEXIMAGE1DPROC TexImage1D; + PFNTEXIMAGE2DPROC TexImage2D; + PFNDRAWBUFFERPROC DrawBuffer; + PFNCLEARPROC Clear; + PFNCLEARCOLORPROC ClearColor; + PFNCLEARSTENCILPROC ClearStencil; + PFNCLEARDEPTHPROC ClearDepth; + PFNSTENCILMASKPROC StencilMask; + PFNCOLORMASKPROC ColorMask; + PFNDEPTHMASKPROC DepthMask; + PFNDISABLEPROC Disable; + PFNENABLEPROC Enable; + PFNFINISHPROC Finish; + PFNFLUSHPROC Flush; + PFNBLENDFUNCPROC BlendFunc; + PFNLOGICOPPROC LogicOp; + PFNSTENCILFUNCPROC StencilFunc; + PFNSTENCILOPPROC StencilOp; + PFNDEPTHFUNCPROC DepthFunc; + PFNPIXELSTOREFPROC PixelStoref; + PFNPIXELSTOREIPROC PixelStorei; + PFNREADBUFFERPROC ReadBuffer; + PFNREADPIXELSPROC ReadPixels; + PFNGETBOOLEANVPROC GetBooleanv; + PFNGETDOUBLEVPROC GetDoublev; + PFNGETERRORPROC GetError; + PFNGETFLOATVPROC GetFloatv; + PFNGETINTEGERVPROC GetIntegerv; + PFNGETSTRINGPROC GetString; + PFNGETTEXIMAGEPROC GetTexImage; + PFNGETTEXPARAMETERFVPROC GetTexParameterfv; + PFNGETTEXPARAMETERIVPROC GetTexParameteriv; + PFNGETTEXLEVELPARAMETERFVPROC GetTexLevelParameterfv; + PFNGETTEXLEVELPARAMETERIVPROC GetTexLevelParameteriv; + PFNISENABLEDPROC IsEnabled; + PFNDEPTHRANGEPROC DepthRange; + PFNVIEWPORTPROC Viewport; + PFNDRAWARRAYSPROC DrawArrays; + PFNDRAWELEMENTSPROC DrawElements; + PFNGETPOINTERVPROC GetPointerv; + PFNPOLYGONOFFSETPROC PolygonOffset; + PFNCOPYTEXIMAGE1DPROC CopyTexImage1D; + PFNCOPYTEXIMAGE2DPROC CopyTexImage2D; + PFNCOPYTEXSUBIMAGE1DPROC CopyTexSubImage1D; + PFNCOPYTEXSUBIMAGE2DPROC CopyTexSubImage2D; + PFNTEXSUBIMAGE1DPROC TexSubImage1D; + PFNTEXSUBIMAGE2DPROC TexSubImage2D; + PFNBINDTEXTUREPROC BindTexture; + PFNDELETETEXTURESPROC DeleteTextures; + PFNGENTEXTURESPROC GenTextures; + PFNISTEXTUREPROC IsTexture; + PFNINDEXUBPROC Indexub; + PFNINDEXUBVPROC Indexubv; + + // Extension: 1.2 + PFNBLENDCOLORPROC BlendColor; + PFNBLENDEQUATIONPROC BlendEquation; + PFNDRAWRANGEELEMENTSPROC DrawRangeElements; + PFNTEXSUBIMAGE3DPROC TexSubImage3D; + PFNCOPYTEXSUBIMAGE3DPROC CopyTexSubImage3D; + + // Extension: 1.3 + PFNACTIVETEXTUREPROC ActiveTexture; + PFNSAMPLECOVERAGEPROC SampleCoverage; + PFNCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D; + PFNCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D; + PFNCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D; + PFNCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D; + PFNCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D; + PFNCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D; + PFNGETCOMPRESSEDTEXIMAGEPROC GetCompressedTexImage; + + // Extension: 1.4 + PFNBLENDFUNCSEPARATEPROC BlendFuncSeparate; + PFNMULTIDRAWARRAYSPROC MultiDrawArrays; + PFNMULTIDRAWELEMENTSPROC MultiDrawElements; + PFNPOINTPARAMETERFPROC PointParameterf; + PFNPOINTPARAMETERFVPROC PointParameterfv; + PFNPOINTPARAMETERIPROC PointParameteri; + PFNPOINTPARAMETERIVPROC PointParameteriv; + + // Extension: 1.5 + PFNGENQUERIESPROC GenQueries; + PFNDELETEQUERIESPROC DeleteQueries; + PFNISQUERYPROC IsQuery; + PFNBEGINQUERYPROC BeginQuery; + PFNENDQUERYPROC EndQuery; + PFNGETQUERYIVPROC GetQueryiv; + PFNGETQUERYOBJECTIVPROC GetQueryObjectiv; + PFNGETQUERYOBJECTUIVPROC GetQueryObjectuiv; + PFNBINDBUFFERPROC BindBuffer; + PFNDELETEBUFFERSPROC DeleteBuffers; + PFNGENBUFFERSPROC GenBuffers; + PFNISBUFFERPROC IsBuffer; + PFNBUFFERDATAPROC BufferData; + PFNBUFFERSUBDATAPROC BufferSubData; + PFNGETBUFFERSUBDATAPROC GetBufferSubData; + PFNMAPBUFFERPROC MapBuffer; + PFNUNMAPBUFFERPROC UnmapBuffer; + PFNGETBUFFERPARAMETERIVPROC GetBufferParameteriv; + PFNGETBUFFERPOINTERVPROC GetBufferPointerv; + + // Extension: 2.0 + PFNBLENDEQUATIONSEPARATEPROC BlendEquationSeparate; + PFNDRAWBUFFERSPROC DrawBuffers; + PFNSTENCILOPSEPARATEPROC StencilOpSeparate; + PFNSTENCILFUNCSEPARATEPROC StencilFuncSeparate; + PFNSTENCILMASKSEPARATEPROC StencilMaskSeparate; + PFNATTACHSHADERPROC AttachShader; + PFNBINDATTRIBLOCATIONPROC BindAttribLocation; + PFNCOMPILESHADERPROC CompileShader; + PFNCREATEPROGRAMPROC CreateProgram; + PFNCREATESHADERPROC CreateShader; + PFNDELETEPROGRAMPROC DeleteProgram; + PFNDELETESHADERPROC DeleteShader; + PFNDETACHSHADERPROC DetachShader; + PFNDISABLEVERTEXATTRIBARRAYPROC DisableVertexAttribArray; + PFNENABLEVERTEXATTRIBARRAYPROC EnableVertexAttribArray; + PFNGETACTIVEATTRIBPROC GetActiveAttrib; + PFNGETACTIVEUNIFORMPROC GetActiveUniform; + PFNGETATTACHEDSHADERSPROC GetAttachedShaders; + PFNGETATTRIBLOCATIONPROC GetAttribLocation; + PFNGETPROGRAMIVPROC GetProgramiv; + PFNGETPROGRAMINFOLOGPROC GetProgramInfoLog; + PFNGETSHADERIVPROC GetShaderiv; + PFNGETSHADERINFOLOGPROC GetShaderInfoLog; + PFNGETSHADERSOURCEPROC GetShaderSource; + PFNGETUNIFORMLOCATIONPROC GetUniformLocation; + PFNGETUNIFORMFVPROC GetUniformfv; + PFNGETUNIFORMIVPROC GetUniformiv; + PFNGETVERTEXATTRIBDVPROC GetVertexAttribdv; + PFNGETVERTEXATTRIBFVPROC GetVertexAttribfv; + PFNGETVERTEXATTRIBIVPROC GetVertexAttribiv; + PFNGETVERTEXATTRIBPOINTERVPROC GetVertexAttribPointerv; + PFNISPROGRAMPROC IsProgram; + PFNISSHADERPROC IsShader; + PFNLINKPROGRAMPROC LinkProgram; + PFNSHADERSOURCEPROC ShaderSource; + PFNUSEPROGRAMPROC UseProgram; + PFNUNIFORM1FPROC Uniform1f; + PFNUNIFORM2FPROC Uniform2f; + PFNUNIFORM3FPROC Uniform3f; + PFNUNIFORM4FPROC Uniform4f; + PFNUNIFORM1IPROC Uniform1i; + PFNUNIFORM2IPROC Uniform2i; + PFNUNIFORM3IPROC Uniform3i; + PFNUNIFORM4IPROC Uniform4i; + PFNUNIFORM1FVPROC Uniform1fv; + PFNUNIFORM2FVPROC Uniform2fv; + PFNUNIFORM3FVPROC Uniform3fv; + PFNUNIFORM4FVPROC Uniform4fv; + PFNUNIFORM1IVPROC Uniform1iv; + PFNUNIFORM2IVPROC Uniform2iv; + PFNUNIFORM3IVPROC Uniform3iv; + PFNUNIFORM4IVPROC Uniform4iv; + PFNUNIFORMMATRIX2FVPROC UniformMatrix2fv; + PFNUNIFORMMATRIX3FVPROC UniformMatrix3fv; + PFNUNIFORMMATRIX4FVPROC UniformMatrix4fv; + PFNVALIDATEPROGRAMPROC ValidateProgram; + PFNVERTEXATTRIBPOINTERPROC VertexAttribPointer; + + // Extension: 2.1 + PFNUNIFORMMATRIX2X3FVPROC UniformMatrix2x3fv; + PFNUNIFORMMATRIX3X2FVPROC UniformMatrix3x2fv; + PFNUNIFORMMATRIX2X4FVPROC UniformMatrix2x4fv; + PFNUNIFORMMATRIX4X2FVPROC UniformMatrix4x2fv; + PFNUNIFORMMATRIX3X4FVPROC UniformMatrix3x4fv; + PFNUNIFORMMATRIX4X3FVPROC UniformMatrix4x3fv; + + // Extension: ARB_vertex_array_object + PFNBINDVERTEXARRAYPROC BindVertexArray; + PFNDELETEVERTEXARRAYSPROC DeleteVertexArrays; + PFNGENVERTEXARRAYSPROC GenVertexArrays; + PFNISVERTEXARRAYPROC IsVertexArray; + + // Extension: ARB_map_buffer_range + PFNMAPBUFFERRANGEPROC MapBufferRange; + PFNFLUSHMAPPEDBUFFERRANGEPROC FlushMappedBufferRange; + + // Extension: ARB_framebuffer_object + PFNISRENDERBUFFERPROC IsRenderbuffer; + PFNBINDRENDERBUFFERPROC BindRenderbuffer; + PFNDELETERENDERBUFFERSPROC DeleteRenderbuffers; + PFNGENRENDERBUFFERSPROC GenRenderbuffers; + PFNRENDERBUFFERSTORAGEPROC RenderbufferStorage; + PFNGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv; + PFNISFRAMEBUFFERPROC IsFramebuffer; + PFNBINDFRAMEBUFFERPROC BindFramebuffer; + PFNDELETEFRAMEBUFFERSPROC DeleteFramebuffers; + PFNGENFRAMEBUFFERSPROC GenFramebuffers; + PFNCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus; + PFNFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D; + PFNFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D; + PFNFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D; + PFNFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer; + PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC GetFramebufferAttachmentParameteriv; + PFNGENERATEMIPMAPPROC GenerateMipmap; + PFNBLITFRAMEBUFFERPROC BlitFramebuffer; + PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample; + PFNFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer; + + // Extension: 3.0 + PFNCOLORMASKIPROC ColorMaski; + PFNGETBOOLEANI_VPROC GetBooleani_v; + PFNGETINTEGERI_VPROC GetIntegeri_v; + PFNENABLEIPROC Enablei; + PFNDISABLEIPROC Disablei; + PFNISENABLEDIPROC IsEnabledi; + PFNBEGINTRANSFORMFEEDBACKPROC BeginTransformFeedback; + PFNENDTRANSFORMFEEDBACKPROC EndTransformFeedback; + PFNBINDBUFFERRANGEPROC BindBufferRange; + PFNBINDBUFFERBASEPROC BindBufferBase; + PFNTRANSFORMFEEDBACKVARYINGSPROC TransformFeedbackVaryings; + PFNGETTRANSFORMFEEDBACKVARYINGPROC GetTransformFeedbackVarying; + PFNCLAMPCOLORPROC ClampColor; + PFNBEGINCONDITIONALRENDERPROC BeginConditionalRender; + PFNENDCONDITIONALRENDERPROC EndConditionalRender; + PFNVERTEXATTRIBIPOINTERPROC VertexAttribIPointer; + PFNGETVERTEXATTRIBIIVPROC GetVertexAttribIiv; + PFNGETVERTEXATTRIBIUIVPROC GetVertexAttribIuiv; + PFNVERTEXATTRIBI1IPROC VertexAttribI1i; + PFNVERTEXATTRIBI2IPROC VertexAttribI2i; + PFNVERTEXATTRIBI3IPROC VertexAttribI3i; + PFNVERTEXATTRIBI4IPROC VertexAttribI4i; + PFNVERTEXATTRIBI1UIPROC VertexAttribI1ui; + PFNVERTEXATTRIBI2UIPROC VertexAttribI2ui; + PFNVERTEXATTRIBI3UIPROC VertexAttribI3ui; + PFNVERTEXATTRIBI4UIPROC VertexAttribI4ui; + PFNVERTEXATTRIBI1IVPROC VertexAttribI1iv; + PFNVERTEXATTRIBI2IVPROC VertexAttribI2iv; + PFNVERTEXATTRIBI3IVPROC VertexAttribI3iv; + PFNVERTEXATTRIBI4IVPROC VertexAttribI4iv; + PFNVERTEXATTRIBI1UIVPROC VertexAttribI1uiv; + PFNVERTEXATTRIBI2UIVPROC VertexAttribI2uiv; + PFNVERTEXATTRIBI3UIVPROC VertexAttribI3uiv; + PFNVERTEXATTRIBI4UIVPROC VertexAttribI4uiv; + PFNVERTEXATTRIBI4BVPROC VertexAttribI4bv; + PFNVERTEXATTRIBI4SVPROC VertexAttribI4sv; + PFNVERTEXATTRIBI4UBVPROC VertexAttribI4ubv; + PFNVERTEXATTRIBI4USVPROC VertexAttribI4usv; + PFNGETUNIFORMUIVPROC GetUniformuiv; + PFNBINDFRAGDATALOCATIONPROC BindFragDataLocation; + PFNGETFRAGDATALOCATIONPROC GetFragDataLocation; + PFNUNIFORM1UIPROC Uniform1ui; + PFNUNIFORM2UIPROC Uniform2ui; + PFNUNIFORM3UIPROC Uniform3ui; + PFNUNIFORM4UIPROC Uniform4ui; + PFNUNIFORM1UIVPROC Uniform1uiv; + PFNUNIFORM2UIVPROC Uniform2uiv; + PFNUNIFORM3UIVPROC Uniform3uiv; + PFNUNIFORM4UIVPROC Uniform4uiv; + PFNTEXPARAMETERIIVPROC TexParameterIiv; + PFNTEXPARAMETERIUIVPROC TexParameterIuiv; + PFNGETTEXPARAMETERIIVPROC GetTexParameterIiv; + PFNGETTEXPARAMETERIUIVPROC GetTexParameterIuiv; + PFNCLEARBUFFERIVPROC ClearBufferiv; + PFNCLEARBUFFERUIVPROC ClearBufferuiv; + PFNCLEARBUFFERFVPROC ClearBufferfv; + PFNCLEARBUFFERFIPROC ClearBufferfi; + PFNGETSTRINGIPROC GetStringi; + + // Extension: ARB_uniform_buffer_object + PFNGETUNIFORMINDICESPROC GetUniformIndices; + PFNGETACTIVEUNIFORMSIVPROC GetActiveUniformsiv; + PFNGETACTIVEUNIFORMNAMEPROC GetActiveUniformName; + PFNGETUNIFORMBLOCKINDEXPROC GetUniformBlockIndex; + PFNGETACTIVEUNIFORMBLOCKIVPROC GetActiveUniformBlockiv; + PFNGETACTIVEUNIFORMBLOCKNAMEPROC GetActiveUniformBlockName; + PFNUNIFORMBLOCKBINDINGPROC UniformBlockBinding; + + // Extension: ARB_copy_buffer + PFNCOPYBUFFERSUBDATAPROC CopyBufferSubData; + + // Extension: 3.1 + PFNDRAWARRAYSINSTANCEDPROC DrawArraysInstanced; + PFNDRAWELEMENTSINSTANCEDPROC DrawElementsInstanced; + PFNTEXBUFFERPROC TexBuffer; + PFNPRIMITIVERESTARTINDEXPROC PrimitiveRestartIndex; + + // Legacy + PFNENABLECLIENTSTATEPROC EnableClientState; + PFNDISABLECLIENTSTATEPROC DisableClientState; + PFNVERTEXPOINTERPROC VertexPointer; + PFNNORMALPOINTERPROC NormalPointer; + PFNCOLORPOINTERPROC ColorPointer; + PFNTEXCOORDPOINTERPROC TexCoordPointer; + + PFNTEXENVIPROC TexEnvi; + + PFNMATRIXMODEPROC MatrixMode; + PFNLOADIDENTITYPROC LoadIdentity; + PFNORTHOPROC Ortho; + + PFNCOLOR3DPROC Color3d; + + ////////////////////////////////////////////// + // Switch functions + + // Extension: 1.1 + + static void CODEGEN_FUNCPTR Switch_CullFace(GLenum mode) + { + CullFace = (PFNCULLFACEPROC)IntGetProcAddress("glCullFace"); + CullFace(mode); + } + + static void CODEGEN_FUNCPTR Switch_FrontFace(GLenum mode) + { + FrontFace = (PFNFRONTFACEPROC)IntGetProcAddress("glFrontFace"); + FrontFace(mode); + } + + static void CODEGEN_FUNCPTR Switch_Hint(GLenum target, GLenum mode) + { + Hint = (PFNHINTPROC)IntGetProcAddress("glHint"); + Hint(target, mode); + } + + static void CODEGEN_FUNCPTR Switch_LineWidth(GLfloat width) + { + LineWidth = (PFNLINEWIDTHPROC)IntGetProcAddress("glLineWidth"); + LineWidth(width); + } + + static void CODEGEN_FUNCPTR Switch_PointSize(GLfloat size) + { + PointSize = (PFNPOINTSIZEPROC)IntGetProcAddress("glPointSize"); + PointSize(size); + } + + static void CODEGEN_FUNCPTR Switch_PolygonMode(GLenum face, GLenum mode) + { + PolygonMode = (PFNPOLYGONMODEPROC)IntGetProcAddress("glPolygonMode"); + PolygonMode(face, mode); + } + + static void CODEGEN_FUNCPTR Switch_Scissor(GLint x, GLint y, GLsizei width, GLsizei height) + { + Scissor = (PFNSCISSORPROC)IntGetProcAddress("glScissor"); + Scissor(x, y, width, height); + } + + static void CODEGEN_FUNCPTR Switch_TexParameterf(GLenum target, GLenum pname, GLfloat param) + { + TexParameterf = (PFNTEXPARAMETERFPROC)IntGetProcAddress("glTexParameterf"); + TexParameterf(target, pname, param); + } + + static void CODEGEN_FUNCPTR Switch_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params) + { + TexParameterfv = (PFNTEXPARAMETERFVPROC)IntGetProcAddress("glTexParameterfv"); + TexParameterfv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_TexParameteri(GLenum target, GLenum pname, GLint param) + { + TexParameteri = (PFNTEXPARAMETERIPROC)IntGetProcAddress("glTexParameteri"); + TexParameteri(target, pname, param); + } + + static void CODEGEN_FUNCPTR Switch_TexParameteriv(GLenum target, GLenum pname, const GLint *params) + { + TexParameteriv = (PFNTEXPARAMETERIVPROC)IntGetProcAddress("glTexParameteriv"); + TexParameteriv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_TexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) + { + TexImage1D = (PFNTEXIMAGE1DPROC)IntGetProcAddress("glTexImage1D"); + TexImage1D(target, level, internalformat, width, border, format, type, pixels); + } + + static void CODEGEN_FUNCPTR Switch_TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) + { + TexImage2D = (PFNTEXIMAGE2DPROC)IntGetProcAddress("glTexImage2D"); + TexImage2D(target, level, internalformat, width, height, border, format, type, pixels); + } + + static void CODEGEN_FUNCPTR Switch_DrawBuffer(GLenum mode) + { + DrawBuffer = (PFNDRAWBUFFERPROC)IntGetProcAddress("glDrawBuffer"); + DrawBuffer(mode); + } + + static void CODEGEN_FUNCPTR Switch_Clear(GLbitfield mask) + { + Clear = (PFNCLEARPROC)IntGetProcAddress("glClear"); + Clear(mask); + } + + static void CODEGEN_FUNCPTR Switch_ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) + { + ClearColor = (PFNCLEARCOLORPROC)IntGetProcAddress("glClearColor"); + ClearColor(red, green, blue, alpha); + } + + static void CODEGEN_FUNCPTR Switch_ClearStencil(GLint s) + { + ClearStencil = (PFNCLEARSTENCILPROC)IntGetProcAddress("glClearStencil"); + ClearStencil(s); + } + + static void CODEGEN_FUNCPTR Switch_ClearDepth(GLdouble depth) + { + ClearDepth = (PFNCLEARDEPTHPROC)IntGetProcAddress("glClearDepth"); + ClearDepth(depth); + } + + static void CODEGEN_FUNCPTR Switch_StencilMask(GLuint mask) + { + StencilMask = (PFNSTENCILMASKPROC)IntGetProcAddress("glStencilMask"); + StencilMask(mask); + } + + static void CODEGEN_FUNCPTR Switch_ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) + { + ColorMask = (PFNCOLORMASKPROC)IntGetProcAddress("glColorMask"); + ColorMask(red, green, blue, alpha); + } + + static void CODEGEN_FUNCPTR Switch_DepthMask(GLboolean flag) + { + DepthMask = (PFNDEPTHMASKPROC)IntGetProcAddress("glDepthMask"); + DepthMask(flag); + } + + static void CODEGEN_FUNCPTR Switch_Disable(GLenum cap) + { + Disable = (PFNDISABLEPROC)IntGetProcAddress("glDisable"); + Disable(cap); + } + + static void CODEGEN_FUNCPTR Switch_Enable(GLenum cap) + { + Enable = (PFNENABLEPROC)IntGetProcAddress("glEnable"); + Enable(cap); + } + + static void CODEGEN_FUNCPTR Switch_Finish() + { + Finish = (PFNFINISHPROC)IntGetProcAddress("glFinish"); + Finish(); + } + + static void CODEGEN_FUNCPTR Switch_Flush() + { + Flush = (PFNFLUSHPROC)IntGetProcAddress("glFlush"); + Flush(); + } + + static void CODEGEN_FUNCPTR Switch_BlendFunc(GLenum sfactor, GLenum dfactor) + { + BlendFunc = (PFNBLENDFUNCPROC)IntGetProcAddress("glBlendFunc"); + BlendFunc(sfactor, dfactor); + } + + static void CODEGEN_FUNCPTR Switch_LogicOp(GLenum opcode) + { + LogicOp = (PFNLOGICOPPROC)IntGetProcAddress("glLogicOp"); + LogicOp(opcode); + } + + static void CODEGEN_FUNCPTR Switch_StencilFunc(GLenum func, GLint ref, GLuint mask) + { + StencilFunc = (PFNSTENCILFUNCPROC)IntGetProcAddress("glStencilFunc"); + StencilFunc(func, ref, mask); + } + + static void CODEGEN_FUNCPTR Switch_StencilOp(GLenum fail, GLenum zfail, GLenum zpass) + { + StencilOp = (PFNSTENCILOPPROC)IntGetProcAddress("glStencilOp"); + StencilOp(fail, zfail, zpass); + } + + static void CODEGEN_FUNCPTR Switch_DepthFunc(GLenum func) + { + DepthFunc = (PFNDEPTHFUNCPROC)IntGetProcAddress("glDepthFunc"); + DepthFunc(func); + } + + static void CODEGEN_FUNCPTR Switch_PixelStoref(GLenum pname, GLfloat param) + { + PixelStoref = (PFNPIXELSTOREFPROC)IntGetProcAddress("glPixelStoref"); + PixelStoref(pname, param); + } + + static void CODEGEN_FUNCPTR Switch_PixelStorei(GLenum pname, GLint param) + { + PixelStorei = (PFNPIXELSTOREIPROC)IntGetProcAddress("glPixelStorei"); + PixelStorei(pname, param); + } + + static void CODEGEN_FUNCPTR Switch_ReadBuffer(GLenum mode) + { + ReadBuffer = (PFNREADBUFFERPROC)IntGetProcAddress("glReadBuffer"); + ReadBuffer(mode); + } + + static void CODEGEN_FUNCPTR Switch_ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) + { + ReadPixels = (PFNREADPIXELSPROC)IntGetProcAddress("glReadPixels"); + ReadPixels(x, y, width, height, format, type, pixels); + } + + static void CODEGEN_FUNCPTR Switch_GetBooleanv(GLenum pname, GLboolean *params) + { + GetBooleanv = (PFNGETBOOLEANVPROC)IntGetProcAddress("glGetBooleanv"); + GetBooleanv(pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetDoublev(GLenum pname, GLdouble *params) + { + GetDoublev = (PFNGETDOUBLEVPROC)IntGetProcAddress("glGetDoublev"); + GetDoublev(pname, params); + } + + static GLenum CODEGEN_FUNCPTR Switch_GetError() + { + GetError = (PFNGETERRORPROC)IntGetProcAddress("glGetError"); + return GetError(); + } + + static void CODEGEN_FUNCPTR Switch_GetFloatv(GLenum pname, GLfloat *params) + { + GetFloatv = (PFNGETFLOATVPROC)IntGetProcAddress("glGetFloatv"); + GetFloatv(pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetIntegerv(GLenum pname, GLint *params) + { + GetIntegerv = (PFNGETINTEGERVPROC)IntGetProcAddress("glGetIntegerv"); + GetIntegerv(pname, params); + } + + static const GLubyte * CODEGEN_FUNCPTR Switch_GetString(GLenum name) + { + GetString = (PFNGETSTRINGPROC)IntGetProcAddress("glGetString"); + return GetString(name); + } + + static void CODEGEN_FUNCPTR Switch_GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) + { + GetTexImage = (PFNGETTEXIMAGEPROC)IntGetProcAddress("glGetTexImage"); + GetTexImage(target, level, format, type, pixels); + } + + static void CODEGEN_FUNCPTR Switch_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) + { + GetTexParameterfv = (PFNGETTEXPARAMETERFVPROC)IntGetProcAddress("glGetTexParameterfv"); + GetTexParameterfv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetTexParameteriv(GLenum target, GLenum pname, GLint *params) + { + GetTexParameteriv = (PFNGETTEXPARAMETERIVPROC)IntGetProcAddress("glGetTexParameteriv"); + GetTexParameteriv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) + { + GetTexLevelParameterfv = (PFNGETTEXLEVELPARAMETERFVPROC)IntGetProcAddress("glGetTexLevelParameterfv"); + GetTexLevelParameterfv(target, level, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) + { + GetTexLevelParameteriv = (PFNGETTEXLEVELPARAMETERIVPROC)IntGetProcAddress("glGetTexLevelParameteriv"); + GetTexLevelParameteriv(target, level, pname, params); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsEnabled(GLenum cap) + { + IsEnabled = (PFNISENABLEDPROC)IntGetProcAddress("glIsEnabled"); + return IsEnabled(cap); + } + + static void CODEGEN_FUNCPTR Switch_DepthRange(GLdouble ren_near, GLdouble ren_far) + { + DepthRange = (PFNDEPTHRANGEPROC)IntGetProcAddress("glDepthRange"); + DepthRange(ren_near, ren_far); + } + + static void CODEGEN_FUNCPTR Switch_Viewport(GLint x, GLint y, GLsizei width, GLsizei height) + { + Viewport = (PFNVIEWPORTPROC)IntGetProcAddress("glViewport"); + Viewport(x, y, width, height); + } + + static void CODEGEN_FUNCPTR Switch_DrawArrays(GLenum mode, GLint first, GLsizei count) + { + DrawArrays = (PFNDRAWARRAYSPROC)IntGetProcAddress("glDrawArrays"); + DrawArrays(mode, first, count); + } + + static void CODEGEN_FUNCPTR Switch_DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) + { + DrawElements = (PFNDRAWELEMENTSPROC)IntGetProcAddress("glDrawElements"); + DrawElements(mode, count, type, indices); + } + + static void CODEGEN_FUNCPTR Switch_GetPointerv(GLenum pname, GLvoid* *params) + { + GetPointerv = (PFNGETPOINTERVPROC)IntGetProcAddress("glGetPointerv"); + GetPointerv(pname, params); + } + + static void CODEGEN_FUNCPTR Switch_PolygonOffset(GLfloat factor, GLfloat units) + { + PolygonOffset = (PFNPOLYGONOFFSETPROC)IntGetProcAddress("glPolygonOffset"); + PolygonOffset(factor, units); + } + + static void CODEGEN_FUNCPTR Switch_CopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) + { + CopyTexImage1D = (PFNCOPYTEXIMAGE1DPROC)IntGetProcAddress("glCopyTexImage1D"); + CopyTexImage1D(target, level, internalformat, x, y, width, border); + } + + static void CODEGEN_FUNCPTR Switch_CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) + { + CopyTexImage2D = (PFNCOPYTEXIMAGE2DPROC)IntGetProcAddress("glCopyTexImage2D"); + CopyTexImage2D(target, level, internalformat, x, y, width, height, border); + } + + static void CODEGEN_FUNCPTR Switch_CopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) + { + CopyTexSubImage1D = (PFNCOPYTEXSUBIMAGE1DPROC)IntGetProcAddress("glCopyTexSubImage1D"); + CopyTexSubImage1D(target, level, xoffset, x, y, width); + } + + static void CODEGEN_FUNCPTR Switch_CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) + { + CopyTexSubImage2D = (PFNCOPYTEXSUBIMAGE2DPROC)IntGetProcAddress("glCopyTexSubImage2D"); + CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); + } + + static void CODEGEN_FUNCPTR Switch_TexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) + { + TexSubImage1D = (PFNTEXSUBIMAGE1DPROC)IntGetProcAddress("glTexSubImage1D"); + TexSubImage1D(target, level, xoffset, width, format, type, pixels); + } + + static void CODEGEN_FUNCPTR Switch_TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) + { + TexSubImage2D = (PFNTEXSUBIMAGE2DPROC)IntGetProcAddress("glTexSubImage2D"); + TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + } + + static void CODEGEN_FUNCPTR Switch_BindTexture(GLenum target, GLuint texture) + { + BindTexture = (PFNBINDTEXTUREPROC)IntGetProcAddress("glBindTexture"); + BindTexture(target, texture); + } + + static void CODEGEN_FUNCPTR Switch_DeleteTextures(GLsizei n, const GLuint *textures) + { + DeleteTextures = (PFNDELETETEXTURESPROC)IntGetProcAddress("glDeleteTextures"); + DeleteTextures(n, textures); + } + + static void CODEGEN_FUNCPTR Switch_GenTextures(GLsizei n, GLuint *textures) + { + GenTextures = (PFNGENTEXTURESPROC)IntGetProcAddress("glGenTextures"); + GenTextures(n, textures); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsTexture(GLuint texture) + { + IsTexture = (PFNISTEXTUREPROC)IntGetProcAddress("glIsTexture"); + return IsTexture(texture); + } + + static void CODEGEN_FUNCPTR Switch_Indexub(GLubyte c) + { + Indexub = (PFNINDEXUBPROC)IntGetProcAddress("glIndexub"); + Indexub(c); + } + + static void CODEGEN_FUNCPTR Switch_Indexubv(const GLubyte *c) + { + Indexubv = (PFNINDEXUBVPROC)IntGetProcAddress("glIndexubv"); + Indexubv(c); + } + + // Extension: 1.2 + + static void CODEGEN_FUNCPTR Switch_BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) + { + BlendColor = (PFNBLENDCOLORPROC)IntGetProcAddress("glBlendColor"); + BlendColor(red, green, blue, alpha); + } + + static void CODEGEN_FUNCPTR Switch_BlendEquation(GLenum mode) + { + BlendEquation = (PFNBLENDEQUATIONPROC)IntGetProcAddress("glBlendEquation"); + BlendEquation(mode); + } + + static void CODEGEN_FUNCPTR Switch_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) + { + DrawRangeElements = (PFNDRAWRANGEELEMENTSPROC)IntGetProcAddress("glDrawRangeElements"); + DrawRangeElements(mode, start, end, count, type, indices); + } + + static void CODEGEN_FUNCPTR Switch_TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) + { + TexSubImage3D = (PFNTEXSUBIMAGE3DPROC)IntGetProcAddress("glTexSubImage3D"); + TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + } + + static void CODEGEN_FUNCPTR Switch_CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) + { + CopyTexSubImage3D = (PFNCOPYTEXSUBIMAGE3DPROC)IntGetProcAddress("glCopyTexSubImage3D"); + CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); + } + + // Extension: 1.3 + + static void CODEGEN_FUNCPTR Switch_ActiveTexture(GLenum texture) + { + ActiveTexture = (PFNACTIVETEXTUREPROC)IntGetProcAddress("glActiveTexture"); + ActiveTexture(texture); + } + + static void CODEGEN_FUNCPTR Switch_SampleCoverage(GLfloat value, GLboolean invert) + { + SampleCoverage = (PFNSAMPLECOVERAGEPROC)IntGetProcAddress("glSampleCoverage"); + SampleCoverage(value, invert); + } + + static void CODEGEN_FUNCPTR Switch_CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) + { + CompressedTexImage3D = (PFNCOMPRESSEDTEXIMAGE3DPROC)IntGetProcAddress("glCompressedTexImage3D"); + CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data); + } + + static void CODEGEN_FUNCPTR Switch_CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) + { + CompressedTexImage2D = (PFNCOMPRESSEDTEXIMAGE2DPROC)IntGetProcAddress("glCompressedTexImage2D"); + CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); + } + + static void CODEGEN_FUNCPTR Switch_CompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) + { + CompressedTexImage1D = (PFNCOMPRESSEDTEXIMAGE1DPROC)IntGetProcAddress("glCompressedTexImage1D"); + CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data); + } + + static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) + { + CompressedTexSubImage3D = (PFNCOMPRESSEDTEXSUBIMAGE3DPROC)IntGetProcAddress("glCompressedTexSubImage3D"); + CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); + } + + static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) + { + CompressedTexSubImage2D = (PFNCOMPRESSEDTEXSUBIMAGE2DPROC)IntGetProcAddress("glCompressedTexSubImage2D"); + CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); + } + + static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) + { + CompressedTexSubImage1D = (PFNCOMPRESSEDTEXSUBIMAGE1DPROC)IntGetProcAddress("glCompressedTexSubImage1D"); + CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); + } + + static void CODEGEN_FUNCPTR Switch_GetCompressedTexImage(GLenum target, GLint level, GLvoid *img) + { + GetCompressedTexImage = (PFNGETCOMPRESSEDTEXIMAGEPROC)IntGetProcAddress("glGetCompressedTexImage"); + GetCompressedTexImage(target, level, img); + } + + // Extension: 1.4 + + static void CODEGEN_FUNCPTR Switch_BlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) + { + BlendFuncSeparate = (PFNBLENDFUNCSEPARATEPROC)IntGetProcAddress("glBlendFuncSeparate"); + BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); + } + + static void CODEGEN_FUNCPTR Switch_MultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount) + { + MultiDrawArrays = (PFNMULTIDRAWARRAYSPROC)IntGetProcAddress("glMultiDrawArrays"); + MultiDrawArrays(mode, first, count, drawcount); + } + + static void CODEGEN_FUNCPTR Switch_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount) + { + MultiDrawElements = (PFNMULTIDRAWELEMENTSPROC)IntGetProcAddress("glMultiDrawElements"); + MultiDrawElements(mode, count, type, indices, drawcount); + } + + static void CODEGEN_FUNCPTR Switch_PointParameterf(GLenum pname, GLfloat param) + { + PointParameterf = (PFNPOINTPARAMETERFPROC)IntGetProcAddress("glPointParameterf"); + PointParameterf(pname, param); + } + + static void CODEGEN_FUNCPTR Switch_PointParameterfv(GLenum pname, const GLfloat *params) + { + PointParameterfv = (PFNPOINTPARAMETERFVPROC)IntGetProcAddress("glPointParameterfv"); + PointParameterfv(pname, params); + } + + static void CODEGEN_FUNCPTR Switch_PointParameteri(GLenum pname, GLint param) + { + PointParameteri = (PFNPOINTPARAMETERIPROC)IntGetProcAddress("glPointParameteri"); + PointParameteri(pname, param); + } + + static void CODEGEN_FUNCPTR Switch_PointParameteriv(GLenum pname, const GLint *params) + { + PointParameteriv = (PFNPOINTPARAMETERIVPROC)IntGetProcAddress("glPointParameteriv"); + PointParameteriv(pname, params); + } + + // Extension: 1.5 + + static void CODEGEN_FUNCPTR Switch_GenQueries(GLsizei n, GLuint *ids) + { + GenQueries = (PFNGENQUERIESPROC)IntGetProcAddress("glGenQueries"); + GenQueries(n, ids); + } + + static void CODEGEN_FUNCPTR Switch_DeleteQueries(GLsizei n, const GLuint *ids) + { + DeleteQueries = (PFNDELETEQUERIESPROC)IntGetProcAddress("glDeleteQueries"); + DeleteQueries(n, ids); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsQuery(GLuint id) + { + IsQuery = (PFNISQUERYPROC)IntGetProcAddress("glIsQuery"); + return IsQuery(id); + } + + static void CODEGEN_FUNCPTR Switch_BeginQuery(GLenum target, GLuint id) + { + BeginQuery = (PFNBEGINQUERYPROC)IntGetProcAddress("glBeginQuery"); + BeginQuery(target, id); + } + + static void CODEGEN_FUNCPTR Switch_EndQuery(GLenum target) + { + EndQuery = (PFNENDQUERYPROC)IntGetProcAddress("glEndQuery"); + EndQuery(target); + } + + static void CODEGEN_FUNCPTR Switch_GetQueryiv(GLenum target, GLenum pname, GLint *params) + { + GetQueryiv = (PFNGETQUERYIVPROC)IntGetProcAddress("glGetQueryiv"); + GetQueryiv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetQueryObjectiv(GLuint id, GLenum pname, GLint *params) + { + GetQueryObjectiv = (PFNGETQUERYOBJECTIVPROC)IntGetProcAddress("glGetQueryObjectiv"); + GetQueryObjectiv(id, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) + { + GetQueryObjectuiv = (PFNGETQUERYOBJECTUIVPROC)IntGetProcAddress("glGetQueryObjectuiv"); + GetQueryObjectuiv(id, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_BindBuffer(GLenum target, GLuint buffer) + { + BindBuffer = (PFNBINDBUFFERPROC)IntGetProcAddress("glBindBuffer"); + BindBuffer(target, buffer); + } + + static void CODEGEN_FUNCPTR Switch_DeleteBuffers(GLsizei n, const GLuint *buffers) + { + DeleteBuffers = (PFNDELETEBUFFERSPROC)IntGetProcAddress("glDeleteBuffers"); + DeleteBuffers(n, buffers); + } + + static void CODEGEN_FUNCPTR Switch_GenBuffers(GLsizei n, GLuint *buffers) + { + GenBuffers = (PFNGENBUFFERSPROC)IntGetProcAddress("glGenBuffers"); + GenBuffers(n, buffers); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsBuffer(GLuint buffer) + { + IsBuffer = (PFNISBUFFERPROC)IntGetProcAddress("glIsBuffer"); + return IsBuffer(buffer); + } + + static void CODEGEN_FUNCPTR Switch_BufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) + { + BufferData = (PFNBUFFERDATAPROC)IntGetProcAddress("glBufferData"); + BufferData(target, size, data, usage); + } + + static void CODEGEN_FUNCPTR Switch_BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) + { + BufferSubData = (PFNBUFFERSUBDATAPROC)IntGetProcAddress("glBufferSubData"); + BufferSubData(target, offset, size, data); + } + + static void CODEGEN_FUNCPTR Switch_GetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data) + { + GetBufferSubData = (PFNGETBUFFERSUBDATAPROC)IntGetProcAddress("glGetBufferSubData"); + GetBufferSubData(target, offset, size, data); + } + + static GLvoid* CODEGEN_FUNCPTR Switch_MapBuffer(GLenum target, GLenum access) + { + MapBuffer = (PFNMAPBUFFERPROC)IntGetProcAddress("glMapBuffer"); + return MapBuffer(target, access); + } + + static GLboolean CODEGEN_FUNCPTR Switch_UnmapBuffer(GLenum target) + { + UnmapBuffer = (PFNUNMAPBUFFERPROC)IntGetProcAddress("glUnmapBuffer"); + return UnmapBuffer(target); + } + + static void CODEGEN_FUNCPTR Switch_GetBufferParameteriv(GLenum target, GLenum pname, GLint *params) + { + GetBufferParameteriv = (PFNGETBUFFERPARAMETERIVPROC)IntGetProcAddress("glGetBufferParameteriv"); + GetBufferParameteriv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params) + { + GetBufferPointerv = (PFNGETBUFFERPOINTERVPROC)IntGetProcAddress("glGetBufferPointerv"); + GetBufferPointerv(target, pname, params); + } + + // Extension: 2.0 + + static void CODEGEN_FUNCPTR Switch_BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) + { + BlendEquationSeparate = (PFNBLENDEQUATIONSEPARATEPROC)IntGetProcAddress("glBlendEquationSeparate"); + BlendEquationSeparate(modeRGB, modeAlpha); + } + + static void CODEGEN_FUNCPTR Switch_DrawBuffers(GLsizei n, const GLenum *bufs) + { + DrawBuffers = (PFNDRAWBUFFERSPROC)IntGetProcAddress("glDrawBuffers"); + DrawBuffers(n, bufs); + } + + static void CODEGEN_FUNCPTR Switch_StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) + { + StencilOpSeparate = (PFNSTENCILOPSEPARATEPROC)IntGetProcAddress("glStencilOpSeparate"); + StencilOpSeparate(face, sfail, dpfail, dppass); + } + + static void CODEGEN_FUNCPTR Switch_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) + { + StencilFuncSeparate = (PFNSTENCILFUNCSEPARATEPROC)IntGetProcAddress("glStencilFuncSeparate"); + StencilFuncSeparate(face, func, ref, mask); + } + + static void CODEGEN_FUNCPTR Switch_StencilMaskSeparate(GLenum face, GLuint mask) + { + StencilMaskSeparate = (PFNSTENCILMASKSEPARATEPROC)IntGetProcAddress("glStencilMaskSeparate"); + StencilMaskSeparate(face, mask); + } + + static void CODEGEN_FUNCPTR Switch_AttachShader(GLuint program, GLuint shader) + { + AttachShader = (PFNATTACHSHADERPROC)IntGetProcAddress("glAttachShader"); + AttachShader(program, shader); + } + + static void CODEGEN_FUNCPTR Switch_BindAttribLocation(GLuint program, GLuint index, const GLchar *name) + { + BindAttribLocation = (PFNBINDATTRIBLOCATIONPROC)IntGetProcAddress("glBindAttribLocation"); + BindAttribLocation(program, index, name); + } + + static void CODEGEN_FUNCPTR Switch_CompileShader(GLuint shader) + { + CompileShader = (PFNCOMPILESHADERPROC)IntGetProcAddress("glCompileShader"); + CompileShader(shader); + } + + static GLuint CODEGEN_FUNCPTR Switch_CreateProgram() + { + CreateProgram = (PFNCREATEPROGRAMPROC)IntGetProcAddress("glCreateProgram"); + return CreateProgram(); + } + + static GLuint CODEGEN_FUNCPTR Switch_CreateShader(GLenum type) + { + CreateShader = (PFNCREATESHADERPROC)IntGetProcAddress("glCreateShader"); + return CreateShader(type); + } + + static void CODEGEN_FUNCPTR Switch_DeleteProgram(GLuint program) + { + DeleteProgram = (PFNDELETEPROGRAMPROC)IntGetProcAddress("glDeleteProgram"); + DeleteProgram(program); + } + + static void CODEGEN_FUNCPTR Switch_DeleteShader(GLuint shader) + { + DeleteShader = (PFNDELETESHADERPROC)IntGetProcAddress("glDeleteShader"); + DeleteShader(shader); + } + + static void CODEGEN_FUNCPTR Switch_DetachShader(GLuint program, GLuint shader) + { + DetachShader = (PFNDETACHSHADERPROC)IntGetProcAddress("glDetachShader"); + DetachShader(program, shader); + } + + static void CODEGEN_FUNCPTR Switch_DisableVertexAttribArray(GLuint index) + { + DisableVertexAttribArray = (PFNDISABLEVERTEXATTRIBARRAYPROC)IntGetProcAddress("glDisableVertexAttribArray"); + DisableVertexAttribArray(index); + } + + static void CODEGEN_FUNCPTR Switch_EnableVertexAttribArray(GLuint index) + { + EnableVertexAttribArray = (PFNENABLEVERTEXATTRIBARRAYPROC)IntGetProcAddress("glEnableVertexAttribArray"); + EnableVertexAttribArray(index); + } + + static void CODEGEN_FUNCPTR Switch_GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) + { + GetActiveAttrib = (PFNGETACTIVEATTRIBPROC)IntGetProcAddress("glGetActiveAttrib"); + GetActiveAttrib(program, index, bufSize, length, size, type, name); + } + + static void CODEGEN_FUNCPTR Switch_GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) + { + GetActiveUniform = (PFNGETACTIVEUNIFORMPROC)IntGetProcAddress("glGetActiveUniform"); + GetActiveUniform(program, index, bufSize, length, size, type, name); + } + + static void CODEGEN_FUNCPTR Switch_GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj) + { + GetAttachedShaders = (PFNGETATTACHEDSHADERSPROC)IntGetProcAddress("glGetAttachedShaders"); + GetAttachedShaders(program, maxCount, count, obj); + } + + static GLint CODEGEN_FUNCPTR Switch_GetAttribLocation(GLuint program, const GLchar *name) + { + GetAttribLocation = (PFNGETATTRIBLOCATIONPROC)IntGetProcAddress("glGetAttribLocation"); + return GetAttribLocation(program, name); + } + + static void CODEGEN_FUNCPTR Switch_GetProgramiv(GLuint program, GLenum pname, GLint *params) + { + GetProgramiv = (PFNGETPROGRAMIVPROC)IntGetProcAddress("glGetProgramiv"); + GetProgramiv(program, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) + { + GetProgramInfoLog = (PFNGETPROGRAMINFOLOGPROC)IntGetProcAddress("glGetProgramInfoLog"); + GetProgramInfoLog(program, bufSize, length, infoLog); + } + + static void CODEGEN_FUNCPTR Switch_GetShaderiv(GLuint shader, GLenum pname, GLint *params) + { + GetShaderiv = (PFNGETSHADERIVPROC)IntGetProcAddress("glGetShaderiv"); + GetShaderiv(shader, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) + { + GetShaderInfoLog = (PFNGETSHADERINFOLOGPROC)IntGetProcAddress("glGetShaderInfoLog"); + GetShaderInfoLog(shader, bufSize, length, infoLog); + } + + static void CODEGEN_FUNCPTR Switch_GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source) + { + GetShaderSource = (PFNGETSHADERSOURCEPROC)IntGetProcAddress("glGetShaderSource"); + GetShaderSource(shader, bufSize, length, source); + } + + static GLint CODEGEN_FUNCPTR Switch_GetUniformLocation(GLuint program, const GLchar *name) + { + GetUniformLocation = (PFNGETUNIFORMLOCATIONPROC)IntGetProcAddress("glGetUniformLocation"); + return GetUniformLocation(program, name); + } + + static void CODEGEN_FUNCPTR Switch_GetUniformfv(GLuint program, GLint location, GLfloat *params) + { + GetUniformfv = (PFNGETUNIFORMFVPROC)IntGetProcAddress("glGetUniformfv"); + GetUniformfv(program, location, params); + } + + static void CODEGEN_FUNCPTR Switch_GetUniformiv(GLuint program, GLint location, GLint *params) + { + GetUniformiv = (PFNGETUNIFORMIVPROC)IntGetProcAddress("glGetUniformiv"); + GetUniformiv(program, location, params); + } + + static void CODEGEN_FUNCPTR Switch_GetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) + { + GetVertexAttribdv = (PFNGETVERTEXATTRIBDVPROC)IntGetProcAddress("glGetVertexAttribdv"); + GetVertexAttribdv(index, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) + { + GetVertexAttribfv = (PFNGETVERTEXATTRIBFVPROC)IntGetProcAddress("glGetVertexAttribfv"); + GetVertexAttribfv(index, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetVertexAttribiv(GLuint index, GLenum pname, GLint *params) + { + GetVertexAttribiv = (PFNGETVERTEXATTRIBIVPROC)IntGetProcAddress("glGetVertexAttribiv"); + GetVertexAttribiv(index, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer) + { + GetVertexAttribPointerv = (PFNGETVERTEXATTRIBPOINTERVPROC)IntGetProcAddress("glGetVertexAttribPointerv"); + GetVertexAttribPointerv(index, pname, pointer); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsProgram(GLuint program) + { + IsProgram = (PFNISPROGRAMPROC)IntGetProcAddress("glIsProgram"); + return IsProgram(program); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsShader(GLuint shader) + { + IsShader = (PFNISSHADERPROC)IntGetProcAddress("glIsShader"); + return IsShader(shader); + } + + static void CODEGEN_FUNCPTR Switch_LinkProgram(GLuint program) + { + LinkProgram = (PFNLINKPROGRAMPROC)IntGetProcAddress("glLinkProgram"); + LinkProgram(program); + } + + static void CODEGEN_FUNCPTR Switch_ShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length) + { + ShaderSource = (PFNSHADERSOURCEPROC)IntGetProcAddress("glShaderSource"); + ShaderSource(shader, count, string, length); + } + + static void CODEGEN_FUNCPTR Switch_UseProgram(GLuint program) + { + UseProgram = (PFNUSEPROGRAMPROC)IntGetProcAddress("glUseProgram"); + UseProgram(program); + } + + static void CODEGEN_FUNCPTR Switch_Uniform1f(GLint location, GLfloat v0) + { + Uniform1f = (PFNUNIFORM1FPROC)IntGetProcAddress("glUniform1f"); + Uniform1f(location, v0); + } + + static void CODEGEN_FUNCPTR Switch_Uniform2f(GLint location, GLfloat v0, GLfloat v1) + { + Uniform2f = (PFNUNIFORM2FPROC)IntGetProcAddress("glUniform2f"); + Uniform2f(location, v0, v1); + } + + static void CODEGEN_FUNCPTR Switch_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) + { + Uniform3f = (PFNUNIFORM3FPROC)IntGetProcAddress("glUniform3f"); + Uniform3f(location, v0, v1, v2); + } + + static void CODEGEN_FUNCPTR Switch_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) + { + Uniform4f = (PFNUNIFORM4FPROC)IntGetProcAddress("glUniform4f"); + Uniform4f(location, v0, v1, v2, v3); + } + + static void CODEGEN_FUNCPTR Switch_Uniform1i(GLint location, GLint v0) + { + Uniform1i = (PFNUNIFORM1IPROC)IntGetProcAddress("glUniform1i"); + Uniform1i(location, v0); + } + + static void CODEGEN_FUNCPTR Switch_Uniform2i(GLint location, GLint v0, GLint v1) + { + Uniform2i = (PFNUNIFORM2IPROC)IntGetProcAddress("glUniform2i"); + Uniform2i(location, v0, v1); + } + + static void CODEGEN_FUNCPTR Switch_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2) + { + Uniform3i = (PFNUNIFORM3IPROC)IntGetProcAddress("glUniform3i"); + Uniform3i(location, v0, v1, v2); + } + + static void CODEGEN_FUNCPTR Switch_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) + { + Uniform4i = (PFNUNIFORM4IPROC)IntGetProcAddress("glUniform4i"); + Uniform4i(location, v0, v1, v2, v3); + } + + static void CODEGEN_FUNCPTR Switch_Uniform1fv(GLint location, GLsizei count, const GLfloat *value) + { + Uniform1fv = (PFNUNIFORM1FVPROC)IntGetProcAddress("glUniform1fv"); + Uniform1fv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform2fv(GLint location, GLsizei count, const GLfloat *value) + { + Uniform2fv = (PFNUNIFORM2FVPROC)IntGetProcAddress("glUniform2fv"); + Uniform2fv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform3fv(GLint location, GLsizei count, const GLfloat *value) + { + Uniform3fv = (PFNUNIFORM3FVPROC)IntGetProcAddress("glUniform3fv"); + Uniform3fv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform4fv(GLint location, GLsizei count, const GLfloat *value) + { + Uniform4fv = (PFNUNIFORM4FVPROC)IntGetProcAddress("glUniform4fv"); + Uniform4fv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform1iv(GLint location, GLsizei count, const GLint *value) + { + Uniform1iv = (PFNUNIFORM1IVPROC)IntGetProcAddress("glUniform1iv"); + Uniform1iv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform2iv(GLint location, GLsizei count, const GLint *value) + { + Uniform2iv = (PFNUNIFORM2IVPROC)IntGetProcAddress("glUniform2iv"); + Uniform2iv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform3iv(GLint location, GLsizei count, const GLint *value) + { + Uniform3iv = (PFNUNIFORM3IVPROC)IntGetProcAddress("glUniform3iv"); + Uniform3iv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform4iv(GLint location, GLsizei count, const GLint *value) + { + Uniform4iv = (PFNUNIFORM4IVPROC)IntGetProcAddress("glUniform4iv"); + Uniform4iv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix2fv = (PFNUNIFORMMATRIX2FVPROC)IntGetProcAddress("glUniformMatrix2fv"); + UniformMatrix2fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix3fv = (PFNUNIFORMMATRIX3FVPROC)IntGetProcAddress("glUniformMatrix3fv"); + UniformMatrix3fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix4fv = (PFNUNIFORMMATRIX4FVPROC)IntGetProcAddress("glUniformMatrix4fv"); + UniformMatrix4fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_ValidateProgram(GLuint program) + { + ValidateProgram = (PFNVALIDATEPROGRAMPROC)IntGetProcAddress("glValidateProgram"); + ValidateProgram(program); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer) + { + VertexAttribPointer = (PFNVERTEXATTRIBPOINTERPROC)IntGetProcAddress("glVertexAttribPointer"); + VertexAttribPointer(index, size, type, normalized, stride, pointer); + } + + // Extension: 2.1 + + static void CODEGEN_FUNCPTR Switch_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix2x3fv = (PFNUNIFORMMATRIX2X3FVPROC)IntGetProcAddress("glUniformMatrix2x3fv"); + UniformMatrix2x3fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix3x2fv = (PFNUNIFORMMATRIX3X2FVPROC)IntGetProcAddress("glUniformMatrix3x2fv"); + UniformMatrix3x2fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix2x4fv = (PFNUNIFORMMATRIX2X4FVPROC)IntGetProcAddress("glUniformMatrix2x4fv"); + UniformMatrix2x4fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix4x2fv = (PFNUNIFORMMATRIX4X2FVPROC)IntGetProcAddress("glUniformMatrix4x2fv"); + UniformMatrix4x2fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix3x4fv = (PFNUNIFORMMATRIX3X4FVPROC)IntGetProcAddress("glUniformMatrix3x4fv"); + UniformMatrix3x4fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix4x3fv = (PFNUNIFORMMATRIX4X3FVPROC)IntGetProcAddress("glUniformMatrix4x3fv"); + UniformMatrix4x3fv(location, count, transpose, value); + } + + // Extension: ARB_vertex_array_object + + static void CODEGEN_FUNCPTR Switch_BindVertexArray(GLuint ren_array) + { + BindVertexArray = (PFNBINDVERTEXARRAYPROC)IntGetProcAddress("glBindVertexArray"); + BindVertexArray(ren_array); + } + + static void CODEGEN_FUNCPTR Switch_DeleteVertexArrays(GLsizei n, const GLuint *arrays) + { + DeleteVertexArrays = (PFNDELETEVERTEXARRAYSPROC)IntGetProcAddress("glDeleteVertexArrays"); + DeleteVertexArrays(n, arrays); + } + + static void CODEGEN_FUNCPTR Switch_GenVertexArrays(GLsizei n, GLuint *arrays) + { + GenVertexArrays = (PFNGENVERTEXARRAYSPROC)IntGetProcAddress("glGenVertexArrays"); + GenVertexArrays(n, arrays); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsVertexArray(GLuint ren_array) + { + IsVertexArray = (PFNISVERTEXARRAYPROC)IntGetProcAddress("glIsVertexArray"); + return IsVertexArray(ren_array); + } + + // Extension: ARB_map_buffer_range + + static GLvoid* CODEGEN_FUNCPTR Switch_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) + { + MapBufferRange = (PFNMAPBUFFERRANGEPROC)IntGetProcAddress("glMapBufferRange"); + return MapBufferRange(target, offset, length, access); + } + + static void CODEGEN_FUNCPTR Switch_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) + { + FlushMappedBufferRange = (PFNFLUSHMAPPEDBUFFERRANGEPROC)IntGetProcAddress("glFlushMappedBufferRange"); + FlushMappedBufferRange(target, offset, length); + } + + // Extension: ARB_framebuffer_object + + static GLboolean CODEGEN_FUNCPTR Switch_IsRenderbuffer(GLuint renderbuffer) + { + IsRenderbuffer = (PFNISRENDERBUFFERPROC)IntGetProcAddress("glIsRenderbuffer"); + return IsRenderbuffer(renderbuffer); + } + + static void CODEGEN_FUNCPTR Switch_BindRenderbuffer(GLenum target, GLuint renderbuffer) + { + BindRenderbuffer = (PFNBINDRENDERBUFFERPROC)IntGetProcAddress("glBindRenderbuffer"); + BindRenderbuffer(target, renderbuffer); + } + + static void CODEGEN_FUNCPTR Switch_DeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers) + { + DeleteRenderbuffers = (PFNDELETERENDERBUFFERSPROC)IntGetProcAddress("glDeleteRenderbuffers"); + DeleteRenderbuffers(n, renderbuffers); + } + + static void CODEGEN_FUNCPTR Switch_GenRenderbuffers(GLsizei n, GLuint *renderbuffers) + { + GenRenderbuffers = (PFNGENRENDERBUFFERSPROC)IntGetProcAddress("glGenRenderbuffers"); + GenRenderbuffers(n, renderbuffers); + } + + static void CODEGEN_FUNCPTR Switch_RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) + { + RenderbufferStorage = (PFNRENDERBUFFERSTORAGEPROC)IntGetProcAddress("glRenderbufferStorage"); + RenderbufferStorage(target, internalformat, width, height); + } + + static void CODEGEN_FUNCPTR Switch_GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) + { + GetRenderbufferParameteriv = (PFNGETRENDERBUFFERPARAMETERIVPROC)IntGetProcAddress("glGetRenderbufferParameteriv"); + GetRenderbufferParameteriv(target, pname, params); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsFramebuffer(GLuint framebuffer) + { + IsFramebuffer = (PFNISFRAMEBUFFERPROC)IntGetProcAddress("glIsFramebuffer"); + return IsFramebuffer(framebuffer); + } + + static void CODEGEN_FUNCPTR Switch_BindFramebuffer(GLenum target, GLuint framebuffer) + { + BindFramebuffer = (PFNBINDFRAMEBUFFERPROC)IntGetProcAddress("glBindFramebuffer"); + BindFramebuffer(target, framebuffer); + } + + static void CODEGEN_FUNCPTR Switch_DeleteFramebuffers(GLsizei n, const GLuint *framebuffers) + { + DeleteFramebuffers = (PFNDELETEFRAMEBUFFERSPROC)IntGetProcAddress("glDeleteFramebuffers"); + DeleteFramebuffers(n, framebuffers); + } + + static void CODEGEN_FUNCPTR Switch_GenFramebuffers(GLsizei n, GLuint *framebuffers) + { + GenFramebuffers = (PFNGENFRAMEBUFFERSPROC)IntGetProcAddress("glGenFramebuffers"); + GenFramebuffers(n, framebuffers); + } + + static GLenum CODEGEN_FUNCPTR Switch_CheckFramebufferStatus(GLenum target) + { + CheckFramebufferStatus = (PFNCHECKFRAMEBUFFERSTATUSPROC)IntGetProcAddress("glCheckFramebufferStatus"); + return CheckFramebufferStatus(target); + } + + static void CODEGEN_FUNCPTR Switch_FramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) + { + FramebufferTexture1D = (PFNFRAMEBUFFERTEXTURE1DPROC)IntGetProcAddress("glFramebufferTexture1D"); + FramebufferTexture1D(target, attachment, textarget, texture, level); + } + + static void CODEGEN_FUNCPTR Switch_FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) + { + FramebufferTexture2D = (PFNFRAMEBUFFERTEXTURE2DPROC)IntGetProcAddress("glFramebufferTexture2D"); + FramebufferTexture2D(target, attachment, textarget, texture, level); + } + + static void CODEGEN_FUNCPTR Switch_FramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) + { + FramebufferTexture3D = (PFNFRAMEBUFFERTEXTURE3DPROC)IntGetProcAddress("glFramebufferTexture3D"); + FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); + } + + static void CODEGEN_FUNCPTR Switch_FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) + { + FramebufferRenderbuffer = (PFNFRAMEBUFFERRENDERBUFFERPROC)IntGetProcAddress("glFramebufferRenderbuffer"); + FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); + } + + static void CODEGEN_FUNCPTR Switch_GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) + { + GetFramebufferAttachmentParameteriv = (PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)IntGetProcAddress("glGetFramebufferAttachmentParameteriv"); + GetFramebufferAttachmentParameteriv(target, attachment, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GenerateMipmap(GLenum target) + { + GenerateMipmap = (PFNGENERATEMIPMAPPROC)IntGetProcAddress("glGenerateMipmap"); + GenerateMipmap(target); + } + + static void CODEGEN_FUNCPTR Switch_BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) + { + BlitFramebuffer = (PFNBLITFRAMEBUFFERPROC)IntGetProcAddress("glBlitFramebuffer"); + BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); + } + + static void CODEGEN_FUNCPTR Switch_RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) + { + RenderbufferStorageMultisample = (PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC)IntGetProcAddress("glRenderbufferStorageMultisample"); + RenderbufferStorageMultisample(target, samples, internalformat, width, height); + } + + static void CODEGEN_FUNCPTR Switch_FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) + { + FramebufferTextureLayer = (PFNFRAMEBUFFERTEXTURELAYERPROC)IntGetProcAddress("glFramebufferTextureLayer"); + FramebufferTextureLayer(target, attachment, texture, level, layer); + } + + // Extension: 3.0 + + static void CODEGEN_FUNCPTR Switch_ColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) + { + ColorMaski = (PFNCOLORMASKIPROC)IntGetProcAddress("glColorMaski"); + ColorMaski(index, r, g, b, a); + } + + static void CODEGEN_FUNCPTR Switch_GetBooleani_v(GLenum target, GLuint index, GLboolean *data) + { + GetBooleani_v = (PFNGETBOOLEANI_VPROC)IntGetProcAddress("glGetBooleani_v"); + GetBooleani_v(target, index, data); + } + + static void CODEGEN_FUNCPTR Switch_GetIntegeri_v(GLenum target, GLuint index, GLint *data) + { + GetIntegeri_v = (PFNGETINTEGERI_VPROC)IntGetProcAddress("glGetIntegeri_v"); + GetIntegeri_v(target, index, data); + } + + static void CODEGEN_FUNCPTR Switch_Enablei(GLenum target, GLuint index) + { + Enablei = (PFNENABLEIPROC)IntGetProcAddress("glEnablei"); + Enablei(target, index); + } + + static void CODEGEN_FUNCPTR Switch_Disablei(GLenum target, GLuint index) + { + Disablei = (PFNDISABLEIPROC)IntGetProcAddress("glDisablei"); + Disablei(target, index); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsEnabledi(GLenum target, GLuint index) + { + IsEnabledi = (PFNISENABLEDIPROC)IntGetProcAddress("glIsEnabledi"); + return IsEnabledi(target, index); + } + + static void CODEGEN_FUNCPTR Switch_BeginTransformFeedback(GLenum primitiveMode) + { + BeginTransformFeedback = (PFNBEGINTRANSFORMFEEDBACKPROC)IntGetProcAddress("glBeginTransformFeedback"); + BeginTransformFeedback(primitiveMode); + } + + static void CODEGEN_FUNCPTR Switch_EndTransformFeedback() + { + EndTransformFeedback = (PFNENDTRANSFORMFEEDBACKPROC)IntGetProcAddress("glEndTransformFeedback"); + EndTransformFeedback(); + } + + static void CODEGEN_FUNCPTR Switch_BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) + { + BindBufferRange = (PFNBINDBUFFERRANGEPROC)IntGetProcAddress("glBindBufferRange"); + BindBufferRange(target, index, buffer, offset, size); + } + + static void CODEGEN_FUNCPTR Switch_BindBufferBase(GLenum target, GLuint index, GLuint buffer) + { + BindBufferBase = (PFNBINDBUFFERBASEPROC)IntGetProcAddress("glBindBufferBase"); + BindBufferBase(target, index, buffer); + } + + static void CODEGEN_FUNCPTR Switch_TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode) + { + TransformFeedbackVaryings = (PFNTRANSFORMFEEDBACKVARYINGSPROC)IntGetProcAddress("glTransformFeedbackVaryings"); + TransformFeedbackVaryings(program, count, varyings, bufferMode); + } + + static void CODEGEN_FUNCPTR Switch_GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) + { + GetTransformFeedbackVarying = (PFNGETTRANSFORMFEEDBACKVARYINGPROC)IntGetProcAddress("glGetTransformFeedbackVarying"); + GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name); + } + + static void CODEGEN_FUNCPTR Switch_ClampColor(GLenum target, GLenum clamp) + { + ClampColor = (PFNCLAMPCOLORPROC)IntGetProcAddress("glClampColor"); + ClampColor(target, clamp); + } + + static void CODEGEN_FUNCPTR Switch_BeginConditionalRender(GLuint id, GLenum mode) + { + BeginConditionalRender = (PFNBEGINCONDITIONALRENDERPROC)IntGetProcAddress("glBeginConditionalRender"); + BeginConditionalRender(id, mode); + } + + static void CODEGEN_FUNCPTR Switch_EndConditionalRender() + { + EndConditionalRender = (PFNENDCONDITIONALRENDERPROC)IntGetProcAddress("glEndConditionalRender"); + EndConditionalRender(); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) + { + VertexAttribIPointer = (PFNVERTEXATTRIBIPOINTERPROC)IntGetProcAddress("glVertexAttribIPointer"); + VertexAttribIPointer(index, size, type, stride, pointer); + } + + static void CODEGEN_FUNCPTR Switch_GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params) + { + GetVertexAttribIiv = (PFNGETVERTEXATTRIBIIVPROC)IntGetProcAddress("glGetVertexAttribIiv"); + GetVertexAttribIiv(index, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params) + { + GetVertexAttribIuiv = (PFNGETVERTEXATTRIBIUIVPROC)IntGetProcAddress("glGetVertexAttribIuiv"); + GetVertexAttribIuiv(index, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI1i(GLuint index, GLint x) + { + VertexAttribI1i = (PFNVERTEXATTRIBI1IPROC)IntGetProcAddress("glVertexAttribI1i"); + VertexAttribI1i(index, x); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI2i(GLuint index, GLint x, GLint y) + { + VertexAttribI2i = (PFNVERTEXATTRIBI2IPROC)IntGetProcAddress("glVertexAttribI2i"); + VertexAttribI2i(index, x, y); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI3i(GLuint index, GLint x, GLint y, GLint z) + { + VertexAttribI3i = (PFNVERTEXATTRIBI3IPROC)IntGetProcAddress("glVertexAttribI3i"); + VertexAttribI3i(index, x, y, z); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) + { + VertexAttribI4i = (PFNVERTEXATTRIBI4IPROC)IntGetProcAddress("glVertexAttribI4i"); + VertexAttribI4i(index, x, y, z, w); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI1ui(GLuint index, GLuint x) + { + VertexAttribI1ui = (PFNVERTEXATTRIBI1UIPROC)IntGetProcAddress("glVertexAttribI1ui"); + VertexAttribI1ui(index, x); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI2ui(GLuint index, GLuint x, GLuint y) + { + VertexAttribI2ui = (PFNVERTEXATTRIBI2UIPROC)IntGetProcAddress("glVertexAttribI2ui"); + VertexAttribI2ui(index, x, y); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z) + { + VertexAttribI3ui = (PFNVERTEXATTRIBI3UIPROC)IntGetProcAddress("glVertexAttribI3ui"); + VertexAttribI3ui(index, x, y, z); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) + { + VertexAttribI4ui = (PFNVERTEXATTRIBI4UIPROC)IntGetProcAddress("glVertexAttribI4ui"); + VertexAttribI4ui(index, x, y, z, w); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI1iv(GLuint index, const GLint *v) + { + VertexAttribI1iv = (PFNVERTEXATTRIBI1IVPROC)IntGetProcAddress("glVertexAttribI1iv"); + VertexAttribI1iv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI2iv(GLuint index, const GLint *v) + { + VertexAttribI2iv = (PFNVERTEXATTRIBI2IVPROC)IntGetProcAddress("glVertexAttribI2iv"); + VertexAttribI2iv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI3iv(GLuint index, const GLint *v) + { + VertexAttribI3iv = (PFNVERTEXATTRIBI3IVPROC)IntGetProcAddress("glVertexAttribI3iv"); + VertexAttribI3iv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4iv(GLuint index, const GLint *v) + { + VertexAttribI4iv = (PFNVERTEXATTRIBI4IVPROC)IntGetProcAddress("glVertexAttribI4iv"); + VertexAttribI4iv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI1uiv(GLuint index, const GLuint *v) + { + VertexAttribI1uiv = (PFNVERTEXATTRIBI1UIVPROC)IntGetProcAddress("glVertexAttribI1uiv"); + VertexAttribI1uiv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI2uiv(GLuint index, const GLuint *v) + { + VertexAttribI2uiv = (PFNVERTEXATTRIBI2UIVPROC)IntGetProcAddress("glVertexAttribI2uiv"); + VertexAttribI2uiv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI3uiv(GLuint index, const GLuint *v) + { + VertexAttribI3uiv = (PFNVERTEXATTRIBI3UIVPROC)IntGetProcAddress("glVertexAttribI3uiv"); + VertexAttribI3uiv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4uiv(GLuint index, const GLuint *v) + { + VertexAttribI4uiv = (PFNVERTEXATTRIBI4UIVPROC)IntGetProcAddress("glVertexAttribI4uiv"); + VertexAttribI4uiv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4bv(GLuint index, const GLbyte *v) + { + VertexAttribI4bv = (PFNVERTEXATTRIBI4BVPROC)IntGetProcAddress("glVertexAttribI4bv"); + VertexAttribI4bv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4sv(GLuint index, const GLshort *v) + { + VertexAttribI4sv = (PFNVERTEXATTRIBI4SVPROC)IntGetProcAddress("glVertexAttribI4sv"); + VertexAttribI4sv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4ubv(GLuint index, const GLubyte *v) + { + VertexAttribI4ubv = (PFNVERTEXATTRIBI4UBVPROC)IntGetProcAddress("glVertexAttribI4ubv"); + VertexAttribI4ubv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4usv(GLuint index, const GLushort *v) + { + VertexAttribI4usv = (PFNVERTEXATTRIBI4USVPROC)IntGetProcAddress("glVertexAttribI4usv"); + VertexAttribI4usv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_GetUniformuiv(GLuint program, GLint location, GLuint *params) + { + GetUniformuiv = (PFNGETUNIFORMUIVPROC)IntGetProcAddress("glGetUniformuiv"); + GetUniformuiv(program, location, params); + } + + static void CODEGEN_FUNCPTR Switch_BindFragDataLocation(GLuint program, GLuint color, const GLchar *name) + { + BindFragDataLocation = (PFNBINDFRAGDATALOCATIONPROC)IntGetProcAddress("glBindFragDataLocation"); + BindFragDataLocation(program, color, name); + } + + static GLint CODEGEN_FUNCPTR Switch_GetFragDataLocation(GLuint program, const GLchar *name) + { + GetFragDataLocation = (PFNGETFRAGDATALOCATIONPROC)IntGetProcAddress("glGetFragDataLocation"); + return GetFragDataLocation(program, name); + } + + static void CODEGEN_FUNCPTR Switch_Uniform1ui(GLint location, GLuint v0) + { + Uniform1ui = (PFNUNIFORM1UIPROC)IntGetProcAddress("glUniform1ui"); + Uniform1ui(location, v0); + } + + static void CODEGEN_FUNCPTR Switch_Uniform2ui(GLint location, GLuint v0, GLuint v1) + { + Uniform2ui = (PFNUNIFORM2UIPROC)IntGetProcAddress("glUniform2ui"); + Uniform2ui(location, v0, v1); + } + + static void CODEGEN_FUNCPTR Switch_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) + { + Uniform3ui = (PFNUNIFORM3UIPROC)IntGetProcAddress("glUniform3ui"); + Uniform3ui(location, v0, v1, v2); + } + + static void CODEGEN_FUNCPTR Switch_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) + { + Uniform4ui = (PFNUNIFORM4UIPROC)IntGetProcAddress("glUniform4ui"); + Uniform4ui(location, v0, v1, v2, v3); + } + + static void CODEGEN_FUNCPTR Switch_Uniform1uiv(GLint location, GLsizei count, const GLuint *value) + { + Uniform1uiv = (PFNUNIFORM1UIVPROC)IntGetProcAddress("glUniform1uiv"); + Uniform1uiv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform2uiv(GLint location, GLsizei count, const GLuint *value) + { + Uniform2uiv = (PFNUNIFORM2UIVPROC)IntGetProcAddress("glUniform2uiv"); + Uniform2uiv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform3uiv(GLint location, GLsizei count, const GLuint *value) + { + Uniform3uiv = (PFNUNIFORM3UIVPROC)IntGetProcAddress("glUniform3uiv"); + Uniform3uiv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform4uiv(GLint location, GLsizei count, const GLuint *value) + { + Uniform4uiv = (PFNUNIFORM4UIVPROC)IntGetProcAddress("glUniform4uiv"); + Uniform4uiv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_TexParameterIiv(GLenum target, GLenum pname, const GLint *params) + { + TexParameterIiv = (PFNTEXPARAMETERIIVPROC)IntGetProcAddress("glTexParameterIiv"); + TexParameterIiv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_TexParameterIuiv(GLenum target, GLenum pname, const GLuint *params) + { + TexParameterIuiv = (PFNTEXPARAMETERIUIVPROC)IntGetProcAddress("glTexParameterIuiv"); + TexParameterIuiv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetTexParameterIiv(GLenum target, GLenum pname, GLint *params) + { + GetTexParameterIiv = (PFNGETTEXPARAMETERIIVPROC)IntGetProcAddress("glGetTexParameterIiv"); + GetTexParameterIiv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params) + { + GetTexParameterIuiv = (PFNGETTEXPARAMETERIUIVPROC)IntGetProcAddress("glGetTexParameterIuiv"); + GetTexParameterIuiv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value) + { + ClearBufferiv = (PFNCLEARBUFFERIVPROC)IntGetProcAddress("glClearBufferiv"); + ClearBufferiv(buffer, drawbuffer, value); + } + + static void CODEGEN_FUNCPTR Switch_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value) + { + ClearBufferuiv = (PFNCLEARBUFFERUIVPROC)IntGetProcAddress("glClearBufferuiv"); + ClearBufferuiv(buffer, drawbuffer, value); + } + + static void CODEGEN_FUNCPTR Switch_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value) + { + ClearBufferfv = (PFNCLEARBUFFERFVPROC)IntGetProcAddress("glClearBufferfv"); + ClearBufferfv(buffer, drawbuffer, value); + } + + static void CODEGEN_FUNCPTR Switch_ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) + { + ClearBufferfi = (PFNCLEARBUFFERFIPROC)IntGetProcAddress("glClearBufferfi"); + ClearBufferfi(buffer, drawbuffer, depth, stencil); + } + + static const GLubyte * CODEGEN_FUNCPTR Switch_GetStringi(GLenum name, GLuint index) + { + GetStringi = (PFNGETSTRINGIPROC)IntGetProcAddress("glGetStringi"); + return GetStringi(name, index); + } + + // Extension: ARB_uniform_buffer_object + + static void CODEGEN_FUNCPTR Switch_GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices) + { + GetUniformIndices = (PFNGETUNIFORMINDICESPROC)IntGetProcAddress("glGetUniformIndices"); + GetUniformIndices(program, uniformCount, uniformNames, uniformIndices); + } + + static void CODEGEN_FUNCPTR Switch_GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params) + { + GetActiveUniformsiv = (PFNGETACTIVEUNIFORMSIVPROC)IntGetProcAddress("glGetActiveUniformsiv"); + GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName) + { + GetActiveUniformName = (PFNGETACTIVEUNIFORMNAMEPROC)IntGetProcAddress("glGetActiveUniformName"); + GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); + } + + static GLuint CODEGEN_FUNCPTR Switch_GetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName) + { + GetUniformBlockIndex = (PFNGETUNIFORMBLOCKINDEXPROC)IntGetProcAddress("glGetUniformBlockIndex"); + return GetUniformBlockIndex(program, uniformBlockName); + } + + static void CODEGEN_FUNCPTR Switch_GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params) + { + GetActiveUniformBlockiv = (PFNGETACTIVEUNIFORMBLOCKIVPROC)IntGetProcAddress("glGetActiveUniformBlockiv"); + GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName) + { + GetActiveUniformBlockName = (PFNGETACTIVEUNIFORMBLOCKNAMEPROC)IntGetProcAddress("glGetActiveUniformBlockName"); + GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); + } + + static void CODEGEN_FUNCPTR Switch_UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) + { + UniformBlockBinding = (PFNUNIFORMBLOCKBINDINGPROC)IntGetProcAddress("glUniformBlockBinding"); + UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); + } + + // Extension: ARB_copy_buffer + + static void CODEGEN_FUNCPTR Switch_CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) + { + CopyBufferSubData = (PFNCOPYBUFFERSUBDATAPROC)IntGetProcAddress("glCopyBufferSubData"); + CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); + } + + // Extension: 3.1 + + static void CODEGEN_FUNCPTR Switch_DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) + { + DrawArraysInstanced = (PFNDRAWARRAYSINSTANCEDPROC)IntGetProcAddress("glDrawArraysInstanced"); + DrawArraysInstanced(mode, first, count, instancecount); + } + + static void CODEGEN_FUNCPTR Switch_DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount) + { + DrawElementsInstanced = (PFNDRAWELEMENTSINSTANCEDPROC)IntGetProcAddress("glDrawElementsInstanced"); + DrawElementsInstanced(mode, count, type, indices, instancecount); + } + + static void CODEGEN_FUNCPTR Switch_TexBuffer(GLenum target, GLenum internalformat, GLuint buffer) + { + TexBuffer = (PFNTEXBUFFERPROC)IntGetProcAddress("glTexBuffer"); + TexBuffer(target, internalformat, buffer); + } + + static void CODEGEN_FUNCPTR Switch_PrimitiveRestartIndex(GLuint index) + { + PrimitiveRestartIndex = (PFNPRIMITIVERESTARTINDEXPROC)IntGetProcAddress("glPrimitiveRestartIndex"); + PrimitiveRestartIndex(index); + } + + // Legacy + + static void CODEGEN_FUNCPTR Switch_EnableClientState(GLenum cap) + { + EnableClientState = (PFNENABLECLIENTSTATEPROC)IntGetProcAddress("glEnableClientState"); + EnableClientState(cap); + } + + static void CODEGEN_FUNCPTR Switch_DisableClientState(GLenum cap) + { + DisableClientState = (PFNDISABLECLIENTSTATEPROC)IntGetProcAddress("glDisableClientState"); + DisableClientState(cap); + } + + static void CODEGEN_FUNCPTR Switch_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) + { + VertexPointer = (PFNVERTEXPOINTERPROC)IntGetProcAddress("glVertexPointer"); + VertexPointer(size, type, stride, ptr); + } + + static void CODEGEN_FUNCPTR Switch_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr) + { + NormalPointer = (PFNNORMALPOINTERPROC)IntGetProcAddress("glNormalPointer"); + NormalPointer(type, stride, ptr); + } + + static void CODEGEN_FUNCPTR Switch_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) + { + ColorPointer = (PFNCOLORPOINTERPROC)IntGetProcAddress("glColorPointer"); + ColorPointer(size, type, stride, ptr); + } + + static void CODEGEN_FUNCPTR Switch_TexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) + { + TexCoordPointer = (PFNTEXCOORDPOINTERPROC)IntGetProcAddress("glTexCoordPointer"); + TexCoordPointer(size, type, stride, ptr); + } + + static void CODEGEN_FUNCPTR Switch_TexEnvi(GLenum target, GLenum pname, GLint param) + { + TexEnvi = (PFNTEXENVIPROC)IntGetProcAddress("glTexEnvi"); + TexEnvi(target, pname, param); + } + + static void CODEGEN_FUNCPTR Switch_MatrixMode(GLenum mode) + { + MatrixMode = (PFNMATRIXMODEPROC)IntGetProcAddress("glMatrixMode"); + MatrixMode(mode); + } + + static void CODEGEN_FUNCPTR Switch_LoadIdentity(void) + { + LoadIdentity = (PFNLOADIDENTITYPROC)IntGetProcAddress("glLoadIdentity"); + LoadIdentity(); + } + + static void CODEGEN_FUNCPTR Switch_Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val) + { + Ortho = (PFNORTHOPROC)IntGetProcAddress("glOrtho"); + Ortho(left, right, bottom, top, near_val, far_val); + } + + static void CODEGEN_FUNCPTR Switch_Color3d(GLdouble red, GLdouble green, GLdouble blue) + { + Color3d = (PFNCOLOR3DPROC)IntGetProcAddress("glColor3d"); + Color3d(red, green, blue); + } + + struct InitializeVariables + { + InitializeVariables() + { + // Extension: 1.1 + CullFace = Switch_CullFace; + FrontFace = Switch_FrontFace; + Hint = Switch_Hint; + LineWidth = Switch_LineWidth; + PointSize = Switch_PointSize; + PolygonMode = Switch_PolygonMode; + Scissor = Switch_Scissor; + TexParameterf = Switch_TexParameterf; + TexParameterfv = Switch_TexParameterfv; + TexParameteri = Switch_TexParameteri; + TexParameteriv = Switch_TexParameteriv; + TexImage1D = Switch_TexImage1D; + TexImage2D = Switch_TexImage2D; + DrawBuffer = Switch_DrawBuffer; + Clear = Switch_Clear; + ClearColor = Switch_ClearColor; + ClearStencil = Switch_ClearStencil; + ClearDepth = Switch_ClearDepth; + StencilMask = Switch_StencilMask; + ColorMask = Switch_ColorMask; + DepthMask = Switch_DepthMask; + Disable = Switch_Disable; + Enable = Switch_Enable; + Finish = Switch_Finish; + Flush = Switch_Flush; + BlendFunc = Switch_BlendFunc; + LogicOp = Switch_LogicOp; + StencilFunc = Switch_StencilFunc; + StencilOp = Switch_StencilOp; + DepthFunc = Switch_DepthFunc; + PixelStoref = Switch_PixelStoref; + PixelStorei = Switch_PixelStorei; + ReadBuffer = Switch_ReadBuffer; + ReadPixels = Switch_ReadPixels; + GetBooleanv = Switch_GetBooleanv; + GetDoublev = Switch_GetDoublev; + GetError = Switch_GetError; + GetFloatv = Switch_GetFloatv; + GetIntegerv = Switch_GetIntegerv; + GetString = Switch_GetString; + GetTexImage = Switch_GetTexImage; + GetTexParameterfv = Switch_GetTexParameterfv; + GetTexParameteriv = Switch_GetTexParameteriv; + GetTexLevelParameterfv = Switch_GetTexLevelParameterfv; + GetTexLevelParameteriv = Switch_GetTexLevelParameteriv; + IsEnabled = Switch_IsEnabled; + DepthRange = Switch_DepthRange; + Viewport = Switch_Viewport; + DrawArrays = Switch_DrawArrays; + DrawElements = Switch_DrawElements; + GetPointerv = Switch_GetPointerv; + PolygonOffset = Switch_PolygonOffset; + CopyTexImage1D = Switch_CopyTexImage1D; + CopyTexImage2D = Switch_CopyTexImage2D; + CopyTexSubImage1D = Switch_CopyTexSubImage1D; + CopyTexSubImage2D = Switch_CopyTexSubImage2D; + TexSubImage1D = Switch_TexSubImage1D; + TexSubImage2D = Switch_TexSubImage2D; + BindTexture = Switch_BindTexture; + DeleteTextures = Switch_DeleteTextures; + GenTextures = Switch_GenTextures; + IsTexture = Switch_IsTexture; + Indexub = Switch_Indexub; + Indexubv = Switch_Indexubv; + + // Extension: 1.2 + BlendColor = Switch_BlendColor; + BlendEquation = Switch_BlendEquation; + DrawRangeElements = Switch_DrawRangeElements; + TexSubImage3D = Switch_TexSubImage3D; + CopyTexSubImage3D = Switch_CopyTexSubImage3D; + + // Extension: 1.3 + ActiveTexture = Switch_ActiveTexture; + SampleCoverage = Switch_SampleCoverage; + CompressedTexImage3D = Switch_CompressedTexImage3D; + CompressedTexImage2D = Switch_CompressedTexImage2D; + CompressedTexImage1D = Switch_CompressedTexImage1D; + CompressedTexSubImage3D = Switch_CompressedTexSubImage3D; + CompressedTexSubImage2D = Switch_CompressedTexSubImage2D; + CompressedTexSubImage1D = Switch_CompressedTexSubImage1D; + GetCompressedTexImage = Switch_GetCompressedTexImage; + + // Extension: 1.4 + BlendFuncSeparate = Switch_BlendFuncSeparate; + MultiDrawArrays = Switch_MultiDrawArrays; + MultiDrawElements = Switch_MultiDrawElements; + PointParameterf = Switch_PointParameterf; + PointParameterfv = Switch_PointParameterfv; + PointParameteri = Switch_PointParameteri; + PointParameteriv = Switch_PointParameteriv; + + // Extension: 1.5 + GenQueries = Switch_GenQueries; + DeleteQueries = Switch_DeleteQueries; + IsQuery = Switch_IsQuery; + BeginQuery = Switch_BeginQuery; + EndQuery = Switch_EndQuery; + GetQueryiv = Switch_GetQueryiv; + GetQueryObjectiv = Switch_GetQueryObjectiv; + GetQueryObjectuiv = Switch_GetQueryObjectuiv; + BindBuffer = Switch_BindBuffer; + DeleteBuffers = Switch_DeleteBuffers; + GenBuffers = Switch_GenBuffers; + IsBuffer = Switch_IsBuffer; + BufferData = Switch_BufferData; + BufferSubData = Switch_BufferSubData; + GetBufferSubData = Switch_GetBufferSubData; + MapBuffer = Switch_MapBuffer; + UnmapBuffer = Switch_UnmapBuffer; + GetBufferParameteriv = Switch_GetBufferParameteriv; + GetBufferPointerv = Switch_GetBufferPointerv; + + // Extension: 2.0 + BlendEquationSeparate = Switch_BlendEquationSeparate; + DrawBuffers = Switch_DrawBuffers; + StencilOpSeparate = Switch_StencilOpSeparate; + StencilFuncSeparate = Switch_StencilFuncSeparate; + StencilMaskSeparate = Switch_StencilMaskSeparate; + AttachShader = Switch_AttachShader; + BindAttribLocation = Switch_BindAttribLocation; + CompileShader = Switch_CompileShader; + CreateProgram = Switch_CreateProgram; + CreateShader = Switch_CreateShader; + DeleteProgram = Switch_DeleteProgram; + DeleteShader = Switch_DeleteShader; + DetachShader = Switch_DetachShader; + DisableVertexAttribArray = Switch_DisableVertexAttribArray; + EnableVertexAttribArray = Switch_EnableVertexAttribArray; + GetActiveAttrib = Switch_GetActiveAttrib; + GetActiveUniform = Switch_GetActiveUniform; + GetAttachedShaders = Switch_GetAttachedShaders; + GetAttribLocation = Switch_GetAttribLocation; + GetProgramiv = Switch_GetProgramiv; + GetProgramInfoLog = Switch_GetProgramInfoLog; + GetShaderiv = Switch_GetShaderiv; + GetShaderInfoLog = Switch_GetShaderInfoLog; + GetShaderSource = Switch_GetShaderSource; + GetUniformLocation = Switch_GetUniformLocation; + GetUniformfv = Switch_GetUniformfv; + GetUniformiv = Switch_GetUniformiv; + GetVertexAttribdv = Switch_GetVertexAttribdv; + GetVertexAttribfv = Switch_GetVertexAttribfv; + GetVertexAttribiv = Switch_GetVertexAttribiv; + GetVertexAttribPointerv = Switch_GetVertexAttribPointerv; + IsProgram = Switch_IsProgram; + IsShader = Switch_IsShader; + LinkProgram = Switch_LinkProgram; + ShaderSource = Switch_ShaderSource; + UseProgram = Switch_UseProgram; + Uniform1f = Switch_Uniform1f; + Uniform2f = Switch_Uniform2f; + Uniform3f = Switch_Uniform3f; + Uniform4f = Switch_Uniform4f; + Uniform1i = Switch_Uniform1i; + Uniform2i = Switch_Uniform2i; + Uniform3i = Switch_Uniform3i; + Uniform4i = Switch_Uniform4i; + Uniform1fv = Switch_Uniform1fv; + Uniform2fv = Switch_Uniform2fv; + Uniform3fv = Switch_Uniform3fv; + Uniform4fv = Switch_Uniform4fv; + Uniform1iv = Switch_Uniform1iv; + Uniform2iv = Switch_Uniform2iv; + Uniform3iv = Switch_Uniform3iv; + Uniform4iv = Switch_Uniform4iv; + UniformMatrix2fv = Switch_UniformMatrix2fv; + UniformMatrix3fv = Switch_UniformMatrix3fv; + UniformMatrix4fv = Switch_UniformMatrix4fv; + ValidateProgram = Switch_ValidateProgram; + VertexAttribPointer = Switch_VertexAttribPointer; + + // Extension: 2.1 + UniformMatrix2x3fv = Switch_UniformMatrix2x3fv; + UniformMatrix3x2fv = Switch_UniformMatrix3x2fv; + UniformMatrix2x4fv = Switch_UniformMatrix2x4fv; + UniformMatrix4x2fv = Switch_UniformMatrix4x2fv; + UniformMatrix3x4fv = Switch_UniformMatrix3x4fv; + UniformMatrix4x3fv = Switch_UniformMatrix4x3fv; + + // Extension: ARB_vertex_array_object + BindVertexArray = Switch_BindVertexArray; + DeleteVertexArrays = Switch_DeleteVertexArrays; + GenVertexArrays = Switch_GenVertexArrays; + IsVertexArray = Switch_IsVertexArray; + + // Extension: ARB_map_buffer_range + MapBufferRange = Switch_MapBufferRange; + FlushMappedBufferRange = Switch_FlushMappedBufferRange; + + // Extension: ARB_framebuffer_object + IsRenderbuffer = Switch_IsRenderbuffer; + BindRenderbuffer = Switch_BindRenderbuffer; + DeleteRenderbuffers = Switch_DeleteRenderbuffers; + GenRenderbuffers = Switch_GenRenderbuffers; + RenderbufferStorage = Switch_RenderbufferStorage; + GetRenderbufferParameteriv = Switch_GetRenderbufferParameteriv; + IsFramebuffer = Switch_IsFramebuffer; + BindFramebuffer = Switch_BindFramebuffer; + DeleteFramebuffers = Switch_DeleteFramebuffers; + GenFramebuffers = Switch_GenFramebuffers; + CheckFramebufferStatus = Switch_CheckFramebufferStatus; + FramebufferTexture1D = Switch_FramebufferTexture1D; + FramebufferTexture2D = Switch_FramebufferTexture2D; + FramebufferTexture3D = Switch_FramebufferTexture3D; + FramebufferRenderbuffer = Switch_FramebufferRenderbuffer; + GetFramebufferAttachmentParameteriv = Switch_GetFramebufferAttachmentParameteriv; + GenerateMipmap = Switch_GenerateMipmap; + BlitFramebuffer = Switch_BlitFramebuffer; + RenderbufferStorageMultisample = Switch_RenderbufferStorageMultisample; + FramebufferTextureLayer = Switch_FramebufferTextureLayer; + + // Extension: 3.0 + ColorMaski = Switch_ColorMaski; + GetBooleani_v = Switch_GetBooleani_v; + GetIntegeri_v = Switch_GetIntegeri_v; + Enablei = Switch_Enablei; + Disablei = Switch_Disablei; + IsEnabledi = Switch_IsEnabledi; + BeginTransformFeedback = Switch_BeginTransformFeedback; + EndTransformFeedback = Switch_EndTransformFeedback; + BindBufferRange = Switch_BindBufferRange; + BindBufferBase = Switch_BindBufferBase; + TransformFeedbackVaryings = Switch_TransformFeedbackVaryings; + GetTransformFeedbackVarying = Switch_GetTransformFeedbackVarying; + ClampColor = Switch_ClampColor; + BeginConditionalRender = Switch_BeginConditionalRender; + EndConditionalRender = Switch_EndConditionalRender; + VertexAttribIPointer = Switch_VertexAttribIPointer; + GetVertexAttribIiv = Switch_GetVertexAttribIiv; + GetVertexAttribIuiv = Switch_GetVertexAttribIuiv; + VertexAttribI1i = Switch_VertexAttribI1i; + VertexAttribI2i = Switch_VertexAttribI2i; + VertexAttribI3i = Switch_VertexAttribI3i; + VertexAttribI4i = Switch_VertexAttribI4i; + VertexAttribI1ui = Switch_VertexAttribI1ui; + VertexAttribI2ui = Switch_VertexAttribI2ui; + VertexAttribI3ui = Switch_VertexAttribI3ui; + VertexAttribI4ui = Switch_VertexAttribI4ui; + VertexAttribI1iv = Switch_VertexAttribI1iv; + VertexAttribI2iv = Switch_VertexAttribI2iv; + VertexAttribI3iv = Switch_VertexAttribI3iv; + VertexAttribI4iv = Switch_VertexAttribI4iv; + VertexAttribI1uiv = Switch_VertexAttribI1uiv; + VertexAttribI2uiv = Switch_VertexAttribI2uiv; + VertexAttribI3uiv = Switch_VertexAttribI3uiv; + VertexAttribI4uiv = Switch_VertexAttribI4uiv; + VertexAttribI4bv = Switch_VertexAttribI4bv; + VertexAttribI4sv = Switch_VertexAttribI4sv; + VertexAttribI4ubv = Switch_VertexAttribI4ubv; + VertexAttribI4usv = Switch_VertexAttribI4usv; + GetUniformuiv = Switch_GetUniformuiv; + BindFragDataLocation = Switch_BindFragDataLocation; + GetFragDataLocation = Switch_GetFragDataLocation; + Uniform1ui = Switch_Uniform1ui; + Uniform2ui = Switch_Uniform2ui; + Uniform3ui = Switch_Uniform3ui; + Uniform4ui = Switch_Uniform4ui; + Uniform1uiv = Switch_Uniform1uiv; + Uniform2uiv = Switch_Uniform2uiv; + Uniform3uiv = Switch_Uniform3uiv; + Uniform4uiv = Switch_Uniform4uiv; + TexParameterIiv = Switch_TexParameterIiv; + TexParameterIuiv = Switch_TexParameterIuiv; + GetTexParameterIiv = Switch_GetTexParameterIiv; + GetTexParameterIuiv = Switch_GetTexParameterIuiv; + ClearBufferiv = Switch_ClearBufferiv; + ClearBufferuiv = Switch_ClearBufferuiv; + ClearBufferfv = Switch_ClearBufferfv; + ClearBufferfi = Switch_ClearBufferfi; + GetStringi = Switch_GetStringi; + + // Extension: ARB_uniform_buffer_object + GetUniformIndices = Switch_GetUniformIndices; + GetActiveUniformsiv = Switch_GetActiveUniformsiv; + GetActiveUniformName = Switch_GetActiveUniformName; + GetUniformBlockIndex = Switch_GetUniformBlockIndex; + GetActiveUniformBlockiv = Switch_GetActiveUniformBlockiv; + GetActiveUniformBlockName = Switch_GetActiveUniformBlockName; + UniformBlockBinding = Switch_UniformBlockBinding; + + // Extension: ARB_copy_buffer + CopyBufferSubData = Switch_CopyBufferSubData; + + // Extension: 3.1 + DrawArraysInstanced = Switch_DrawArraysInstanced; + DrawElementsInstanced = Switch_DrawElementsInstanced; + TexBuffer = Switch_TexBuffer; + PrimitiveRestartIndex = Switch_PrimitiveRestartIndex; + + // Legacy + EnableClientState = Switch_EnableClientState; + DisableClientState = Switch_DisableClientState; + VertexPointer = Switch_VertexPointer; + NormalPointer = Switch_NormalPointer; + ColorPointer = Switch_ColorPointer; + TexCoordPointer = Switch_TexCoordPointer; + TexEnvi = Switch_TexEnvi; + MatrixMode = Switch_MatrixMode; + LoadIdentity = Switch_LoadIdentity; + Ortho = Switch_Ortho; + Color3d = Switch_Color3d; + } + }; + + InitializeVariables g_initVariables; +} diff --git a/modules/core/src/gl_core_3_1.hpp b/modules/core/src/gl_core_3_1.hpp new file mode 100644 index 0000000000..50dbee66c7 --- /dev/null +++ b/modules/core/src/gl_core_3_1.hpp @@ -0,0 +1,1331 @@ +#ifndef OPENGL_NOLOAD_STYLE_HPP +#define OPENGL_NOLOAD_STYLE_HPP + +#if defined(__gl_h_) || defined(__GL_H__) +#error Attempt to include auto-generated header after including gl.h +#endif +#if defined(__glext_h_) || defined(__GLEXT_H_) +#error Attempt to include auto-generated header after including glext.h +#endif +#if defined(__gl_ATI_h_) +#error Attempt to include auto-generated header after including glATI.h +#endif + +#define __gl_h_ +#define __GL_H__ +#define __glext_h_ +#define __GLEXT_H_ +#define __gl_ATI_h_ + +#ifndef APIENTRY + #if defined(__MINGW32__) + #ifndef WIN32_LEAN_AND_MEAN + #define WIN32_LEAN_AND_MEAN 1 + #endif + #ifndef NOMINMAX + #define NOMINMAX + #endif + #include + #elif (defined(_MSC_VER) && _MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) || defined(__BORLANDC__) + #ifndef WIN32_LEAN_AND_MEAN + #define WIN32_LEAN_AND_MEAN 1 + #endif + #ifndef NOMINMAX + #define NOMINMAX + #endif + #include + #else + #define APIENTRY + #endif +#endif // APIENTRY + +#ifndef CODEGEN_FUNCPTR + #define CODEGEN_REMOVE_FUNCPTR + #if defined(_WIN32) + #define CODEGEN_FUNCPTR APIENTRY + #else + #define CODEGEN_FUNCPTR + #endif +#endif // CODEGEN_FUNCPTR + +#ifndef GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS +#define GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS + typedef unsigned int GLenum; + typedef unsigned char GLboolean; + typedef unsigned int GLbitfield; + typedef signed char GLbyte; + typedef short GLshort; + typedef int GLint; + typedef int GLsizei; + typedef unsigned char GLubyte; + typedef unsigned short GLushort; + typedef unsigned int GLuint; + typedef float GLfloat; + typedef float GLclampf; + typedef double GLdouble; + typedef double GLclampd; + #define GLvoid void +#endif // GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS + +#include + +#ifndef GL_VERSION_2_0 + // GL type for program/shader text + typedef char GLchar; +#endif + +#ifndef GL_VERSION_1_5 + // GL types for handling large vertex buffer objects + typedef ptrdiff_t GLintptr; + typedef ptrdiff_t GLsizeiptr; +#endif + +#ifndef GL_ARB_vertex_buffer_object + // GL types for handling large vertex buffer objects + typedef ptrdiff_t GLintptrARB; + typedef ptrdiff_t GLsizeiptrARB; +#endif + +#ifndef GL_ARB_shader_objects + // GL types for program/shader text and shader object handles + typedef char GLcharARB; + typedef unsigned int GLhandleARB; +#endif + +// GL type for "half" precision (s10e5) float data in host memory +#ifndef GL_ARB_half_float_pixel + typedef unsigned short GLhalfARB; +#endif +#ifndef GL_NV_half_float + typedef unsigned short GLhalfNV; +#endif + +#ifndef GLEXT_64_TYPES_DEFINED + // This code block is duplicated in glxext.h, so must be protected + #define GLEXT_64_TYPES_DEFINED + + // Define int32_t, int64_t, and uint64_t types for UST/MSC + // (as used in the GL_EXT_timer_query extension) + #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #include + #elif defined(__sun__) || defined(__digital__) + #include + #if defined(__STDC__) + #if defined(__arch64__) || defined(_LP64) + typedef long int int64_t; + typedef unsigned long int uint64_t; + #else + typedef long long int int64_t; + typedef unsigned long long int uint64_t; + #endif // __arch64__ + #endif // __STDC__ + #elif defined( __VMS ) || defined(__sgi) + #include + #elif defined(__SCO__) || defined(__USLC__) + #include + #elif defined(__UNIXOS2__) || defined(__SOL64__) + typedef long int int32_t; + typedef long long int int64_t; + typedef unsigned long long int uint64_t; + #elif defined(_WIN32) && defined(__GNUC__) + #include + #elif defined(_WIN32) + typedef __int32 int32_t; + typedef __int64 int64_t; + typedef unsigned __int64 uint64_t; + #else + // Fallback if nothing above works + #include + #endif +#endif + +#ifndef GL_EXT_timer_query + typedef int64_t GLint64EXT; + typedef uint64_t GLuint64EXT; +#endif + +#ifndef GL_ARB_sync + typedef int64_t GLint64; + typedef uint64_t GLuint64; + typedef struct __GLsync *GLsync; +#endif + +#ifndef GL_ARB_cl_event + // These incomplete types let us declare types compatible with OpenCL's cl_context and cl_event + struct _cl_context; + struct _cl_event; +#endif + +#ifndef GL_ARB_debug_output + typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam); +#endif + +#ifndef GL_AMD_debug_output + typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam); +#endif + +#ifndef GL_KHR_debug + typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam); +#endif + +#ifndef GL_NV_vdpau_interop + typedef GLintptr GLvdpauSurfaceNV; +#endif + +namespace gl +{ + enum + { + // Version: 1.1 + DEPTH_BUFFER_BIT = 0x00000100, + STENCIL_BUFFER_BIT = 0x00000400, + COLOR_BUFFER_BIT = 0x00004000, + FALSE_ = 0, + TRUE_ = 1, + POINTS = 0x0000, + LINES = 0x0001, + LINE_LOOP = 0x0002, + LINE_STRIP = 0x0003, + TRIANGLES = 0x0004, + TRIANGLE_STRIP = 0x0005, + TRIANGLE_FAN = 0x0006, + QUADS = 0x0007, + NEVER = 0x0200, + LESS = 0x0201, + EQUAL = 0x0202, + LEQUAL = 0x0203, + GREATER = 0x0204, + NOTEQUAL = 0x0205, + GEQUAL = 0x0206, + ALWAYS = 0x0207, + ZERO = 0, + ONE = 1, + SRC_COLOR = 0x0300, + ONE_MINUS_SRC_COLOR = 0x0301, + SRC_ALPHA = 0x0302, + ONE_MINUS_SRC_ALPHA = 0x0303, + DST_ALPHA = 0x0304, + ONE_MINUS_DST_ALPHA = 0x0305, + DST_COLOR = 0x0306, + ONE_MINUS_DST_COLOR = 0x0307, + SRC_ALPHA_SATURATE = 0x0308, + NONE = 0, + FRONT_LEFT = 0x0400, + FRONT_RIGHT = 0x0401, + BACK_LEFT = 0x0402, + BACK_RIGHT = 0x0403, + FRONT = 0x0404, + BACK = 0x0405, + LEFT = 0x0406, + RIGHT = 0x0407, + FRONT_AND_BACK = 0x0408, + NO_ERROR_ = 0, + INVALID_ENUM = 0x0500, + INVALID_VALUE = 0x0501, + INVALID_OPERATION = 0x0502, + OUT_OF_MEMORY = 0x0505, + CW = 0x0900, + CCW = 0x0901, + POINT_SIZE = 0x0B11, + POINT_SIZE_RANGE = 0x0B12, + POINT_SIZE_GRANULARITY = 0x0B13, + LINE_SMOOTH = 0x0B20, + LINE_WIDTH = 0x0B21, + LINE_WIDTH_RANGE = 0x0B22, + LINE_WIDTH_GRANULARITY = 0x0B23, + POLYGON_MODE = 0x0B40, + POLYGON_SMOOTH = 0x0B41, + CULL_FACE = 0x0B44, + CULL_FACE_MODE = 0x0B45, + FRONT_FACE = 0x0B46, + DEPTH_RANGE = 0x0B70, + DEPTH_TEST = 0x0B71, + DEPTH_WRITEMASK = 0x0B72, + DEPTH_CLEAR_VALUE = 0x0B73, + DEPTH_FUNC = 0x0B74, + STENCIL_TEST = 0x0B90, + STENCIL_CLEAR_VALUE = 0x0B91, + STENCIL_FUNC = 0x0B92, + STENCIL_VALUE_MASK = 0x0B93, + STENCIL_FAIL = 0x0B94, + STENCIL_PASS_DEPTH_FAIL = 0x0B95, + STENCIL_PASS_DEPTH_PASS = 0x0B96, + STENCIL_REF = 0x0B97, + STENCIL_WRITEMASK = 0x0B98, + VIEWPORT = 0x0BA2, + DITHER = 0x0BD0, + BLEND_DST = 0x0BE0, + BLEND_SRC = 0x0BE1, + BLEND = 0x0BE2, + LOGIC_OP_MODE = 0x0BF0, + COLOR_LOGIC_OP = 0x0BF2, + DRAW_BUFFER = 0x0C01, + READ_BUFFER = 0x0C02, + SCISSOR_BOX = 0x0C10, + SCISSOR_TEST = 0x0C11, + COLOR_CLEAR_VALUE = 0x0C22, + COLOR_WRITEMASK = 0x0C23, + DOUBLEBUFFER = 0x0C32, + STEREO = 0x0C33, + LINE_SMOOTH_HINT = 0x0C52, + POLYGON_SMOOTH_HINT = 0x0C53, + UNPACK_SWAP_BYTES = 0x0CF0, + UNPACK_LSB_FIRST = 0x0CF1, + UNPACK_ROW_LENGTH = 0x0CF2, + UNPACK_SKIP_ROWS = 0x0CF3, + UNPACK_SKIP_PIXELS = 0x0CF4, + UNPACK_ALIGNMENT = 0x0CF5, + PACK_SWAP_BYTES = 0x0D00, + PACK_LSB_FIRST = 0x0D01, + PACK_ROW_LENGTH = 0x0D02, + PACK_SKIP_ROWS = 0x0D03, + PACK_SKIP_PIXELS = 0x0D04, + PACK_ALIGNMENT = 0x0D05, + MAX_TEXTURE_SIZE = 0x0D33, + MAX_VIEWPORT_DIMS = 0x0D3A, + SUBPIXEL_BITS = 0x0D50, + TEXTURE_1D = 0x0DE0, + TEXTURE_2D = 0x0DE1, + POLYGON_OFFSET_UNITS = 0x2A00, + POLYGON_OFFSET_POINT = 0x2A01, + POLYGON_OFFSET_LINE = 0x2A02, + POLYGON_OFFSET_FILL = 0x8037, + POLYGON_OFFSET_FACTOR = 0x8038, + TEXTURE_BINDING_1D = 0x8068, + TEXTURE_BINDING_2D = 0x8069, + TEXTURE_WIDTH = 0x1000, + TEXTURE_HEIGHT = 0x1001, + TEXTURE_INTERNAL_FORMAT = 0x1003, + TEXTURE_BORDER_COLOR = 0x1004, + TEXTURE_RED_SIZE = 0x805C, + TEXTURE_GREEN_SIZE = 0x805D, + TEXTURE_BLUE_SIZE = 0x805E, + TEXTURE_ALPHA_SIZE = 0x805F, + DONT_CARE = 0x1100, + FASTEST = 0x1101, + NICEST = 0x1102, + BYTE = 0x1400, + UNSIGNED_BYTE = 0x1401, + SHORT = 0x1402, + UNSIGNED_SHORT = 0x1403, + INT = 0x1404, + UNSIGNED_INT = 0x1405, + FLOAT = 0x1406, + DOUBLE = 0x140A, + CLEAR = 0x1500, + AND = 0x1501, + AND_REVERSE = 0x1502, + COPY = 0x1503, + AND_INVERTED = 0x1504, + NOOP = 0x1505, + XOR = 0x1506, + OR = 0x1507, + NOR = 0x1508, + EQUIV = 0x1509, + INVERT = 0x150A, + OR_REVERSE = 0x150B, + COPY_INVERTED = 0x150C, + OR_INVERTED = 0x150D, + NAND = 0x150E, + SET = 0x150F, + TEXTURE = 0x1702, + COLOR = 0x1800, + DEPTH = 0x1801, + STENCIL = 0x1802, + STENCIL_INDEX = 0x1901, + DEPTH_COMPONENT = 0x1902, + RED = 0x1903, + GREEN = 0x1904, + BLUE = 0x1905, + ALPHA = 0x1906, + RGB = 0x1907, + RGBA = 0x1908, + POINT = 0x1B00, + LINE = 0x1B01, + FILL = 0x1B02, + KEEP = 0x1E00, + REPLACE = 0x1E01, + INCR = 0x1E02, + DECR = 0x1E03, + VENDOR = 0x1F00, + RENDERER = 0x1F01, + VERSION_ = 0x1F02, + EXTENSIONS = 0x1F03, + NEAREST = 0x2600, + LINEAR = 0x2601, + NEAREST_MIPMAP_NEAREST = 0x2700, + LINEAR_MIPMAP_NEAREST = 0x2701, + NEAREST_MIPMAP_LINEAR = 0x2702, + LINEAR_MIPMAP_LINEAR = 0x2703, + TEXTURE_MAG_FILTER = 0x2800, + TEXTURE_MIN_FILTER = 0x2801, + TEXTURE_WRAP_S = 0x2802, + TEXTURE_WRAP_T = 0x2803, + PROXY_TEXTURE_1D = 0x8063, + PROXY_TEXTURE_2D = 0x8064, + REPEAT = 0x2901, + R3_G3_B2 = 0x2A10, + RGB4 = 0x804F, + RGB5 = 0x8050, + RGB8 = 0x8051, + RGB10 = 0x8052, + RGB12 = 0x8053, + RGB16 = 0x8054, + RGBA2 = 0x8055, + RGBA4 = 0x8056, + RGB5_A1 = 0x8057, + RGBA8 = 0x8058, + RGB10_A2 = 0x8059, + RGBA12 = 0x805A, + RGBA16 = 0x805B, + + // Core Extension: ARB_imaging + CONSTANT_COLOR = 0x8001, + ONE_MINUS_CONSTANT_COLOR = 0x8002, + CONSTANT_ALPHA = 0x8003, + ONE_MINUS_CONSTANT_ALPHA = 0x8004, + BLEND_COLOR = 0x8005, + FUNC_ADD = 0x8006, + MIN = 0x8007, + MAX = 0x8008, + BLEND_EQUATION = 0x8009, + FUNC_SUBTRACT = 0x800A, + FUNC_REVERSE_SUBTRACT = 0x800B, + CONVOLUTION_1D = 0x8010, + CONVOLUTION_2D = 0x8011, + SEPARABLE_2D = 0x8012, + CONVOLUTION_BORDER_MODE = 0x8013, + CONVOLUTION_FILTER_SCALE = 0x8014, + CONVOLUTION_FILTER_BIAS = 0x8015, + REDUCE = 0x8016, + CONVOLUTION_FORMAT = 0x8017, + CONVOLUTION_WIDTH = 0x8018, + CONVOLUTION_HEIGHT = 0x8019, + MAX_CONVOLUTION_WIDTH = 0x801A, + MAX_CONVOLUTION_HEIGHT = 0x801B, + POST_CONVOLUTION_RED_SCALE = 0x801C, + POST_CONVOLUTION_GREEN_SCALE = 0x801D, + POST_CONVOLUTION_BLUE_SCALE = 0x801E, + POST_CONVOLUTION_ALPHA_SCALE = 0x801F, + POST_CONVOLUTION_RED_BIAS = 0x8020, + POST_CONVOLUTION_GREEN_BIAS = 0x8021, + POST_CONVOLUTION_BLUE_BIAS = 0x8022, + POST_CONVOLUTION_ALPHA_BIAS = 0x8023, + HISTOGRAM = 0x8024, + PROXY_HISTOGRAM = 0x8025, + HISTOGRAM_WIDTH = 0x8026, + HISTOGRAM_FORMAT = 0x8027, + HISTOGRAM_RED_SIZE = 0x8028, + HISTOGRAM_GREEN_SIZE = 0x8029, + HISTOGRAM_BLUE_SIZE = 0x802A, + HISTOGRAM_ALPHA_SIZE = 0x802B, + HISTOGRAM_LUMINANCE_SIZE = 0x802C, + HISTOGRAM_SINK = 0x802D, + MINMAX = 0x802E, + MINMAX_FORMAT = 0x802F, + MINMAX_SINK = 0x8030, + TABLE_TOO_LARGE = 0x8031, + COLOR_MATRIX = 0x80B1, + COLOR_MATRIX_STACK_DEPTH = 0x80B2, + MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3, + POST_COLOR_MATRIX_RED_SCALE = 0x80B4, + POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5, + POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6, + POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7, + POST_COLOR_MATRIX_RED_BIAS = 0x80B8, + POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9, + POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA, + POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB, + COLOR_TABLE = 0x80D0, + POST_CONVOLUTION_COLOR_TABLE = 0x80D1, + POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2, + PROXY_COLOR_TABLE = 0x80D3, + PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4, + PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5, + COLOR_TABLE_SCALE = 0x80D6, + COLOR_TABLE_BIAS = 0x80D7, + COLOR_TABLE_FORMAT = 0x80D8, + COLOR_TABLE_WIDTH = 0x80D9, + COLOR_TABLE_RED_SIZE = 0x80DA, + COLOR_TABLE_GREEN_SIZE = 0x80DB, + COLOR_TABLE_BLUE_SIZE = 0x80DC, + COLOR_TABLE_ALPHA_SIZE = 0x80DD, + COLOR_TABLE_LUMINANCE_SIZE = 0x80DE, + COLOR_TABLE_INTENSITY_SIZE = 0x80DF, + CONSTANT_BORDER = 0x8151, + REPLICATE_BORDER = 0x8153, + CONVOLUTION_BORDER_COLOR = 0x8154, + + // Version: 1.2 + UNSIGNED_BYTE_3_3_2 = 0x8032, + UNSIGNED_SHORT_4_4_4_4 = 0x8033, + UNSIGNED_SHORT_5_5_5_1 = 0x8034, + UNSIGNED_INT_8_8_8_8 = 0x8035, + UNSIGNED_INT_10_10_10_2 = 0x8036, + TEXTURE_BINDING_3D = 0x806A, + PACK_SKIP_IMAGES = 0x806B, + PACK_IMAGE_HEIGHT = 0x806C, + UNPACK_SKIP_IMAGES = 0x806D, + UNPACK_IMAGE_HEIGHT = 0x806E, + TEXTURE_3D = 0x806F, + PROXY_TEXTURE_3D = 0x8070, + TEXTURE_DEPTH = 0x8071, + TEXTURE_WRAP_R = 0x8072, + MAX_3D_TEXTURE_SIZE = 0x8073, + UNSIGNED_BYTE_2_3_3_REV = 0x8362, + UNSIGNED_SHORT_5_6_5 = 0x8363, + UNSIGNED_SHORT_5_6_5_REV = 0x8364, + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365, + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366, + UNSIGNED_INT_8_8_8_8_REV = 0x8367, + UNSIGNED_INT_2_10_10_10_REV = 0x8368, + BGR = 0x80E0, + BGRA = 0x80E1, + MAX_ELEMENTS_VERTICES = 0x80E8, + MAX_ELEMENTS_INDICES = 0x80E9, + CLAMP_TO_EDGE = 0x812F, + TEXTURE_MIN_LOD = 0x813A, + TEXTURE_MAX_LOD = 0x813B, + TEXTURE_BASE_LEVEL = 0x813C, + TEXTURE_MAX_LEVEL = 0x813D, + SMOOTH_POINT_SIZE_RANGE = 0x0B12, + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13, + SMOOTH_LINE_WIDTH_RANGE = 0x0B22, + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23, + ALIASED_LINE_WIDTH_RANGE = 0x846E, + + // Version: 1.3 + TEXTURE0 = 0x84C0, + TEXTURE1 = 0x84C1, + TEXTURE2 = 0x84C2, + TEXTURE3 = 0x84C3, + TEXTURE4 = 0x84C4, + TEXTURE5 = 0x84C5, + TEXTURE6 = 0x84C6, + TEXTURE7 = 0x84C7, + TEXTURE8 = 0x84C8, + TEXTURE9 = 0x84C9, + TEXTURE10 = 0x84CA, + TEXTURE11 = 0x84CB, + TEXTURE12 = 0x84CC, + TEXTURE13 = 0x84CD, + TEXTURE14 = 0x84CE, + TEXTURE15 = 0x84CF, + TEXTURE16 = 0x84D0, + TEXTURE17 = 0x84D1, + TEXTURE18 = 0x84D2, + TEXTURE19 = 0x84D3, + TEXTURE20 = 0x84D4, + TEXTURE21 = 0x84D5, + TEXTURE22 = 0x84D6, + TEXTURE23 = 0x84D7, + TEXTURE24 = 0x84D8, + TEXTURE25 = 0x84D9, + TEXTURE26 = 0x84DA, + TEXTURE27 = 0x84DB, + TEXTURE28 = 0x84DC, + TEXTURE29 = 0x84DD, + TEXTURE30 = 0x84DE, + TEXTURE31 = 0x84DF, + ACTIVE_TEXTURE = 0x84E0, + MULTISAMPLE = 0x809D, + SAMPLE_ALPHA_TO_COVERAGE = 0x809E, + SAMPLE_ALPHA_TO_ONE = 0x809F, + SAMPLE_COVERAGE = 0x80A0, + SAMPLE_BUFFERS = 0x80A8, + SAMPLES = 0x80A9, + SAMPLE_COVERAGE_VALUE = 0x80AA, + SAMPLE_COVERAGE_INVERT = 0x80AB, + TEXTURE_CUBE_MAP = 0x8513, + TEXTURE_BINDING_CUBE_MAP = 0x8514, + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515, + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516, + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517, + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518, + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519, + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A, + PROXY_TEXTURE_CUBE_MAP = 0x851B, + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C, + COMPRESSED_RGB = 0x84ED, + COMPRESSED_RGBA = 0x84EE, + TEXTURE_COMPRESSION_HINT = 0x84EF, + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0, + TEXTURE_COMPRESSED = 0x86A1, + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2, + COMPRESSED_TEXTURE_FORMATS = 0x86A3, + CLAMP_TO_BORDER = 0x812D, + + // Version: 1.4 + BLEND_DST_RGB = 0x80C8, + BLEND_SRC_RGB = 0x80C9, + BLEND_DST_ALPHA = 0x80CA, + BLEND_SRC_ALPHA = 0x80CB, + POINT_FADE_THRESHOLD_SIZE = 0x8128, + DEPTH_COMPONENT16 = 0x81A5, + DEPTH_COMPONENT24 = 0x81A6, + DEPTH_COMPONENT32 = 0x81A7, + MIRRORED_REPEAT = 0x8370, + MAX_TEXTURE_LOD_BIAS = 0x84FD, + TEXTURE_LOD_BIAS = 0x8501, + INCR_WRAP = 0x8507, + DECR_WRAP = 0x8508, + TEXTURE_DEPTH_SIZE = 0x884A, + TEXTURE_COMPARE_MODE = 0x884C, + TEXTURE_COMPARE_FUNC = 0x884D, + + // Version: 1.5 + BUFFER_SIZE = 0x8764, + BUFFER_USAGE = 0x8765, + QUERY_COUNTER_BITS = 0x8864, + CURRENT_QUERY = 0x8865, + QUERY_RESULT = 0x8866, + QUERY_RESULT_AVAILABLE = 0x8867, + ARRAY_BUFFER = 0x8892, + ELEMENT_ARRAY_BUFFER = 0x8893, + ARRAY_BUFFER_BINDING = 0x8894, + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895, + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F, + READ_ONLY = 0x88B8, + WRITE_ONLY = 0x88B9, + READ_WRITE = 0x88BA, + BUFFER_ACCESS = 0x88BB, + BUFFER_MAPPED = 0x88BC, + BUFFER_MAP_POINTER = 0x88BD, + STREAM_DRAW = 0x88E0, + STREAM_READ = 0x88E1, + STREAM_COPY = 0x88E2, + STATIC_DRAW = 0x88E4, + STATIC_READ = 0x88E5, + STATIC_COPY = 0x88E6, + DYNAMIC_DRAW = 0x88E8, + DYNAMIC_READ = 0x88E9, + DYNAMIC_COPY = 0x88EA, + SAMPLES_PASSED = 0x8914, + SRC1_ALPHA = 0x8589, + + // Version: 2.0 + BLEND_EQUATION_RGB = 0x8009, + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622, + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623, + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624, + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625, + CURRENT_VERTEX_ATTRIB = 0x8626, + VERTEX_PROGRAM_POINT_SIZE = 0x8642, + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645, + STENCIL_BACK_FUNC = 0x8800, + STENCIL_BACK_FAIL = 0x8801, + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802, + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803, + MAX_DRAW_BUFFERS = 0x8824, + DRAW_BUFFER0 = 0x8825, + DRAW_BUFFER1 = 0x8826, + DRAW_BUFFER2 = 0x8827, + DRAW_BUFFER3 = 0x8828, + DRAW_BUFFER4 = 0x8829, + DRAW_BUFFER5 = 0x882A, + DRAW_BUFFER6 = 0x882B, + DRAW_BUFFER7 = 0x882C, + DRAW_BUFFER8 = 0x882D, + DRAW_BUFFER9 = 0x882E, + DRAW_BUFFER10 = 0x882F, + DRAW_BUFFER11 = 0x8830, + DRAW_BUFFER12 = 0x8831, + DRAW_BUFFER13 = 0x8832, + DRAW_BUFFER14 = 0x8833, + DRAW_BUFFER15 = 0x8834, + BLEND_EQUATION_ALPHA = 0x883D, + MAX_VERTEX_ATTRIBS = 0x8869, + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A, + MAX_TEXTURE_IMAGE_UNITS = 0x8872, + FRAGMENT_SHADER = 0x8B30, + VERTEX_SHADER = 0x8B31, + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49, + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A, + MAX_VARYING_FLOATS = 0x8B4B, + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C, + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D, + SHADER_TYPE = 0x8B4F, + FLOAT_VEC2 = 0x8B50, + FLOAT_VEC3 = 0x8B51, + FLOAT_VEC4 = 0x8B52, + INT_VEC2 = 0x8B53, + INT_VEC3 = 0x8B54, + INT_VEC4 = 0x8B55, + BOOL = 0x8B56, + BOOL_VEC2 = 0x8B57, + BOOL_VEC3 = 0x8B58, + BOOL_VEC4 = 0x8B59, + FLOAT_MAT2 = 0x8B5A, + FLOAT_MAT3 = 0x8B5B, + FLOAT_MAT4 = 0x8B5C, + SAMPLER_1D = 0x8B5D, + SAMPLER_2D = 0x8B5E, + SAMPLER_3D = 0x8B5F, + SAMPLER_CUBE = 0x8B60, + SAMPLER_1D_SHADOW = 0x8B61, + SAMPLER_2D_SHADOW = 0x8B62, + DELETE_STATUS = 0x8B80, + COMPILE_STATUS = 0x8B81, + LINK_STATUS = 0x8B82, + VALIDATE_STATUS = 0x8B83, + INFO_LOG_LENGTH = 0x8B84, + ATTACHED_SHADERS = 0x8B85, + ACTIVE_UNIFORMS = 0x8B86, + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87, + SHADER_SOURCE_LENGTH = 0x8B88, + ACTIVE_ATTRIBUTES = 0x8B89, + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A, + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B, + SHADING_LANGUAGE_VERSION = 0x8B8C, + CURRENT_PROGRAM = 0x8B8D, + POINT_SPRITE_COORD_ORIGIN = 0x8CA0, + LOWER_LEFT = 0x8CA1, + UPPER_LEFT = 0x8CA2, + STENCIL_BACK_REF = 0x8CA3, + STENCIL_BACK_VALUE_MASK = 0x8CA4, + STENCIL_BACK_WRITEMASK = 0x8CA5, + + // Version: 2.1 + PIXEL_PACK_BUFFER = 0x88EB, + PIXEL_UNPACK_BUFFER = 0x88EC, + PIXEL_PACK_BUFFER_BINDING = 0x88ED, + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF, + FLOAT_MAT2x3 = 0x8B65, + FLOAT_MAT2x4 = 0x8B66, + FLOAT_MAT3x2 = 0x8B67, + FLOAT_MAT3x4 = 0x8B68, + FLOAT_MAT4x2 = 0x8B69, + FLOAT_MAT4x3 = 0x8B6A, + SRGB = 0x8C40, + SRGB8 = 0x8C41, + SRGB_ALPHA = 0x8C42, + SRGB8_ALPHA8 = 0x8C43, + COMPRESSED_SRGB = 0x8C48, + COMPRESSED_SRGB_ALPHA = 0x8C49, + + // Core Extension: ARB_vertex_array_object + VERTEX_ARRAY_BINDING = 0x85B5, + + // Core Extension: ARB_texture_rg + RG = 0x8227, + RG_INTEGER = 0x8228, + R8 = 0x8229, + R16 = 0x822A, + RG8 = 0x822B, + RG16 = 0x822C, + R16F = 0x822D, + R32F = 0x822E, + RG16F = 0x822F, + RG32F = 0x8230, + R8I = 0x8231, + R8UI = 0x8232, + R16I = 0x8233, + R16UI = 0x8234, + R32I = 0x8235, + R32UI = 0x8236, + RG8I = 0x8237, + RG8UI = 0x8238, + RG16I = 0x8239, + RG16UI = 0x823A, + RG32I = 0x823B, + RG32UI = 0x823C, + + // Core Extension: ARB_texture_compression_rgtc + COMPRESSED_RED_RGTC1 = 0x8DBB, + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC, + COMPRESSED_RG_RGTC2 = 0x8DBD, + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE, + + // Core Extension: ARB_map_buffer_range + MAP_READ_BIT = 0x0001, + MAP_WRITE_BIT = 0x0002, + MAP_INVALIDATE_RANGE_BIT = 0x0004, + MAP_INVALIDATE_BUFFER_BIT = 0x0008, + MAP_FLUSH_EXPLICIT_BIT = 0x0010, + MAP_UNSYNCHRONIZED_BIT = 0x0020, + + // Core Extension: ARB_half_float_vertex + HALF_FLOAT = 0x140B, + + // Core Extension: ARB_framebuffer_sRGB + FRAMEBUFFER_SRGB = 0x8DB9, + + // Core Extension: ARB_framebuffer_object + INVALID_FRAMEBUFFER_OPERATION = 0x0506, + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210, + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211, + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212, + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213, + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214, + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215, + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216, + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217, + FRAMEBUFFER_DEFAULT = 0x8218, + FRAMEBUFFER_UNDEFINED = 0x8219, + DEPTH_STENCIL_ATTACHMENT = 0x821A, + INDEX = 0x8222, + MAX_RENDERBUFFER_SIZE = 0x84E8, + DEPTH_STENCIL = 0x84F9, + UNSIGNED_INT_24_8 = 0x84FA, + DEPTH24_STENCIL8 = 0x88F0, + TEXTURE_STENCIL_SIZE = 0x88F1, + TEXTURE_RED_TYPE = 0x8C10, + TEXTURE_GREEN_TYPE = 0x8C11, + TEXTURE_BLUE_TYPE = 0x8C12, + TEXTURE_ALPHA_TYPE = 0x8C13, + TEXTURE_DEPTH_TYPE = 0x8C16, + UNSIGNED_NORMALIZED = 0x8C17, + FRAMEBUFFER_BINDING = 0x8CA6, + DRAW_FRAMEBUFFER_BINDING = 0x8CA6, + RENDERBUFFER_BINDING = 0x8CA7, + READ_FRAMEBUFFER = 0x8CA8, + DRAW_FRAMEBUFFER = 0x8CA9, + READ_FRAMEBUFFER_BINDING = 0x8CAA, + RENDERBUFFER_SAMPLES = 0x8CAB, + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0, + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1, + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2, + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3, + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4, + FRAMEBUFFER_COMPLETE = 0x8CD5, + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6, + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7, + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB, + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC, + FRAMEBUFFER_UNSUPPORTED = 0x8CDD, + MAX_COLOR_ATTACHMENTS = 0x8CDF, + COLOR_ATTACHMENT0 = 0x8CE0, + COLOR_ATTACHMENT1 = 0x8CE1, + COLOR_ATTACHMENT2 = 0x8CE2, + COLOR_ATTACHMENT3 = 0x8CE3, + COLOR_ATTACHMENT4 = 0x8CE4, + COLOR_ATTACHMENT5 = 0x8CE5, + COLOR_ATTACHMENT6 = 0x8CE6, + COLOR_ATTACHMENT7 = 0x8CE7, + COLOR_ATTACHMENT8 = 0x8CE8, + COLOR_ATTACHMENT9 = 0x8CE9, + COLOR_ATTACHMENT10 = 0x8CEA, + COLOR_ATTACHMENT11 = 0x8CEB, + COLOR_ATTACHMENT12 = 0x8CEC, + COLOR_ATTACHMENT13 = 0x8CED, + COLOR_ATTACHMENT14 = 0x8CEE, + COLOR_ATTACHMENT15 = 0x8CEF, + DEPTH_ATTACHMENT = 0x8D00, + STENCIL_ATTACHMENT = 0x8D20, + FRAMEBUFFER = 0x8D40, + RENDERBUFFER = 0x8D41, + RENDERBUFFER_WIDTH = 0x8D42, + RENDERBUFFER_HEIGHT = 0x8D43, + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44, + STENCIL_INDEX1 = 0x8D46, + STENCIL_INDEX4 = 0x8D47, + STENCIL_INDEX8 = 0x8D48, + STENCIL_INDEX16 = 0x8D49, + RENDERBUFFER_RED_SIZE = 0x8D50, + RENDERBUFFER_GREEN_SIZE = 0x8D51, + RENDERBUFFER_BLUE_SIZE = 0x8D52, + RENDERBUFFER_ALPHA_SIZE = 0x8D53, + RENDERBUFFER_DEPTH_SIZE = 0x8D54, + RENDERBUFFER_STENCIL_SIZE = 0x8D55, + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56, + MAX_SAMPLES = 0x8D57, + TEXTURE_LUMINANCE_TYPE = 0x8C14, + TEXTURE_INTENSITY_TYPE = 0x8C15, + + // Core Extension: ARB_depth_buffer_float + DEPTH_COMPONENT32F = 0x8CAC, + DEPTH32F_STENCIL8 = 0x8CAD, + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD, + + // Version: 3.0 + COMPARE_REF_TO_TEXTURE = 0x884E, + CLIP_DISTANCE0 = 0x3000, + CLIP_DISTANCE1 = 0x3001, + CLIP_DISTANCE2 = 0x3002, + CLIP_DISTANCE3 = 0x3003, + CLIP_DISTANCE4 = 0x3004, + CLIP_DISTANCE5 = 0x3005, + CLIP_DISTANCE6 = 0x3006, + CLIP_DISTANCE7 = 0x3007, + MAX_CLIP_DISTANCES = 0x0D32, + MAJOR_VERSION = 0x821B, + MINOR_VERSION = 0x821C, + NUM_EXTENSIONS = 0x821D, + CONTEXT_FLAGS = 0x821E, + COMPRESSED_RED = 0x8225, + COMPRESSED_RG = 0x8226, + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x0001, + RGBA32F = 0x8814, + RGB32F = 0x8815, + RGBA16F = 0x881A, + RGB16F = 0x881B, + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD, + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF, + MIN_PROGRAM_TEXEL_OFFSET = 0x8904, + MAX_PROGRAM_TEXEL_OFFSET = 0x8905, + CLAMP_READ_COLOR = 0x891C, + FIXED_ONLY = 0x891D, + TEXTURE_1D_ARRAY = 0x8C18, + PROXY_TEXTURE_1D_ARRAY = 0x8C19, + TEXTURE_2D_ARRAY = 0x8C1A, + PROXY_TEXTURE_2D_ARRAY = 0x8C1B, + TEXTURE_BINDING_1D_ARRAY = 0x8C1C, + TEXTURE_BINDING_2D_ARRAY = 0x8C1D, + R11F_G11F_B10F = 0x8C3A, + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B, + RGB9_E5 = 0x8C3D, + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E, + TEXTURE_SHARED_SIZE = 0x8C3F, + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76, + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F, + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80, + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83, + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84, + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85, + PRIMITIVES_GENERATED = 0x8C87, + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88, + RASTERIZER_DISCARD = 0x8C89, + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A, + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B, + INTERLEAVED_ATTRIBS = 0x8C8C, + SEPARATE_ATTRIBS = 0x8C8D, + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E, + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F, + RGBA32UI = 0x8D70, + RGB32UI = 0x8D71, + RGBA16UI = 0x8D76, + RGB16UI = 0x8D77, + RGBA8UI = 0x8D7C, + RGB8UI = 0x8D7D, + RGBA32I = 0x8D82, + RGB32I = 0x8D83, + RGBA16I = 0x8D88, + RGB16I = 0x8D89, + RGBA8I = 0x8D8E, + RGB8I = 0x8D8F, + RED_INTEGER = 0x8D94, + GREEN_INTEGER = 0x8D95, + BLUE_INTEGER = 0x8D96, + RGB_INTEGER = 0x8D98, + RGBA_INTEGER = 0x8D99, + BGR_INTEGER = 0x8D9A, + BGRA_INTEGER = 0x8D9B, + SAMPLER_1D_ARRAY = 0x8DC0, + SAMPLER_2D_ARRAY = 0x8DC1, + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3, + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4, + SAMPLER_CUBE_SHADOW = 0x8DC5, + UNSIGNED_INT_VEC2 = 0x8DC6, + UNSIGNED_INT_VEC3 = 0x8DC7, + UNSIGNED_INT_VEC4 = 0x8DC8, + INT_SAMPLER_1D = 0x8DC9, + INT_SAMPLER_2D = 0x8DCA, + INT_SAMPLER_3D = 0x8DCB, + INT_SAMPLER_CUBE = 0x8DCC, + INT_SAMPLER_1D_ARRAY = 0x8DCE, + INT_SAMPLER_2D_ARRAY = 0x8DCF, + UNSIGNED_INT_SAMPLER_1D = 0x8DD1, + UNSIGNED_INT_SAMPLER_2D = 0x8DD2, + UNSIGNED_INT_SAMPLER_3D = 0x8DD3, + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4, + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6, + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7, + QUERY_WAIT = 0x8E13, + QUERY_NO_WAIT = 0x8E14, + QUERY_BY_REGION_WAIT = 0x8E15, + QUERY_BY_REGION_NO_WAIT = 0x8E16, + BUFFER_ACCESS_FLAGS = 0x911F, + BUFFER_MAP_LENGTH = 0x9120, + BUFFER_MAP_OFFSET = 0x9121, + + // Core Extension: ARB_uniform_buffer_object + UNIFORM_BUFFER = 0x8A11, + UNIFORM_BUFFER_BINDING = 0x8A28, + UNIFORM_BUFFER_START = 0x8A29, + UNIFORM_BUFFER_SIZE = 0x8A2A, + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B, + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D, + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E, + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F, + MAX_UNIFORM_BLOCK_SIZE = 0x8A30, + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31, + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33, + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34, + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35, + ACTIVE_UNIFORM_BLOCKS = 0x8A36, + UNIFORM_TYPE = 0x8A37, + UNIFORM_SIZE = 0x8A38, + UNIFORM_NAME_LENGTH = 0x8A39, + UNIFORM_BLOCK_INDEX = 0x8A3A, + UNIFORM_OFFSET = 0x8A3B, + UNIFORM_ARRAY_STRIDE = 0x8A3C, + UNIFORM_MATRIX_STRIDE = 0x8A3D, + UNIFORM_IS_ROW_MAJOR = 0x8A3E, + UNIFORM_BLOCK_BINDING = 0x8A3F, + UNIFORM_BLOCK_DATA_SIZE = 0x8A40, + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41, + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42, + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43, + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44, + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46, + INVALID_INDEX = 0xFFFFFFFF, + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C, + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32, + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45, + + // Core Extension: ARB_copy_buffer + COPY_READ_BUFFER = 0x8F36, + COPY_WRITE_BUFFER = 0x8F37, + COPY_READ_BUFFER_BINDING = 0x8F36, + COPY_WRITE_BUFFER_BINDING = 0x8F37, + + // Version: 3.1 + SAMPLER_2D_RECT = 0x8B63, + SAMPLER_2D_RECT_SHADOW = 0x8B64, + SAMPLER_BUFFER = 0x8DC2, + INT_SAMPLER_2D_RECT = 0x8DCD, + INT_SAMPLER_BUFFER = 0x8DD0, + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5, + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8, + TEXTURE_BUFFER = 0x8C2A, + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B, + TEXTURE_BINDING_BUFFER = 0x8C2C, + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D, + TEXTURE_RECTANGLE = 0x84F5, + TEXTURE_BINDING_RECTANGLE = 0x84F6, + PROXY_TEXTURE_RECTANGLE = 0x84F7, + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8, + RED_SNORM = 0x8F90, + RG_SNORM = 0x8F91, + RGB_SNORM = 0x8F92, + RGBA_SNORM = 0x8F93, + R8_SNORM = 0x8F94, + RG8_SNORM = 0x8F95, + RGB8_SNORM = 0x8F96, + RGBA8_SNORM = 0x8F97, + R16_SNORM = 0x8F98, + RG16_SNORM = 0x8F99, + RGB16_SNORM = 0x8F9A, + RGBA16_SNORM = 0x8F9B, + SIGNED_NORMALIZED = 0x8F9C, + PRIMITIVE_RESTART = 0x8F9D, + PRIMITIVE_RESTART_INDEX = 0x8F9E, + + // Legacy + VERTEX_ARRAY = 0x8074, + NORMAL_ARRAY = 0x8075, + COLOR_ARRAY = 0x8076, + TEXTURE_COORD_ARRAY = 0x8078, + TEXTURE_ENV = 0x2300, + TEXTURE_ENV_MODE = 0x2200, + MODELVIEW = 0x1700, + PROJECTION = 0x1701, + LIGHTING = 0x0B50 + }; + + // Extension: 1.1 + extern void (CODEGEN_FUNCPTR *CullFace)(GLenum mode); + extern void (CODEGEN_FUNCPTR *FrontFace)(GLenum mode); + extern void (CODEGEN_FUNCPTR *Hint)(GLenum target, GLenum mode); + extern void (CODEGEN_FUNCPTR *LineWidth)(GLfloat width); + extern void (CODEGEN_FUNCPTR *PointSize)(GLfloat size); + extern void (CODEGEN_FUNCPTR *PolygonMode)(GLenum face, GLenum mode); + extern void (CODEGEN_FUNCPTR *Scissor)(GLint x, GLint y, GLsizei width, GLsizei height); + extern void (CODEGEN_FUNCPTR *TexParameterf)(GLenum target, GLenum pname, GLfloat param); + extern void (CODEGEN_FUNCPTR *TexParameterfv)(GLenum target, GLenum pname, const GLfloat *params); + extern void (CODEGEN_FUNCPTR *TexParameteri)(GLenum target, GLenum pname, GLint param); + extern void (CODEGEN_FUNCPTR *TexParameteriv)(GLenum target, GLenum pname, const GLint *params); + extern void (CODEGEN_FUNCPTR *TexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels); + extern void (CODEGEN_FUNCPTR *TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels); + extern void (CODEGEN_FUNCPTR *DrawBuffer)(GLenum mode); + extern void (CODEGEN_FUNCPTR *Clear)(GLbitfield mask); + extern void (CODEGEN_FUNCPTR *ClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + extern void (CODEGEN_FUNCPTR *ClearStencil)(GLint s); + extern void (CODEGEN_FUNCPTR *ClearDepth)(GLdouble depth); + extern void (CODEGEN_FUNCPTR *StencilMask)(GLuint mask); + extern void (CODEGEN_FUNCPTR *ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); + extern void (CODEGEN_FUNCPTR *DepthMask)(GLboolean flag); + extern void (CODEGEN_FUNCPTR *Disable)(GLenum cap); + extern void (CODEGEN_FUNCPTR *Enable)(GLenum cap); + extern void (CODEGEN_FUNCPTR *Finish)(); + extern void (CODEGEN_FUNCPTR *Flush)(); + extern void (CODEGEN_FUNCPTR *BlendFunc)(GLenum sfactor, GLenum dfactor); + extern void (CODEGEN_FUNCPTR *LogicOp)(GLenum opcode); + extern void (CODEGEN_FUNCPTR *StencilFunc)(GLenum func, GLint ref, GLuint mask); + extern void (CODEGEN_FUNCPTR *StencilOp)(GLenum fail, GLenum zfail, GLenum zpass); + extern void (CODEGEN_FUNCPTR *DepthFunc)(GLenum func); + extern void (CODEGEN_FUNCPTR *PixelStoref)(GLenum pname, GLfloat param); + extern void (CODEGEN_FUNCPTR *PixelStorei)(GLenum pname, GLint param); + extern void (CODEGEN_FUNCPTR *ReadBuffer)(GLenum mode); + extern void (CODEGEN_FUNCPTR *ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels); + extern void (CODEGEN_FUNCPTR *GetBooleanv)(GLenum pname, GLboolean *params); + extern void (CODEGEN_FUNCPTR *GetDoublev)(GLenum pname, GLdouble *params); + extern GLenum (CODEGEN_FUNCPTR *GetError)(); + extern void (CODEGEN_FUNCPTR *GetFloatv)(GLenum pname, GLfloat *params); + extern void (CODEGEN_FUNCPTR *GetIntegerv)(GLenum pname, GLint *params); + extern const GLubyte * (CODEGEN_FUNCPTR *GetString)(GLenum name); + extern void (CODEGEN_FUNCPTR *GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels); + extern void (CODEGEN_FUNCPTR *GetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params); + extern void (CODEGEN_FUNCPTR *GetTexParameteriv)(GLenum target, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params); + extern void (CODEGEN_FUNCPTR *GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params); + extern GLboolean (CODEGEN_FUNCPTR *IsEnabled)(GLenum cap); + extern void (CODEGEN_FUNCPTR *DepthRange)(GLdouble ren_near, GLdouble ren_far); + extern void (CODEGEN_FUNCPTR *Viewport)(GLint x, GLint y, GLsizei width, GLsizei height); + extern void (CODEGEN_FUNCPTR *DrawArrays)(GLenum mode, GLint first, GLsizei count); + extern void (CODEGEN_FUNCPTR *DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices); + extern void (CODEGEN_FUNCPTR *GetPointerv)(GLenum pname, GLvoid* *params); + extern void (CODEGEN_FUNCPTR *PolygonOffset)(GLfloat factor, GLfloat units); + extern void (CODEGEN_FUNCPTR *CopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); + extern void (CODEGEN_FUNCPTR *CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); + extern void (CODEGEN_FUNCPTR *CopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); + extern void (CODEGEN_FUNCPTR *CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); + extern void (CODEGEN_FUNCPTR *TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels); + extern void (CODEGEN_FUNCPTR *TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); + extern void (CODEGEN_FUNCPTR *BindTexture)(GLenum target, GLuint texture); + extern void (CODEGEN_FUNCPTR *DeleteTextures)(GLsizei n, const GLuint *textures); + extern void (CODEGEN_FUNCPTR *GenTextures)(GLsizei n, GLuint *textures); + extern GLboolean (CODEGEN_FUNCPTR *IsTexture)(GLuint texture); + extern void (CODEGEN_FUNCPTR *Indexub)(GLubyte c); + extern void (CODEGEN_FUNCPTR *Indexubv)(const GLubyte *c); + + // Extension: 1.2 + extern void (CODEGEN_FUNCPTR *BlendColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + extern void (CODEGEN_FUNCPTR *BlendEquation)(GLenum mode); + extern void (CODEGEN_FUNCPTR *DrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices); + extern void (CODEGEN_FUNCPTR *TexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels); + extern void (CODEGEN_FUNCPTR *CopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); + + // Extension: 1.3 + extern void (CODEGEN_FUNCPTR *ActiveTexture)(GLenum texture); + extern void (CODEGEN_FUNCPTR *SampleCoverage)(GLfloat value, GLboolean invert); + extern void (CODEGEN_FUNCPTR *CompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data); + extern void (CODEGEN_FUNCPTR *CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data); + extern void (CODEGEN_FUNCPTR *CompressedTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data); + extern void (CODEGEN_FUNCPTR *CompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data); + extern void (CODEGEN_FUNCPTR *CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data); + extern void (CODEGEN_FUNCPTR *CompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data); + extern void (CODEGEN_FUNCPTR *GetCompressedTexImage)(GLenum target, GLint level, GLvoid *img); + + // Extension: 1.4 + extern void (CODEGEN_FUNCPTR *BlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); + extern void (CODEGEN_FUNCPTR *MultiDrawArrays)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); + extern void (CODEGEN_FUNCPTR *MultiDrawElements)(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount); + extern void (CODEGEN_FUNCPTR *PointParameterf)(GLenum pname, GLfloat param); + extern void (CODEGEN_FUNCPTR *PointParameterfv)(GLenum pname, const GLfloat *params); + extern void (CODEGEN_FUNCPTR *PointParameteri)(GLenum pname, GLint param); + extern void (CODEGEN_FUNCPTR *PointParameteriv)(GLenum pname, const GLint *params); + + // Extension: 1.5 + extern void (CODEGEN_FUNCPTR *GenQueries)(GLsizei n, GLuint *ids); + extern void (CODEGEN_FUNCPTR *DeleteQueries)(GLsizei n, const GLuint *ids); + extern GLboolean (CODEGEN_FUNCPTR *IsQuery)(GLuint id); + extern void (CODEGEN_FUNCPTR *BeginQuery)(GLenum target, GLuint id); + extern void (CODEGEN_FUNCPTR *EndQuery)(GLenum target); + extern void (CODEGEN_FUNCPTR *GetQueryiv)(GLenum target, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetQueryObjectiv)(GLuint id, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params); + extern void (CODEGEN_FUNCPTR *BindBuffer)(GLenum target, GLuint buffer); + extern void (CODEGEN_FUNCPTR *DeleteBuffers)(GLsizei n, const GLuint *buffers); + extern void (CODEGEN_FUNCPTR *GenBuffers)(GLsizei n, GLuint *buffers); + extern GLboolean (CODEGEN_FUNCPTR *IsBuffer)(GLuint buffer); + extern void (CODEGEN_FUNCPTR *BufferData)(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage); + extern void (CODEGEN_FUNCPTR *BufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data); + extern void (CODEGEN_FUNCPTR *GetBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data); + extern GLvoid* (CODEGEN_FUNCPTR *MapBuffer)(GLenum target, GLenum access); + extern GLboolean (CODEGEN_FUNCPTR *UnmapBuffer)(GLenum target); + extern void (CODEGEN_FUNCPTR *GetBufferParameteriv)(GLenum target, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetBufferPointerv)(GLenum target, GLenum pname, GLvoid* *params); + + // Extension: 2.0 + extern void (CODEGEN_FUNCPTR *BlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha); + extern void (CODEGEN_FUNCPTR *DrawBuffers)(GLsizei n, const GLenum *bufs); + extern void (CODEGEN_FUNCPTR *StencilOpSeparate)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); + extern void (CODEGEN_FUNCPTR *StencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask); + extern void (CODEGEN_FUNCPTR *StencilMaskSeparate)(GLenum face, GLuint mask); + extern void (CODEGEN_FUNCPTR *AttachShader)(GLuint program, GLuint shader); + extern void (CODEGEN_FUNCPTR *BindAttribLocation)(GLuint program, GLuint index, const GLchar *name); + extern void (CODEGEN_FUNCPTR *CompileShader)(GLuint shader); + extern GLuint (CODEGEN_FUNCPTR *CreateProgram)(); + extern GLuint (CODEGEN_FUNCPTR *CreateShader)(GLenum type); + extern void (CODEGEN_FUNCPTR *DeleteProgram)(GLuint program); + extern void (CODEGEN_FUNCPTR *DeleteShader)(GLuint shader); + extern void (CODEGEN_FUNCPTR *DetachShader)(GLuint program, GLuint shader); + extern void (CODEGEN_FUNCPTR *DisableVertexAttribArray)(GLuint index); + extern void (CODEGEN_FUNCPTR *EnableVertexAttribArray)(GLuint index); + extern void (CODEGEN_FUNCPTR *GetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); + extern void (CODEGEN_FUNCPTR *GetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); + extern void (CODEGEN_FUNCPTR *GetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj); + extern GLint (CODEGEN_FUNCPTR *GetAttribLocation)(GLuint program, const GLchar *name); + extern void (CODEGEN_FUNCPTR *GetProgramiv)(GLuint program, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); + extern void (CODEGEN_FUNCPTR *GetShaderiv)(GLuint shader, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); + extern void (CODEGEN_FUNCPTR *GetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); + extern GLint (CODEGEN_FUNCPTR *GetUniformLocation)(GLuint program, const GLchar *name); + extern void (CODEGEN_FUNCPTR *GetUniformfv)(GLuint program, GLint location, GLfloat *params); + extern void (CODEGEN_FUNCPTR *GetUniformiv)(GLuint program, GLint location, GLint *params); + extern void (CODEGEN_FUNCPTR *GetVertexAttribdv)(GLuint index, GLenum pname, GLdouble *params); + extern void (CODEGEN_FUNCPTR *GetVertexAttribfv)(GLuint index, GLenum pname, GLfloat *params); + extern void (CODEGEN_FUNCPTR *GetVertexAttribiv)(GLuint index, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetVertexAttribPointerv)(GLuint index, GLenum pname, GLvoid* *pointer); + extern GLboolean (CODEGEN_FUNCPTR *IsProgram)(GLuint program); + extern GLboolean (CODEGEN_FUNCPTR *IsShader)(GLuint shader); + extern void (CODEGEN_FUNCPTR *LinkProgram)(GLuint program); + extern void (CODEGEN_FUNCPTR *ShaderSource)(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length); + extern void (CODEGEN_FUNCPTR *UseProgram)(GLuint program); + extern void (CODEGEN_FUNCPTR *Uniform1f)(GLint location, GLfloat v0); + extern void (CODEGEN_FUNCPTR *Uniform2f)(GLint location, GLfloat v0, GLfloat v1); + extern void (CODEGEN_FUNCPTR *Uniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); + extern void (CODEGEN_FUNCPTR *Uniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); + extern void (CODEGEN_FUNCPTR *Uniform1i)(GLint location, GLint v0); + extern void (CODEGEN_FUNCPTR *Uniform2i)(GLint location, GLint v0, GLint v1); + extern void (CODEGEN_FUNCPTR *Uniform3i)(GLint location, GLint v0, GLint v1, GLint v2); + extern void (CODEGEN_FUNCPTR *Uniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); + extern void (CODEGEN_FUNCPTR *Uniform1fv)(GLint location, GLsizei count, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *Uniform2fv)(GLint location, GLsizei count, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *Uniform3fv)(GLint location, GLsizei count, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *Uniform4fv)(GLint location, GLsizei count, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *Uniform1iv)(GLint location, GLsizei count, const GLint *value); + extern void (CODEGEN_FUNCPTR *Uniform2iv)(GLint location, GLsizei count, const GLint *value); + extern void (CODEGEN_FUNCPTR *Uniform3iv)(GLint location, GLsizei count, const GLint *value); + extern void (CODEGEN_FUNCPTR *Uniform4iv)(GLint location, GLsizei count, const GLint *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *ValidateProgram)(GLuint program); + extern void (CODEGEN_FUNCPTR *VertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer); + + // Extension: 2.1 + extern void (CODEGEN_FUNCPTR *UniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + + // Extension: ARB_vertex_array_object + extern void (CODEGEN_FUNCPTR *BindVertexArray)(GLuint ren_array); + extern void (CODEGEN_FUNCPTR *DeleteVertexArrays)(GLsizei n, const GLuint *arrays); + extern void (CODEGEN_FUNCPTR *GenVertexArrays)(GLsizei n, GLuint *arrays); + extern GLboolean (CODEGEN_FUNCPTR *IsVertexArray)(GLuint ren_array); + + // Extension: ARB_map_buffer_range + extern GLvoid* (CODEGEN_FUNCPTR *MapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); + extern void (CODEGEN_FUNCPTR *FlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length); + + // Extension: ARB_framebuffer_object + extern GLboolean (CODEGEN_FUNCPTR *IsRenderbuffer)(GLuint renderbuffer); + extern void (CODEGEN_FUNCPTR *BindRenderbuffer)(GLenum target, GLuint renderbuffer); + extern void (CODEGEN_FUNCPTR *DeleteRenderbuffers)(GLsizei n, const GLuint *renderbuffers); + extern void (CODEGEN_FUNCPTR *GenRenderbuffers)(GLsizei n, GLuint *renderbuffers); + extern void (CODEGEN_FUNCPTR *RenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); + extern void (CODEGEN_FUNCPTR *GetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint *params); + extern GLboolean (CODEGEN_FUNCPTR *IsFramebuffer)(GLuint framebuffer); + extern void (CODEGEN_FUNCPTR *BindFramebuffer)(GLenum target, GLuint framebuffer); + extern void (CODEGEN_FUNCPTR *DeleteFramebuffers)(GLsizei n, const GLuint *framebuffers); + extern void (CODEGEN_FUNCPTR *GenFramebuffers)(GLsizei n, GLuint *framebuffers); + extern GLenum (CODEGEN_FUNCPTR *CheckFramebufferStatus)(GLenum target); + extern void (CODEGEN_FUNCPTR *FramebufferTexture1D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); + extern void (CODEGEN_FUNCPTR *FramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); + extern void (CODEGEN_FUNCPTR *FramebufferTexture3D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); + extern void (CODEGEN_FUNCPTR *FramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); + extern void (CODEGEN_FUNCPTR *GetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GenerateMipmap)(GLenum target); + extern void (CODEGEN_FUNCPTR *BlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); + extern void (CODEGEN_FUNCPTR *RenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); + extern void (CODEGEN_FUNCPTR *FramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); + + // Extension: 3.0 + extern void (CODEGEN_FUNCPTR *ColorMaski)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); + extern void (CODEGEN_FUNCPTR *GetBooleani_v)(GLenum target, GLuint index, GLboolean *data); + extern void (CODEGEN_FUNCPTR *GetIntegeri_v)(GLenum target, GLuint index, GLint *data); + extern void (CODEGEN_FUNCPTR *Enablei)(GLenum target, GLuint index); + extern void (CODEGEN_FUNCPTR *Disablei)(GLenum target, GLuint index); + extern GLboolean (CODEGEN_FUNCPTR *IsEnabledi)(GLenum target, GLuint index); + extern void (CODEGEN_FUNCPTR *BeginTransformFeedback)(GLenum primitiveMode); + extern void (CODEGEN_FUNCPTR *EndTransformFeedback)(); + extern void (CODEGEN_FUNCPTR *BindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); + extern void (CODEGEN_FUNCPTR *BindBufferBase)(GLenum target, GLuint index, GLuint buffer); + extern void (CODEGEN_FUNCPTR *TransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode); + extern void (CODEGEN_FUNCPTR *GetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); + extern void (CODEGEN_FUNCPTR *ClampColor)(GLenum target, GLenum clamp); + extern void (CODEGEN_FUNCPTR *BeginConditionalRender)(GLuint id, GLenum mode); + extern void (CODEGEN_FUNCPTR *EndConditionalRender)(); + extern void (CODEGEN_FUNCPTR *VertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); + extern void (CODEGEN_FUNCPTR *GetVertexAttribIiv)(GLuint index, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint *params); + extern void (CODEGEN_FUNCPTR *VertexAttribI1i)(GLuint index, GLint x); + extern void (CODEGEN_FUNCPTR *VertexAttribI2i)(GLuint index, GLint x, GLint y); + extern void (CODEGEN_FUNCPTR *VertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z); + extern void (CODEGEN_FUNCPTR *VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w); + extern void (CODEGEN_FUNCPTR *VertexAttribI1ui)(GLuint index, GLuint x); + extern void (CODEGEN_FUNCPTR *VertexAttribI2ui)(GLuint index, GLuint x, GLuint y); + extern void (CODEGEN_FUNCPTR *VertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z); + extern void (CODEGEN_FUNCPTR *VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); + extern void (CODEGEN_FUNCPTR *VertexAttribI1iv)(GLuint index, const GLint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI2iv)(GLuint index, const GLint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI3iv)(GLuint index, const GLint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI4iv)(GLuint index, const GLint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI1uiv)(GLuint index, const GLuint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI2uiv)(GLuint index, const GLuint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI3uiv)(GLuint index, const GLuint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI4uiv)(GLuint index, const GLuint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI4bv)(GLuint index, const GLbyte *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI4sv)(GLuint index, const GLshort *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI4ubv)(GLuint index, const GLubyte *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI4usv)(GLuint index, const GLushort *v); + extern void (CODEGEN_FUNCPTR *GetUniformuiv)(GLuint program, GLint location, GLuint *params); + extern void (CODEGEN_FUNCPTR *BindFragDataLocation)(GLuint program, GLuint color, const GLchar *name); + extern GLint (CODEGEN_FUNCPTR *GetFragDataLocation)(GLuint program, const GLchar *name); + extern void (CODEGEN_FUNCPTR *Uniform1ui)(GLint location, GLuint v0); + extern void (CODEGEN_FUNCPTR *Uniform2ui)(GLint location, GLuint v0, GLuint v1); + extern void (CODEGEN_FUNCPTR *Uniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2); + extern void (CODEGEN_FUNCPTR *Uniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); + extern void (CODEGEN_FUNCPTR *Uniform1uiv)(GLint location, GLsizei count, const GLuint *value); + extern void (CODEGEN_FUNCPTR *Uniform2uiv)(GLint location, GLsizei count, const GLuint *value); + extern void (CODEGEN_FUNCPTR *Uniform3uiv)(GLint location, GLsizei count, const GLuint *value); + extern void (CODEGEN_FUNCPTR *Uniform4uiv)(GLint location, GLsizei count, const GLuint *value); + extern void (CODEGEN_FUNCPTR *TexParameterIiv)(GLenum target, GLenum pname, const GLint *params); + extern void (CODEGEN_FUNCPTR *TexParameterIuiv)(GLenum target, GLenum pname, const GLuint *params); + extern void (CODEGEN_FUNCPTR *GetTexParameterIiv)(GLenum target, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetTexParameterIuiv)(GLenum target, GLenum pname, GLuint *params); + extern void (CODEGEN_FUNCPTR *ClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint *value); + extern void (CODEGEN_FUNCPTR *ClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint *value); + extern void (CODEGEN_FUNCPTR *ClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *ClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); + extern const GLubyte * (CODEGEN_FUNCPTR *GetStringi)(GLenum name, GLuint index); + + // Extension: ARB_uniform_buffer_object + extern void (CODEGEN_FUNCPTR *GetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices); + extern void (CODEGEN_FUNCPTR *GetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetActiveUniformName)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); + extern GLuint (CODEGEN_FUNCPTR *GetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName); + extern void (CODEGEN_FUNCPTR *GetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); + extern void (CODEGEN_FUNCPTR *UniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); + + // Extension: ARB_copy_buffer + extern void (CODEGEN_FUNCPTR *CopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); + + // Extension: 3.1 + extern void (CODEGEN_FUNCPTR *DrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); + extern void (CODEGEN_FUNCPTR *DrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount); + extern void (CODEGEN_FUNCPTR *TexBuffer)(GLenum target, GLenum internalformat, GLuint buffer); + extern void (CODEGEN_FUNCPTR *PrimitiveRestartIndex)(GLuint index); + + // Legacy + extern void (CODEGEN_FUNCPTR *EnableClientState)(GLenum cap); + extern void (CODEGEN_FUNCPTR *DisableClientState)(GLenum cap); + extern void (CODEGEN_FUNCPTR *VertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr); + extern void (CODEGEN_FUNCPTR *NormalPointer)(GLenum type, GLsizei stride, const GLvoid *ptr); + extern void (CODEGEN_FUNCPTR *ColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr); + extern void (CODEGEN_FUNCPTR *TexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr); + extern void (CODEGEN_FUNCPTR *TexEnvi)(GLenum target, GLenum pname, GLint param); + extern void (CODEGEN_FUNCPTR *MatrixMode)(GLenum mode); + extern void (CODEGEN_FUNCPTR *LoadIdentity)(void); + extern void (CODEGEN_FUNCPTR *Ortho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val); + extern void (CODEGEN_FUNCPTR *Color3d)(GLdouble red, GLdouble green, GLdouble blue); +} + +#endif // OPENGL_NOLOAD_STYLE_HPP diff --git a/modules/core/src/matrix.cpp b/modules/core/src/matrix.cpp index 6c265f6c6f..ca2372d3ee 100644 --- a/modules/core/src/matrix.cpp +++ b/modules/core/src/matrix.cpp @@ -925,8 +925,8 @@ _InputArray::_InputArray(const Mat& m) : flags(MAT), obj((void*)&m) {} _InputArray::_InputArray(const vector& 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) {} +_InputArray::_InputArray(const GlBuffer& buf) : flags(OPENGL_BUFFER), obj((void*)&buf) {} +_InputArray::_InputArray(const GlTexture& tex) : flags(OPENGL_TEXTURE), obj((void*)&tex) {} _InputArray::_InputArray(const gpu::GpuMat& d_mat) : flags(GPU_MAT), obj((void*)&d_mat) {} Mat _InputArray::getMat(int i) const @@ -1237,9 +1237,6 @@ int _InputArray::type(int i) const if( k == OPENGL_BUFFER ) return ((const GlBuffer*)obj)->type(); - if( k == OPENGL_TEXTURE ) - return ((const GlTexture*)obj)->type(); - CV_Assert( k == GPU_MAT ); //if( k == GPU_MAT ) return ((const gpu::GpuMat*)obj)->type(); @@ -1308,10 +1305,14 @@ _OutputArray::~_OutputArray() {} _OutputArray::_OutputArray(Mat& m) : _InputArray(m) {} _OutputArray::_OutputArray(vector& vec) : _InputArray(vec) {} _OutputArray::_OutputArray(gpu::GpuMat& d_mat) : _InputArray(d_mat) {} +_OutputArray::_OutputArray(GlBuffer& buf) : _InputArray(buf) {} +_OutputArray::_OutputArray(GlTexture& tex) : _InputArray(tex) {} _OutputArray::_OutputArray(const Mat& m) : _InputArray(m) {flags |= FIXED_SIZE|FIXED_TYPE;} _OutputArray::_OutputArray(const vector& vec) : _InputArray(vec) {flags |= FIXED_SIZE;} _OutputArray::_OutputArray(const gpu::GpuMat& d_mat) : _InputArray(d_mat) {flags |= FIXED_SIZE|FIXED_TYPE;} +_OutputArray::_OutputArray(const GlBuffer& buf) : _InputArray(buf) {flags |= FIXED_SIZE|FIXED_TYPE;} +_OutputArray::_OutputArray(const GlTexture& tex) : _InputArray(tex) {flags |= FIXED_SIZE|FIXED_TYPE;} bool _OutputArray::fixedSize() const @@ -1341,6 +1342,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() || ((GlBuffer*)obj)->size() == _sz); + CV_Assert(!fixedType() || ((GlBuffer*)obj)->type() == mtype); + ((GlBuffer*)obj)->create(_sz, mtype); + return; + } int sizes[] = {_sz.height, _sz.width}; create(2, sizes, mtype, i, allowTransposed, fixedDepthMask); } @@ -1362,6 +1370,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() || ((GlBuffer*)obj)->size() == Size(cols, rows)); + CV_Assert(!fixedType() || ((GlBuffer*)obj)->type() == mtype); + ((GlBuffer*)obj)->create(rows, cols, mtype); + return; + } int sizes[] = {rows, cols}; create(2, sizes, mtype, i, allowTransposed, fixedDepthMask); } @@ -1581,6 +1596,18 @@ void _OutputArray::release() const return; } + if( k == OPENGL_BUFFER ) + { + ((GlBuffer*)obj)->release(); + return; + } + + if( k == OPENGL_TEXTURE ) + { + ((GlTexture*)obj)->release(); + return; + } + if( k == NONE ) return; @@ -1646,6 +1673,20 @@ gpu::GpuMat& _OutputArray::getGpuMatRef() const return *(gpu::GpuMat*)obj; } +GlBuffer& _OutputArray::getGlBufferRef() const +{ + int k = kind(); + CV_Assert( k == OPENGL_BUFFER ); + return *(GlBuffer*)obj; +} + +GlTexture& _OutputArray::getGlTextureRef() const +{ + int k = kind(); + CV_Assert( k == OPENGL_TEXTURE ); + return *(GlTexture*)obj; +} + static _OutputArray _none; OutputArray noArray() { return _none; } diff --git a/modules/core/src/opengl_interop.cpp b/modules/core/src/opengl_interop.cpp index 3cbec2c01a..0ef06afcb5 100644 --- a/modules/core/src/opengl_interop.cpp +++ b/modules/core/src/opengl_interop.cpp @@ -41,26 +41,11 @@ //M*/ #include "precomp.hpp" -#include #include "opencv2/core/opengl_interop.hpp" #include "opencv2/core/gpumat.hpp" -#if defined WIN32 || defined _WIN32 || defined WINCE -#include -#undef small -#undef min -#undef max -#undef abs -#endif - #ifdef HAVE_OPENGL - #ifdef __APPLE__ - #include - #include - #else - #include - #include - #endif + #include "gl_core_3_1.hpp" #ifdef HAVE_CUDA #include @@ -72,213 +57,258 @@ using namespace std; using namespace cv; using namespace cv::gpu; -#ifndef HAVE_OPENGL - #define throw_nogl CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support") - #define throw_nocuda CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support") -#else - #define throw_nogl CV_Error(CV_OpenGlNotSupported, "OpenGL context doesn't exist") - - #if !defined HAVE_CUDA || defined(CUDA_DISABLER) - #define throw_nocuda CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support") +namespace +{ + #ifndef HAVE_OPENGL + void throw_nogl() { CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); } #else - #if defined(__GNUC__) - #define cudaSafeCall(expr) ___cudaSafeCall(expr, __FILE__, __LINE__, __func__) - #else /* defined(__CUDACC__) || defined(__MSVC__) */ - #define cudaSafeCall(expr) ___cudaSafeCall(expr, __FILE__, __LINE__) - #endif + void throw_nogl() { CV_Error(CV_OpenGlApiCallError, "OpenGL context doesn't exist"); } - namespace - { - inline void ___cudaSafeCall(cudaError_t err, const char *file, const int line, const char *func = "") + #ifndef HAVE_CUDA + void throw_nocuda() { CV_Error(CV_GpuNotSupported, "The library is compiled without GPU support"); } + #else + void throw_nocuda() { CV_Error(CV_StsNotImplemented, "The called functionality is disabled for current build or platform"); } + + #if defined(__GNUC__) + #define cudaSafeCall(expr) ___cudaSafeCall(expr, __FILE__, __LINE__, __func__) + #else /* defined(__CUDACC__) || defined(__MSVC__) */ + #define cudaSafeCall(expr) ___cudaSafeCall(expr, __FILE__, __LINE__) + #endif + + void ___cudaSafeCall(cudaError_t err, const char* file, const int line, const char* func = "") { if (cudaSuccess != err) cv::gpu::error(cudaGetErrorString(err), file, line, func); } - } - #endif // HAVE_CUDA -#endif + #endif + #endif +} -namespace +bool cv::checkGlError(const char* file, const int line, const char* func) { - class EmptyGlFuncTab : public CvOpenGlFuncTab +#ifndef HAVE_OPENGL + (void) file; + (void) line; + (void) func; + return true; +#else + GLenum err = gl::GetError(); + + if (err != gl::NO_ERROR_) { - public: - void genBuffers(int, unsigned int*) const { throw_nogl; } - void deleteBuffers(int, const unsigned int*) const { throw_nogl; } + const char* msg; - void bufferData(unsigned int, ptrdiff_t, const void*, unsigned int) const { throw_nogl; } - void bufferSubData(unsigned int, ptrdiff_t, ptrdiff_t, const void*) const { throw_nogl; } + switch (err) + { + case gl::INVALID_ENUM: + msg = "An unacceptable value is specified for an enumerated argument"; + break; - void bindBuffer(unsigned int, unsigned int) const { throw_nogl; } + case gl::INVALID_VALUE: + msg = "A numeric argument is out of range"; + break; - void* mapBuffer(unsigned int, unsigned int) const { throw_nogl; return 0; } - void unmapBuffer(unsigned int) const { throw_nogl; } + case gl::INVALID_OPERATION: + msg = "The specified operation is not allowed in the current state"; + break; - void generateBitmapFont(const std::string&, int, int, bool, bool, int, int, int) const { throw_nogl; } + case gl::OUT_OF_MEMORY: + msg = "There is not enough memory left to execute the command"; + break; - bool isGlContextInitialized() const { return false; } - }; + default: + msg = "Unknown error"; + }; - const CvOpenGlFuncTab* g_glFuncTab = 0; + cvError(CV_OpenGlApiCallError, func, msg, file, line); -#if defined HAVE_CUDA || defined HAVE_OPENGL - const CvOpenGlFuncTab* glFuncTab() - { - static EmptyGlFuncTab empty; - return g_glFuncTab ? g_glFuncTab : ∅ + return false; } + + return true; #endif } -CvOpenGlFuncTab::~CvOpenGlFuncTab() -{ - if (g_glFuncTab == this) - g_glFuncTab = 0; -} - -void icvSetOpenGlFuncTab(const CvOpenGlFuncTab* tab) -{ - g_glFuncTab = tab; -} - #ifdef HAVE_OPENGL - #ifndef GL_DYNAMIC_DRAW - #define GL_DYNAMIC_DRAW 0x88E8 - #endif +namespace +{ + const GLenum gl_types[] = { gl::UNSIGNED_BYTE, gl::BYTE, gl::UNSIGNED_SHORT, gl::SHORT, gl::INT, gl::FLOAT, gl::DOUBLE }; +} +#endif - #ifndef GL_READ_WRITE - #define GL_READ_WRITE 0x88BA - #endif - - #ifndef GL_BGR - #define GL_BGR 0x80E0 - #endif - - #ifndef GL_BGRA - #define GL_BGRA 0x80E1 - #endif - - namespace - { - const GLenum gl_types[] = {GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_INT, GL_FLOAT, GL_DOUBLE}; - - #ifdef HAVE_CUDA - bool g_isCudaGlDeviceInitialized = false; - #endif - } -#endif // HAVE_OPENGL +//////////////////////////////////////////////////////////////////////// +// setGlDevice void cv::gpu::setGlDevice(int device) { -#if !defined HAVE_CUDA || defined(CUDA_DISABLER) - (void)device; - throw_nocuda; +#ifndef HAVE_OPENGL + (void) device; + throw_nogl(); #else - #ifndef HAVE_OPENGL - (void)device; - throw_nogl; + #if !defined(HAVE_CUDA) || defined(CUDA_DISABLER) + (void) device; + throw_nocuda(); #else - if (!glFuncTab()->isGlContextInitialized()) - throw_nogl; - cudaSafeCall( cudaGLSetGLDevice(device) ); - - g_isCudaGlDeviceInitialized = true; #endif #endif } //////////////////////////////////////////////////////////////////////// -// CudaGlInterop +// CudaResource + +#if defined(HAVE_OPENGL) && defined(HAVE_CUDA) && !defined(CUDA_DISABLER) -#if defined HAVE_CUDA && defined HAVE_OPENGL namespace { - class CudaGlInterop + class CudaResource { public: - CudaGlInterop(); - ~CudaGlInterop(); + CudaResource(); + ~CudaResource(); - void registerBuffer(unsigned int buffer); + void registerBuffer(GLuint buffer); + void release(); - void copyFrom(const GpuMat& mat, cudaStream_t stream = 0); + void copyFrom(const void* src, size_t spitch, size_t width, size_t height, cudaStream_t stream = 0); + void copyTo(void* dst, size_t dpitch, size_t width, size_t height, cudaStream_t stream = 0); - GpuMat map(int rows, int cols, int type, cudaStream_t stream = 0); + void* map(cudaStream_t stream = 0); void unmap(cudaStream_t stream = 0); private: cudaGraphicsResource_t resource_; + GLuint buffer_; + + class GraphicsMapHolder; }; - inline CudaGlInterop::CudaGlInterop() : resource_(0) + CudaResource::CudaResource() : resource_(0), buffer_(0) { } - CudaGlInterop::~CudaGlInterop() + CudaResource::~CudaResource() { - if (resource_) - { - cudaGraphicsUnregisterResource(resource_); - resource_ = 0; - } + release(); } - void CudaGlInterop::registerBuffer(unsigned int buffer) + void CudaResource::registerBuffer(GLuint buffer) { - if (!g_isCudaGlDeviceInitialized) - cvError(CV_GpuApiCallError, "registerBuffer", "cuda GL device wasn't initialized, call setGlDevice", __FILE__, __LINE__); + CV_DbgAssert( buffer != 0 ); + + if (buffer_ == buffer) + return; cudaGraphicsResource_t resource; cudaSafeCall( cudaGraphicsGLRegisterBuffer(&resource, buffer, cudaGraphicsMapFlagsNone) ); + release(); + resource_ = resource; + buffer_ = buffer; } - void CudaGlInterop::copyFrom(const GpuMat& mat, cudaStream_t stream) + void CudaResource::release() { - CV_Assert(resource_ != 0); + if (resource_) + cudaGraphicsUnregisterResource(resource_); - cudaSafeCall( cudaGraphicsMapResources(1, &resource_, stream) ); + resource_ = 0; + buffer_ = 0; + } - void* dst_ptr; - size_t num_bytes; - cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&dst_ptr, &num_bytes, resource_) ); + class CudaResource::GraphicsMapHolder + { + public: + GraphicsMapHolder(cudaGraphicsResource_t* resource, cudaStream_t stream); + ~GraphicsMapHolder(); - const void* src_ptr = mat.ptr(); - size_t widthBytes = mat.cols * mat.elemSize(); + void reset(); - CV_Assert(widthBytes * mat.rows <= num_bytes); + private: + cudaGraphicsResource_t* resource_; + cudaStream_t stream_; + }; + + CudaResource::GraphicsMapHolder::GraphicsMapHolder(cudaGraphicsResource_t* resource, cudaStream_t stream) : resource_(resource), stream_(stream) + { + if (resource_) + cudaSafeCall( cudaGraphicsMapResources(1, resource_, stream_) ); + } + + CudaResource::GraphicsMapHolder::~GraphicsMapHolder() + { + if (resource_) + cudaGraphicsUnmapResources(1, resource_, stream_); + } + + void CudaResource::GraphicsMapHolder::reset() + { + resource_ = 0; + } + + void CudaResource::copyFrom(const void* src, size_t spitch, size_t width, size_t height, cudaStream_t stream) + { + CV_DbgAssert( resource_ != 0 ); + + GraphicsMapHolder h(&resource_, stream); + (void) h; + + void* dst; + size_t size; + cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&dst, &size, resource_) ); + + CV_DbgAssert( width * height == size ); if (stream == 0) - cudaSafeCall( cudaMemcpy2D(dst_ptr, widthBytes, src_ptr, mat.step, widthBytes, mat.rows, cudaMemcpyDeviceToDevice) ); + cudaSafeCall( cudaMemcpy2D(dst, width, src, spitch, width, height, cudaMemcpyDeviceToDevice) ); else - cudaSafeCall( cudaMemcpy2DAsync(dst_ptr, widthBytes, src_ptr, mat.step, widthBytes, mat.rows, cudaMemcpyDeviceToDevice, stream) ); - - cudaGraphicsUnmapResources(1, &resource_, stream); + cudaSafeCall( cudaMemcpy2DAsync(dst, width, src, spitch, width, height, cudaMemcpyDeviceToDevice, stream) ); } - GpuMat CudaGlInterop::map(int rows, int cols, int type, cudaStream_t stream) + void CudaResource::copyTo(void* dst, size_t dpitch, size_t width, size_t height, cudaStream_t stream) { - CV_Assert(resource_ != 0); + CV_DbgAssert( resource_ != 0 ); - cudaSafeCall( cudaGraphicsMapResources(1, &resource_, stream) ); + GraphicsMapHolder h(&resource_, stream); + (void) h; + + void* src; + size_t size; + cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&src, &size, resource_) ); + + CV_DbgAssert( width * height == size ); + + if (stream == 0) + cudaSafeCall( cudaMemcpy2D(dst, dpitch, src, width, width, height, cudaMemcpyDeviceToDevice) ); + else + cudaSafeCall( cudaMemcpy2DAsync(dst, dpitch, src, width, width, height, cudaMemcpyDeviceToDevice, stream) ); + } + + void* CudaResource::map(cudaStream_t stream) + { + CV_DbgAssert( resource_ != 0 ); + + GraphicsMapHolder h(&resource_, stream); void* ptr; - size_t num_bytes; - cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&ptr, &num_bytes, resource_) ); + size_t size; + cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&ptr, &size, resource_) ); - CV_Assert( static_cast(cols) * CV_ELEM_SIZE(type) * rows <= num_bytes ); + h.reset(); - return GpuMat(rows, cols, type, ptr); + return ptr; } - inline void CudaGlInterop::unmap(cudaStream_t stream) + void CudaResource::unmap(cudaStream_t stream) { + CV_Assert( resource_ != 0 ); + cudaGraphicsUnmapResources(1, &resource_, stream); } } -#endif // HAVE_CUDA && HAVE_OPENGL + +#endif //////////////////////////////////////////////////////////////////////// // GlBuffer @@ -296,393 +326,466 @@ class cv::GlBuffer::Impl public: static const Ptr& empty(); - Impl(int rows, int cols, int type, unsigned int target); - Impl(const Mat& m, unsigned int target); + Impl(GLuint bufId, bool autoRelease); + Impl(GLsizeiptr size, const GLvoid* data, GLenum target, bool autoRelease); ~Impl(); - void copyFrom(const Mat& m, unsigned int target); + void bind(GLenum target) const; + + void copyFrom(GLuint srcBuf, GLsizeiptr size); + + void copyFrom(GLsizeiptr size, const GLvoid* data); + void copyTo(GLsizeiptr size, GLvoid* data) const; + + void* mapHost(GLenum access); + void unmapHost(); #ifdef HAVE_CUDA - void copyFrom(const GpuMat& mat, cudaStream_t stream = 0); -#endif + void copyFrom(const void* src, size_t spitch, size_t width, size_t height, cudaStream_t stream = 0); + void copyTo(void* dst, size_t dpitch, size_t width, size_t height, cudaStream_t stream = 0) const; - void bind(unsigned int target) const; - void unbind(unsigned int target) const; - - Mat mapHost(int rows, int cols, int type, unsigned int target); - void unmapHost(unsigned int target); - -#ifdef HAVE_CUDA - GpuMat mapDevice(int rows, int cols, int type, cudaStream_t stream = 0); + void* mapDevice(cudaStream_t stream = 0); void unmapDevice(cudaStream_t stream = 0); #endif + void setAutoRelease(bool flag) { autoRelease_ = flag; } + + GLuint bufId() const { return bufId_; } + private: Impl(); - unsigned int buffer_; + GLuint bufId_; + bool autoRelease_; #ifdef HAVE_CUDA - CudaGlInterop cudaGlInterop_; + mutable CudaResource cudaResource_; #endif }; -inline const Ptr& cv::GlBuffer::Impl::empty() +const Ptr& cv::GlBuffer::Impl::empty() { static Ptr p(new Impl); return p; } -inline cv::GlBuffer::Impl::Impl() : buffer_(0) +cv::GlBuffer::Impl::Impl() : bufId_(0), autoRelease_(true) { } -cv::GlBuffer::Impl::Impl(int rows, int cols, int type, unsigned int target) : buffer_(0) +cv::GlBuffer::Impl::Impl(GLuint abufId, bool autoRelease) : bufId_(abufId), autoRelease_(autoRelease) { - if (!glFuncTab()->isGlContextInitialized()) - throw_nogl; - - CV_DbgAssert(rows > 0 && cols > 0); - CV_DbgAssert(CV_MAT_DEPTH(type) >= 0 && CV_MAT_DEPTH(type) <= CV_64F); - - glFuncTab()->genBuffers(1, &buffer_); - CV_CheckGlError(); - CV_Assert(buffer_ != 0); - - size_t size = rows * cols * CV_ELEM_SIZE(type); - - glFuncTab()->bindBuffer(target, buffer_); - CV_CheckGlError(); - - glFuncTab()->bufferData(target, size, 0, GL_DYNAMIC_DRAW); - CV_CheckGlError(); - - glFuncTab()->bindBuffer(target, 0); - -#ifdef HAVE_CUDA - if (g_isCudaGlDeviceInitialized) - cudaGlInterop_.registerBuffer(buffer_); -#endif } -cv::GlBuffer::Impl::Impl(const Mat& m, unsigned int target) : buffer_(0) +cv::GlBuffer::Impl::Impl(GLsizeiptr size, const GLvoid* data, GLenum target, bool autoRelease) : bufId_(0), autoRelease_(autoRelease) { - if (!glFuncTab()->isGlContextInitialized()) - throw_nogl; - - CV_DbgAssert(m.rows > 0 && m.cols > 0); - CV_DbgAssert(m.depth() >= 0 && m.depth() <= CV_64F); - CV_Assert(m.isContinuous()); - - glFuncTab()->genBuffers(1, &buffer_); - CV_CheckGlError(); - CV_Assert(buffer_ != 0); - - size_t size = m.rows * m.cols * m.elemSize(); - - glFuncTab()->bindBuffer(target, buffer_); + gl::GenBuffers(1, &bufId_); CV_CheckGlError(); - glFuncTab()->bufferData(target, size, m.data, GL_DYNAMIC_DRAW); + CV_Assert( bufId_ != 0 ); + + gl::BindBuffer(target, bufId_); CV_CheckGlError(); - glFuncTab()->bindBuffer(target, 0); + gl::BufferData(target, size, data, gl::DYNAMIC_DRAW); + CV_CheckGlError(); -#ifdef HAVE_CUDA - if (g_isCudaGlDeviceInitialized) - cudaGlInterop_.registerBuffer(buffer_); -#endif + gl::BindBuffer(target, 0); + CV_CheckGlError(); } cv::GlBuffer::Impl::~Impl() { - try + if (autoRelease_ && bufId_) + gl::DeleteBuffers(1, &bufId_); +} + +void cv::GlBuffer::Impl::bind(GLenum target) const +{ + gl::BindBuffer(target, bufId_); + CV_CheckGlError(); +} + +void cv::GlBuffer::Impl::copyFrom(GLuint srcBuf, GLsizeiptr size) +{ + gl::BindBuffer(gl::COPY_WRITE_BUFFER, bufId_); + CV_CheckGlError(); + + gl::BindBuffer(gl::COPY_READ_BUFFER, srcBuf); + CV_CheckGlError(); + + gl::CopyBufferSubData(gl::COPY_READ_BUFFER, gl::COPY_WRITE_BUFFER, 0, 0, size); + CV_CheckGlError(); +} + +void cv::GlBuffer::Impl::copyFrom(GLsizeiptr size, const GLvoid* data) +{ + gl::BindBuffer(gl::COPY_WRITE_BUFFER, bufId_); + CV_CheckGlError(); + + gl::BufferSubData(gl::COPY_WRITE_BUFFER, 0, size, data); + CV_CheckGlError(); +} + +void cv::GlBuffer::Impl::copyTo(GLsizeiptr size, GLvoid* data) const +{ + gl::BindBuffer(gl::COPY_READ_BUFFER, bufId_); + CV_CheckGlError(); + + gl::GetBufferSubData(gl::COPY_READ_BUFFER, 0, size, data); + CV_CheckGlError(); +} + +void* cv::GlBuffer::Impl::mapHost(GLenum access) +{ + gl::BindBuffer(gl::COPY_READ_BUFFER, bufId_); + CV_CheckGlError(); + + GLvoid* data = gl::MapBuffer(gl::COPY_READ_BUFFER, access); + CV_CheckGlError(); + + return data; +} + +void cv::GlBuffer::Impl::unmapHost() +{ + gl::UnmapBuffer(gl::COPY_READ_BUFFER); +} + +#ifdef HAVE_CUDA + void cv::GlBuffer::Impl::copyFrom(const void* src, size_t spitch, size_t width, size_t height, cudaStream_t stream) { - if (buffer_) - glFuncTab()->deleteBuffers(1, &buffer_); + cudaResource_.registerBuffer(bufId_); + cudaResource_.copyFrom(src, spitch, width, height, stream); } -#ifdef _DEBUG - catch(const exception& e) + + void cv::GlBuffer::Impl::copyTo(void* dst, size_t dpitch, size_t width, size_t height, cudaStream_t stream) const { - cerr << e.what() << endl; + cudaResource_.registerBuffer(bufId_); + cudaResource_.copyTo(dst, dpitch, width, height, stream); + } + + void* cv::GlBuffer::Impl::mapDevice(cudaStream_t stream) + { + cudaResource_.registerBuffer(bufId_); + return cudaResource_.map(stream); + } + + void cv::GlBuffer::Impl::unmapDevice(cudaStream_t stream) + { + cudaResource_.unmap(stream); } #endif - catch(...) - { - } -} - -void cv::GlBuffer::Impl::copyFrom(const Mat& m, unsigned int target) -{ - CV_Assert(buffer_ != 0); - - CV_Assert(m.isContinuous()); - - bind(target); - - size_t size = m.rows * m.cols * m.elemSize(); - - glFuncTab()->bufferSubData(target, 0, size, m.data); - CV_CheckGlError(); - - unbind(target); -} - -#ifdef HAVE_CUDA - -void cv::GlBuffer::Impl::copyFrom(const GpuMat& mat, cudaStream_t stream) -{ - if (!g_isCudaGlDeviceInitialized) - cvError(CV_GpuApiCallError, "copyFrom", "cuda GL device wasn't initialized, call setGlDevice", __FILE__, __LINE__); - - CV_Assert(buffer_ != 0); - - cudaGlInterop_.copyFrom(mat, stream); -} - -#endif // HAVE_CUDA - -inline void cv::GlBuffer::Impl::bind(unsigned int target) const -{ - CV_Assert(buffer_ != 0); - - glFuncTab()->bindBuffer(target, buffer_); - CV_CheckGlError(); -} - -inline void cv::GlBuffer::Impl::unbind(unsigned int target) const -{ - glFuncTab()->bindBuffer(target, 0); -} - -inline Mat cv::GlBuffer::Impl::mapHost(int rows, int cols, int type, unsigned int target) -{ - void* ptr = glFuncTab()->mapBuffer(target, GL_READ_WRITE); - CV_CheckGlError(); - - return Mat(rows, cols, type, ptr); -} - -inline void cv::GlBuffer::Impl::unmapHost(unsigned int target) -{ - glFuncTab()->unmapBuffer(target); -} - -#ifdef HAVE_CUDA - -inline GpuMat cv::GlBuffer::Impl::mapDevice(int rows, int cols, int type, cudaStream_t stream) -{ - if (!g_isCudaGlDeviceInitialized) - cvError(CV_GpuApiCallError, "copyFrom", "cuda GL device wasn't initialized, call setGlDevice", __FILE__, __LINE__); - - CV_Assert(buffer_ != 0); - - return cudaGlInterop_.map(rows, cols, type, stream); -} - -inline void cv::GlBuffer::Impl::unmapDevice(cudaStream_t stream) -{ - if (!g_isCudaGlDeviceInitialized) - cvError(CV_GpuApiCallError, "copyFrom", "cuda GL device wasn't initialized, call setGlDevice", __FILE__, __LINE__); - - cudaGlInterop_.unmap(stream); -} - -#endif // HAVE_CUDA #endif // HAVE_OPENGL -cv::GlBuffer::GlBuffer(Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage) +cv::GlBuffer::GlBuffer() : rows_(0), cols_(0), type_(0) { #ifndef HAVE_OPENGL - (void)_usage; - throw_nogl; + throw_nogl(); #else impl_ = Impl::empty(); #endif } -cv::GlBuffer::GlBuffer(int _rows, int _cols, int _type, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage) +cv::GlBuffer::GlBuffer(int arows, int acols, int atype, unsigned int abufId, bool autoRelease) : rows_(0), cols_(0), type_(0) { #ifndef HAVE_OPENGL - (void)_rows; - (void)_cols; - (void)_type; - (void)_usage; - throw_nogl; + (void) arows; + (void) acols; + (void) atype; + (void) abufId; + (void) autoRelease; + throw_nogl(); #else - impl_ = new Impl(_rows, _cols, _type, _usage); - rows_ = _rows; - cols_ = _cols; - type_ = _type; + impl_ = new Impl(abufId, autoRelease); + rows_ = arows; + cols_ = acols; + type_ = atype; #endif } -cv::GlBuffer::GlBuffer(Size _size, int _type, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage) +cv::GlBuffer::GlBuffer(Size asize, int atype, unsigned int abufId, bool autoRelease) : rows_(0), cols_(0), type_(0) { #ifndef HAVE_OPENGL - (void)_size; - (void)_type; - (void)_usage; - throw_nogl; + (void) asize; + (void) atype; + (void) abufId; + (void) autoRelease; + throw_nogl(); #else - impl_ = new Impl(_size.height, _size.width, _type, _usage); - rows_ = _size.height; - cols_ = _size.width; - type_ = _type; + impl_ = new Impl(abufId, autoRelease); + rows_ = asize.height; + cols_ = asize.width; + type_ = atype; #endif } -cv::GlBuffer::GlBuffer(InputArray mat_, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage) +cv::GlBuffer::GlBuffer(int arows, int acols, int atype, Target target, bool autoRelease) : rows_(0), cols_(0), type_(0) +{ + create(arows, acols, atype, target, autoRelease); +} + +cv::GlBuffer::GlBuffer(Size asize, int atype, Target target, bool autoRelease) : rows_(0), cols_(0), type_(0) +{ + create(asize, atype, target, autoRelease); +} + +cv::GlBuffer::GlBuffer(InputArray arr, Target target, bool autoRelease) : rows_(0), cols_(0), type_(0) { #ifndef HAVE_OPENGL - (void)mat_; - (void)_usage; - throw_nogl; + (void) arr; + (void) target; + (void) autoRelease; + throw_nogl(); #else - int kind = mat_.kind(); - Size _size = mat_.size(); - int _type = mat_.type(); + const int kind = arr.kind(); - if (kind == _InputArray::GPU_MAT) + switch (kind) { - #if !defined HAVE_CUDA || defined(CUDA_DISABLER) - throw_nocuda; - #else - GpuMat d_mat = mat_.getGpuMat(); - impl_ = new Impl(d_mat.rows, d_mat.cols, d_mat.type(), _usage); - impl_->copyFrom(d_mat); - #endif + case _InputArray::OPENGL_BUFFER: + { + copyFrom(arr, target, autoRelease); + break; + } + + case _InputArray::OPENGL_TEXTURE: + { + copyFrom(arr, target, autoRelease); + break; + } + + case _InputArray::GPU_MAT: + { + copyFrom(arr, target, autoRelease); + break; + } + + default: + { + Mat mat = arr.getMat(); + CV_Assert( mat.isContinuous() ); + const GLsizeiptr asize = mat.rows * mat.cols * mat.elemSize(); + impl_ = new Impl(asize, mat.data, target, autoRelease); + rows_ = mat.rows; + cols_ = mat.cols; + type_ = mat.type(); + break; + } } - else - { - Mat mat = mat_.getMat(); - impl_ = new Impl(mat, _usage); - } - - rows_ = _size.height; - cols_ = _size.width; - type_ = _type; #endif } -void cv::GlBuffer::create(int _rows, int _cols, int _type, Usage _usage) +void cv::GlBuffer::create(int arows, int acols, int atype, Target target, bool autoRelease) { #ifndef HAVE_OPENGL - (void)_rows; - (void)_cols; - (void)_type; - (void)_usage; - throw_nogl; + (void) arows; + (void) acols; + (void) atype; + (void) target; + (void) autoRelease; + throw_nogl(); #else - if (rows_ != _rows || cols_ != _cols || type_ != _type || usage_ != _usage) + if (rows_ != arows || cols_ != acols || type_ != atype) { - impl_ = new Impl(_rows, _cols, _type, _usage); - rows_ = _rows; - cols_ = _cols; - type_ = _type; - usage_ = _usage; + const GLsizeiptr asize = arows * acols * CV_ELEM_SIZE(atype); + impl_ = new Impl(asize, 0, target, autoRelease); + rows_ = arows; + cols_ = acols; + type_ = atype; } #endif } void cv::GlBuffer::release() { -#ifndef HAVE_OPENGL - throw_nogl; -#else +#ifdef HAVE_OPENGL + if (*impl_.refcount == 1) + impl_->setAutoRelease(true); impl_ = Impl::empty(); + rows_ = 0; + cols_ = 0; + type_ = 0; #endif } -void cv::GlBuffer::copyFrom(InputArray mat_) +void cv::GlBuffer::setAutoRelease(bool flag) { #ifndef HAVE_OPENGL - (void)mat_; - throw_nogl; + (void) flag; + throw_nogl(); #else - int kind = mat_.kind(); - Size _size = mat_.size(); - int _type = mat_.type(); + impl_->setAutoRelease(flag); +#endif +} - create(_size, _type); +void cv::GlBuffer::copyFrom(InputArray arr, Target target, bool autoRelease) +{ +#ifndef HAVE_OPENGL + (void) arr; + (void) target; + (void) autoRelease; + throw_nogl(); +#else + const int kind = arr.kind(); + + if (kind == _InputArray::OPENGL_TEXTURE) + { + GlTexture tex = arr.getGlTexture(); + tex.copyTo(*this); + setAutoRelease(autoRelease); + return; + } + + const Size asize = arr.size(); + const int atype = arr.type(); + create(asize, atype, target, autoRelease); switch (kind) { case _InputArray::OPENGL_BUFFER: { - GlBuffer buf = mat_.getGlBuffer(); - *this = buf; + GlBuffer buf = arr.getGlBuffer(); + impl_->copyFrom(buf.bufId(), asize.area() * CV_ELEM_SIZE(atype)); break; } + case _InputArray::GPU_MAT: { #if !defined HAVE_CUDA || defined(CUDA_DISABLER) - throw_nocuda; + throw_nocuda(); #else - GpuMat d_mat = mat_.getGpuMat(); - impl_->copyFrom(d_mat); + GpuMat dmat = arr.getGpuMat(); + impl_->copyFrom(dmat.data, dmat.step, dmat.cols * dmat.elemSize(), dmat.rows); #endif break; } + default: { - Mat mat = mat_.getMat(); - impl_->copyFrom(mat, usage_); + Mat mat = arr.getMat(); + CV_Assert( mat.isContinuous() ); + impl_->copyFrom(asize.area() * CV_ELEM_SIZE(atype), mat.data); } } #endif } -void cv::GlBuffer::bind() const +void cv::GlBuffer::copyTo(OutputArray arr, Target target, bool autoRelease) const { #ifndef HAVE_OPENGL - throw_nogl; + (void) arr; + (void) target; + (void) autoRelease; + throw_nogl(); #else - impl_->bind(usage_); + const int kind = arr.kind(); + + switch (kind) + { + case _InputArray::OPENGL_BUFFER: + { + arr.getGlBufferRef().copyFrom(*this, target, autoRelease); + break; + } + + case _InputArray::OPENGL_TEXTURE: + { + arr.getGlTextureRef().copyFrom(*this, autoRelease); + break; + } + + case _InputArray::GPU_MAT: + { + #if !defined HAVE_CUDA || defined(CUDA_DISABLER) + throw_nocuda(); + #else + GpuMat& dmat = arr.getGpuMatRef(); + dmat.create(rows_, cols_, type_); + impl_->copyTo(dmat.data, dmat.step, dmat.cols * dmat.elemSize(), dmat.rows); + #endif + + break; + } + + default: + { + arr.create(rows_, cols_, type_); + Mat mat = arr.getMat(); + CV_Assert( mat.isContinuous() ); + impl_->copyTo(mat.rows * mat.cols * mat.elemSize(), mat.data); + } + } #endif } -void cv::GlBuffer::unbind() const +GlBuffer cv::GlBuffer::clone(Target target, bool autoRelease) const { #ifndef HAVE_OPENGL - throw_nogl; + (void) target; + (void) autoRelease; + throw_nogl(); + return GlBuffer(); #else - impl_->unbind(usage_); + GlBuffer buf; + buf.copyFrom(*this, target, autoRelease); + return buf; #endif } -Mat cv::GlBuffer::mapHost() +void cv::GlBuffer::bind(Target target) const { #ifndef HAVE_OPENGL - throw_nogl; + (void) target; + throw_nogl(); +#else + impl_->bind(target); +#endif +} + +void cv::GlBuffer::unbind(Target target) +{ +#ifndef HAVE_OPENGL + (void) target; + throw_nogl(); +#else + gl::BindBuffer(target, 0); + CV_CheckGlError(); +#endif +} + +Mat cv::GlBuffer::mapHost(Access access) +{ +#ifndef HAVE_OPENGL + (void) access; + throw_nogl(); return Mat(); #else - return impl_->mapHost(rows_, cols_, type_, usage_); + return Mat(rows_, cols_, type_, impl_->mapHost(access)); #endif } void cv::GlBuffer::unmapHost() { #ifndef HAVE_OPENGL - throw_nogl; + throw_nogl(); #else - impl_->unmapHost(usage_); + return impl_->unmapHost(); #endif } GpuMat cv::GlBuffer::mapDevice() { #ifndef HAVE_OPENGL - throw_nogl; + throw_nogl(); return GpuMat(); #else #if !defined HAVE_CUDA || defined(CUDA_DISABLER) - throw_nocuda; + throw_nocuda(); return GpuMat(); #else - return impl_->mapDevice(rows_, cols_, type_); + return GpuMat(rows_, cols_, type_, impl_->mapDevice()); #endif #endif } @@ -690,16 +793,26 @@ GpuMat cv::GlBuffer::mapDevice() void cv::GlBuffer::unmapDevice() { #ifndef HAVE_OPENGL - throw_nogl; + throw_nogl(); #else #if !defined HAVE_CUDA || defined(CUDA_DISABLER) - throw_nocuda; + throw_nocuda(); #else impl_->unmapDevice(); #endif #endif } +unsigned int cv::GlBuffer::bufId() const +{ +#ifndef HAVE_OPENGL + throw_nogl(); + return 0; +#else + return impl_->bufId(); +#endif +} + template <> void cv::Ptr::delete_obj() { if (obj) delete obj; @@ -721,363 +834,377 @@ class cv::GlTexture::Impl public: static const Ptr empty(); - Impl(int rows, int cols, int type); - - Impl(const Mat& mat, bool bgra); - Impl(const GlBuffer& buf, bool bgra); - + Impl(GLuint texId, bool autoRelease); + Impl(GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels, bool autoRelease); ~Impl(); - void copyFrom(const Mat& mat, bool bgra); - void copyFrom(const GlBuffer& buf, bool bgra); + void copyFrom(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); + void copyTo(GLenum format, GLenum type, GLvoid* pixels) const; void bind() const; - void unbind() const; + + void setAutoRelease(bool flag) { autoRelease_ = flag; } + + GLuint texId() const { return texId_; } private: Impl(); - GLuint tex_; + GLuint texId_; + bool autoRelease_; }; -inline const Ptr cv::GlTexture::Impl::empty() +const Ptr cv::GlTexture::Impl::empty() { static Ptr p(new Impl); return p; } -inline cv::GlTexture::Impl::Impl() : tex_(0) +cv::GlTexture::Impl::Impl() : texId_(0), autoRelease_(true) { } -cv::GlTexture::Impl::Impl(int rows, int cols, int type) : tex_(0) +cv::GlTexture::Impl::Impl(GLuint atexId, bool autoRelease) : texId_(atexId), autoRelease_(autoRelease) { - if (!glFuncTab()->isGlContextInitialized()) - throw_nogl; +} - int depth = CV_MAT_DEPTH(type); - int cn = CV_MAT_CN(type); - - CV_DbgAssert(rows > 0 && cols > 0); - CV_Assert(cn == 1 || cn == 3 || cn == 4); - CV_Assert(depth >= 0 && depth <= CV_32F); - - glGenTextures(1, &tex_); - CV_CheckGlError(); - CV_Assert(tex_ != 0); - - glBindTexture(GL_TEXTURE_2D, tex_); +cv::GlTexture::Impl::Impl(GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels, bool autoRelease) : texId_(0), autoRelease_(autoRelease) +{ + gl::GenTextures(1, &texId_); CV_CheckGlError(); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + CV_Assert(texId_ != 0); + + gl::BindTexture(gl::TEXTURE_2D, texId_); CV_CheckGlError(); - GLenum format = cn == 1 ? GL_LUMINANCE : cn == 3 ? GL_BGR : GL_BGRA; - - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + gl::PixelStorei(gl::UNPACK_ALIGNMENT, 1); CV_CheckGlError(); - glTexImage2D(GL_TEXTURE_2D, 0, cn, cols, rows, 0, format, gl_types[depth], 0); + gl::TexImage2D(gl::TEXTURE_2D, 0, internalFormat, width, height, 0, format, type, pixels); + CV_CheckGlError(); + + gl::GenerateMipmap(gl::TEXTURE_2D); CV_CheckGlError(); } -cv::GlTexture::Impl::Impl(const Mat& mat, bool bgra) : tex_(0) +cv::GlTexture::Impl::~Impl() { - if (!glFuncTab()->isGlContextInitialized()) - throw_nogl; + if (autoRelease_ && texId_) + gl::DeleteTextures(1, &texId_); +} - int depth = mat.depth(); - int cn = mat.channels(); - - CV_DbgAssert(mat.rows > 0 && mat.cols > 0); - CV_Assert(cn == 1 || cn == 3 || cn == 4); - CV_Assert(depth >= 0 && depth <= CV_32F); - CV_Assert(mat.isContinuous()); - - glGenTextures(1, &tex_); - CV_CheckGlError(); - CV_Assert(tex_ != 0); - - glBindTexture(GL_TEXTURE_2D, tex_); +void cv::GlTexture::Impl::copyFrom(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) +{ + gl::BindTexture(gl::TEXTURE_2D, texId_); CV_CheckGlError(); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + gl::PixelStorei(gl::UNPACK_ALIGNMENT, 1); CV_CheckGlError(); - GLenum format = cn == 1 ? GL_LUMINANCE : (cn == 3 ? (bgra ? GL_BGR : GL_RGB) : (bgra ? GL_BGRA : GL_RGBA)); - - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + gl::TexSubImage2D(gl::TEXTURE_2D, 0, 0, 0, width, height, format, type, pixels); CV_CheckGlError(); - glTexImage2D(GL_TEXTURE_2D, 0, cn, mat.cols, mat.rows, 0, format, gl_types[depth], mat.data); + gl::GenerateMipmap(gl::TEXTURE_2D); CV_CheckGlError(); } -cv::GlTexture::Impl::Impl(const GlBuffer& buf, bool bgra) : tex_(0) +void cv::GlTexture::Impl::copyTo(GLenum format, GLenum type, GLvoid* pixels) const { - if (!glFuncTab()->isGlContextInitialized()) - throw_nogl; - - int depth = buf.depth(); - int cn = buf.channels(); - - CV_DbgAssert(buf.rows() > 0 && buf.cols() > 0); - CV_Assert(cn == 1 || cn == 3 || cn == 4); - CV_Assert(depth >= 0 && depth <= CV_32F); - CV_Assert(buf.usage() == GlBuffer::TEXTURE_BUFFER); - - glGenTextures(1, &tex_); - CV_CheckGlError(); - CV_Assert(tex_ != 0); - - glBindTexture(GL_TEXTURE_2D, tex_); + gl::BindTexture(gl::TEXTURE_2D, texId_); CV_CheckGlError(); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + gl::PixelStorei(gl::PACK_ALIGNMENT, 1); CV_CheckGlError(); - GLenum format = cn == 1 ? GL_LUMINANCE : (cn == 3 ? (bgra ? GL_BGR : GL_RGB) : (bgra ? GL_BGRA : GL_RGBA)); - - buf.bind(); - - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - CV_CheckGlError(); - - glTexImage2D(GL_TEXTURE_2D, 0, cn, buf.cols(), buf.rows(), 0, format, gl_types[depth], 0); - CV_CheckGlError(); - - buf.unbind(); -} - -inline cv::GlTexture::Impl::~Impl() -{ - if (tex_) - glDeleteTextures(1, &tex_); -} - -void cv::GlTexture::Impl::copyFrom(const Mat& mat, bool bgra) -{ - CV_Assert(tex_ != 0); - - bind(); - - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - CV_CheckGlError(); - - int cn = mat.channels(); - GLenum format = cn == 1 ? GL_LUMINANCE : (cn == 3 ? (bgra ? GL_BGR : GL_RGB) : (bgra ? GL_BGRA : GL_RGBA)); - - glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mat.cols, mat.rows, format, gl_types[mat.depth()], mat.data); - CV_CheckGlError(); - - unbind(); -} - -void cv::GlTexture::Impl::copyFrom(const GlBuffer& buf, bool bgra) -{ - CV_Assert(tex_ != 0); - CV_Assert(buf.usage() == GlBuffer::TEXTURE_BUFFER); - - bind(); - - buf.bind(); - - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - CV_CheckGlError(); - - int cn = buf.channels(); - GLenum format = cn == 1 ? GL_LUMINANCE : (cn == 3 ? (bgra ? GL_BGR : GL_RGB) : (bgra ? GL_BGRA : GL_RGBA)); - - glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, buf.cols(), buf.rows(), format, gl_types[buf.depth()], 0); - CV_CheckGlError(); - - buf.unbind(); - - unbind(); -} - -inline void cv::GlTexture::Impl::bind() const -{ - CV_Assert(tex_ != 0); - - glEnable(GL_TEXTURE_2D); - CV_CheckGlError(); - - glBindTexture(GL_TEXTURE_2D, tex_); + gl::GetTexImage(gl::TEXTURE_2D, 0, format, type, pixels); CV_CheckGlError(); } -inline void cv::GlTexture::Impl::unbind() const +void cv::GlTexture::Impl::bind() const { - glBindTexture(GL_TEXTURE_2D, 0); - - glDisable(GL_TEXTURE_2D); + gl::BindTexture(gl::TEXTURE_2D, texId_); + CV_CheckGlError(); } #endif // HAVE_OPENGL -cv::GlTexture::GlTexture() : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER) +cv::GlTexture::GlTexture() : rows_(0), cols_(0), format_(NONE) { #ifndef HAVE_OPENGL - throw_nogl; + throw_nogl(); #else impl_ = Impl::empty(); #endif } -cv::GlTexture::GlTexture(int _rows, int _cols, int _type) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER) +cv::GlTexture::GlTexture(int arows, int acols, Format aformat, unsigned int atexId, bool autoRelease) : rows_(0), cols_(0), format_(NONE) { #ifndef HAVE_OPENGL - (void)_rows; - (void)_cols; - (void)_type; - throw_nogl; + (void) arows; + (void) acols; + (void) aformat; + (void) atexId; + (void) autoRelease; + throw_nogl(); #else - impl_ = new Impl(_rows, _cols, _type); - rows_ = _rows; - cols_ = _cols; - type_ = _type; + impl_ = new Impl(atexId, autoRelease); + rows_ = arows; + cols_ = acols; + format_ = aformat; #endif } -cv::GlTexture::GlTexture(Size _size, int _type) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER) +cv::GlTexture::GlTexture(Size asize, Format aformat, unsigned int atexId, bool autoRelease) : rows_(0), cols_(0), format_(NONE) { #ifndef HAVE_OPENGL - (void)_size; - (void)_type; - throw_nogl; + (void) asize; + (void) aformat; + (void) atexId; + (void) autoRelease; + throw_nogl(); #else - impl_ = new Impl(_size.height, _size.width, _type); - rows_ = _size.height; - cols_ = _size.width; - type_ = _type; + impl_ = new Impl(atexId, autoRelease); + rows_ = asize.height; + cols_ = asize.width; + format_ = aformat; #endif } -cv::GlTexture::GlTexture(InputArray mat_, bool bgra) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER) +cv::GlTexture::GlTexture(int arows, int acols, Format aformat, bool autoRelease) : rows_(0), cols_(0), format_(NONE) +{ + create(arows, acols, aformat, autoRelease); +} + +cv::GlTexture::GlTexture(Size asize, Format aformat, bool autoRelease) : rows_(0), cols_(0), format_(NONE) +{ + create(asize, aformat, autoRelease); +} + +cv::GlTexture::GlTexture(InputArray arr, bool autoRelease) : rows_(0), cols_(0), format_(NONE) { #ifndef HAVE_OPENGL - (void)mat_; - (void)bgra; - throw_nogl; + (void) arr; + (void) autoRelease; + throw_nogl(); #else - int kind = mat_.kind(); - Size _size = mat_.size(); - int _type = mat_.type(); + const int kind = arr.kind(); + + const Size asize = arr.size(); + const int atype = arr.type(); + + const int depth = CV_MAT_DEPTH(atype); + const int cn = CV_MAT_CN(atype); + + CV_Assert( depth <= CV_32F ); + CV_Assert( cn == 1 || cn == 3 || cn == 4 ); + + const Format internalFormats[] = + { + NONE, DEPTH_COMPONENT, NONE, RGB, RGBA + }; + const GLenum srcFormats[] = + { + 0, gl::DEPTH_COMPONENT, 0, gl::BGR, gl::BGRA + }; switch (kind) { case _InputArray::OPENGL_BUFFER: { - GlBuffer buf = mat_.getGlBuffer(); - impl_ = new Impl(buf, bgra); + GlBuffer buf = arr.getGlBuffer(); + buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER); + impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], 0, autoRelease); + GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); break; } + case _InputArray::GPU_MAT: { #if !defined HAVE_CUDA || defined(CUDA_DISABLER) - throw_nocuda; + throw_nocuda(); #else - GpuMat d_mat = mat_.getGpuMat(); - GlBuffer buf(d_mat, GlBuffer::TEXTURE_BUFFER); - impl_ = new Impl(buf, bgra); + GpuMat dmat = arr.getGpuMat(); + GlBuffer buf(dmat, GlBuffer::PIXEL_UNPACK_BUFFER); + buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER); + impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], 0, autoRelease); + GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); #endif break; } + default: { - Mat mat = mat_.getMat(); - impl_ = new Impl(mat, bgra); + Mat mat = arr.getMat(); + CV_Assert( mat.isContinuous() ); + GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); + impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], mat.data, autoRelease); break; } } - rows_ = _size.height; - cols_ = _size.width; - type_ = _type; + rows_ = asize.height; + cols_ = asize.width; + format_ = internalFormats[cn]; #endif } -void cv::GlTexture::create(int _rows, int _cols, int _type) +void cv::GlTexture::create(int arows, int acols, Format aformat, bool autoRelease) { #ifndef HAVE_OPENGL - (void)_rows; - (void)_cols; - (void)_type; - throw_nogl; + (void) arows; + (void) acols; + (void) aformat; + (void) autoRelease; + throw_nogl(); #else - if (rows_ != _rows || cols_ != _cols || type_ != _type) + if (rows_ != arows || cols_ != acols || format_ != aformat) { - impl_ = new Impl(_rows, _cols, _type); - rows_ = _rows; - cols_ = _cols; - type_ = _type; + GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); + impl_ = new Impl(aformat, acols, arows, aformat, gl::FLOAT, 0, autoRelease); + rows_ = arows; + cols_ = acols; + format_ = aformat; } #endif } void cv::GlTexture::release() { -#ifndef HAVE_OPENGL - throw_nogl; -#else +#ifdef HAVE_OPENGL + if (*impl_.refcount == 1) + impl_->setAutoRelease(true); impl_ = Impl::empty(); + rows_ = 0; + cols_ = 0; + format_ = NONE; #endif } -void cv::GlTexture::copyFrom(InputArray mat_, bool bgra) +void cv::GlTexture::setAutoRelease(bool flag) { #ifndef HAVE_OPENGL - (void)mat_; - (void)bgra; - throw_nogl; + (void) flag; + throw_nogl(); #else - int kind = mat_.kind(); - Size _size = mat_.size(); - int _type = mat_.type(); + impl_->setAutoRelease(flag); +#endif +} - create(_size, _type); +void cv::GlTexture::copyFrom(InputArray arr, bool autoRelease) +{ +#ifndef HAVE_OPENGL + (void) arr; + (void) autoRelease; + throw_nogl(); +#else + const int kind = arr.kind(); + + const Size asize = arr.size(); + const int atype = arr.type(); + + const int depth = CV_MAT_DEPTH(atype); + const int cn = CV_MAT_CN(atype); + + CV_Assert( depth <= CV_32F ); + CV_Assert( cn == 1 || cn == 3 || cn == 4 ); + + const Format internalFormats[] = + { + NONE, DEPTH_COMPONENT, NONE, RGB, RGBA + }; + const GLenum srcFormats[] = + { + 0, gl::DEPTH_COMPONENT, 0, gl::BGR, gl::BGRA + }; + + create(asize, internalFormats[cn], autoRelease); switch(kind) { - case _InputArray::OPENGL_TEXTURE: - { - GlTexture tex = mat_.getGlTexture(); - *this = tex; - break; - } case _InputArray::OPENGL_BUFFER: { - GlBuffer buf = mat_.getGlBuffer(); - impl_->copyFrom(buf, bgra); + GlBuffer buf = arr.getGlBuffer(); + buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER); + impl_->copyFrom(asize.width, asize.height, srcFormats[cn], gl_types[depth], 0); + GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); break; } + case _InputArray::GPU_MAT: { #if !defined HAVE_CUDA || defined(CUDA_DISABLER) - throw_nocuda; + throw_nocuda(); #else - GpuMat d_mat = mat_.getGpuMat(); - buf_.copyFrom(d_mat); - impl_->copyFrom(buf_, bgra); + GpuMat dmat = arr.getGpuMat(); + GlBuffer buf(dmat, GlBuffer::PIXEL_UNPACK_BUFFER); + buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER); + impl_->copyFrom(asize.width, asize.height, srcFormats[cn], gl_types[depth], 0); + GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); #endif break; } + default: { - Mat mat = mat_.getMat(); - impl_->copyFrom(mat, bgra); + Mat mat = arr.getMat(); + CV_Assert( mat.isContinuous() ); + GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); + impl_->copyFrom(asize.width, asize.height, srcFormats[cn], gl_types[depth], mat.data); + } + } +#endif +} + +void cv::GlTexture::copyTo(OutputArray arr, int ddepth, bool autoRelease) const +{ +#ifndef HAVE_OPENGL + (void) arr; + (void) ddepth; + (void) autoRelease; + throw_nogl(); +#else + const int kind = arr.kind(); + + const int cn = format_ == DEPTH_COMPONENT ? 1: format_ == RGB ? 3 : 4; + const GLenum dstFormat = format_ == DEPTH_COMPONENT ? gl::DEPTH_COMPONENT : format_ == RGB ? gl::BGR : gl::BGRA; + + switch(kind) + { + case _InputArray::OPENGL_BUFFER: + { + GlBuffer& buf = arr.getGlBufferRef(); + buf.create(rows_, cols_, CV_MAKE_TYPE(ddepth, cn), GlBuffer::PIXEL_PACK_BUFFER, autoRelease); + buf.bind(GlBuffer::PIXEL_PACK_BUFFER); + impl_->copyTo(dstFormat, gl_types[ddepth], 0); + GlBuffer::unbind(GlBuffer::PIXEL_PACK_BUFFER); + break; + } + + case _InputArray::GPU_MAT: + { + #if !defined HAVE_CUDA || defined(CUDA_DISABLER) + throw_nocuda(); + #else + GlBuffer buf(rows_, cols_, CV_MAKE_TYPE(ddepth, cn), GlBuffer::PIXEL_PACK_BUFFER); + buf.bind(GlBuffer::PIXEL_PACK_BUFFER); + impl_->copyTo(dstFormat, gl_types[ddepth], 0); + GlBuffer::unbind(GlBuffer::PIXEL_PACK_BUFFER); + buf.copyTo(arr); + #endif + + break; + } + + default: + { + arr.create(rows_, cols_, CV_MAKE_TYPE(ddepth, cn)); + Mat mat = arr.getMat(); + CV_Assert( mat.isContinuous() ); + GlBuffer::unbind(GlBuffer::PIXEL_PACK_BUFFER); + impl_->copyTo(dstFormat, gl_types[ddepth], mat.data); } } #endif @@ -1086,18 +1213,19 @@ void cv::GlTexture::copyFrom(InputArray mat_, bool bgra) void cv::GlTexture::bind() const { #ifndef HAVE_OPENGL - throw_nogl; + throw_nogl(); #else impl_->bind(); #endif } -void cv::GlTexture::unbind() const +unsigned int cv::GlTexture::texId() const { #ifndef HAVE_OPENGL - throw_nogl; + throw_nogl(); + return 0; #else - impl_->unbind(); + return impl_->texId(); #endif } @@ -1109,229 +1237,179 @@ template <> void cv::Ptr::delete_obj() //////////////////////////////////////////////////////////////////////// // GlArrays -void cv::GlArrays::setVertexArray(InputArray vertex) +cv::GlArrays::GlArrays() : size_(0) { - int cn = vertex.channels(); - int depth = vertex.depth(); - - CV_Assert(cn == 2 || cn == 3 || cn == 4); - CV_Assert(depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F); - - vertex_.copyFrom(vertex); } -void cv::GlArrays::setColorArray(InputArray color, bool bgra) +void cv::GlArrays::setVertexArray(InputArray vertex) { - int cn = color.channels(); + const int cn = vertex.channels(); + const int depth = vertex.depth(); - CV_Assert((cn == 3 && !bgra) || cn == 4); + CV_Assert( cn == 2 || cn == 3 || cn == 4 ); + CV_Assert( depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F ); - color_.copyFrom(color); - bgra_ = bgra; + if (vertex.kind() == _InputArray::OPENGL_BUFFER) + vertex_ = vertex.getGlBuffer(); + else + vertex_.copyFrom(vertex); + + size_ = vertex_.size().area(); +} + +void cv::GlArrays::resetVertexArray() +{ + vertex_.release(); + size_ = 0; +} + +void cv::GlArrays::setColorArray(InputArray color) +{ + const int cn = color.channels(); + + CV_Assert( cn == 3 || cn == 4 ); + + if (color.kind() == _InputArray::OPENGL_BUFFER) + color_ = color.getGlBuffer(); + else + color_.copyFrom(color); +} + +void cv::GlArrays::resetColorArray() +{ + color_.release(); } void cv::GlArrays::setNormalArray(InputArray normal) { - int cn = normal.channels(); - int depth = normal.depth(); + const int cn = normal.channels(); + const int depth = normal.depth(); - CV_Assert(cn == 3); - CV_Assert(depth == CV_8S || depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F); + CV_Assert( cn == 3 ); + CV_Assert( depth == CV_8S || depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F ); - normal_.copyFrom(normal); + if (normal.kind() == _InputArray::OPENGL_BUFFER) + normal_ = normal.getGlBuffer(); + else + normal_.copyFrom(normal); +} + +void cv::GlArrays::resetNormalArray() +{ + normal_.release(); } void cv::GlArrays::setTexCoordArray(InputArray texCoord) { - int cn = texCoord.channels(); - int depth = texCoord.depth(); + const int cn = texCoord.channels(); + const int depth = texCoord.depth(); - CV_Assert(cn >= 1 && cn <= 4); - CV_Assert(depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F); + CV_Assert( cn >= 1 && cn <= 4 ); + CV_Assert( depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F ); - texCoord_.copyFrom(texCoord); + if (texCoord.kind() == _InputArray::OPENGL_BUFFER) + texCoord_ = texCoord.getGlBuffer(); + else + texCoord_.copyFrom(texCoord); +} + +void cv::GlArrays::resetTexCoordArray() +{ + texCoord_.release(); +} + +void cv::GlArrays::release() +{ + resetVertexArray(); + resetColorArray(); + resetNormalArray(); + resetTexCoordArray(); +} + +void cv::GlArrays::setAutoRelease(bool flag) +{ + vertex_.setAutoRelease(flag); + color_.setAutoRelease(flag); + normal_.setAutoRelease(flag); + texCoord_.setAutoRelease(flag); } void cv::GlArrays::bind() const { #ifndef HAVE_OPENGL - throw_nogl; + throw_nogl(); #else - CV_DbgAssert(texCoord_.empty() || texCoord_.size().area() == vertex_.size().area()); - CV_DbgAssert(normal_.empty() || normal_.size().area() == vertex_.size().area()); - CV_DbgAssert(color_.empty() || color_.size().area() == vertex_.size().area()); + CV_Assert( texCoord_.empty() || texCoord_.size().area() == size_ ); + CV_Assert( normal_.empty() || normal_.size().area() == size_ ); + CV_Assert( color_.empty() || color_.size().area() == size_ ); - if (!texCoord_.empty()) + if (texCoord_.empty()) { - glEnableClientState(GL_TEXTURE_COORD_ARRAY); + gl::DisableClientState(gl::TEXTURE_COORD_ARRAY); CV_CheckGlError(); - - texCoord_.bind(); - - glTexCoordPointer(texCoord_.channels(), gl_types[texCoord_.depth()], 0, 0); - CV_CheckGlError(); - - texCoord_.unbind(); } - - if (!normal_.empty()) + else { - glEnableClientState(GL_NORMAL_ARRAY); + gl::EnableClientState(gl::TEXTURE_COORD_ARRAY); CV_CheckGlError(); - normal_.bind(); + texCoord_.bind(GlBuffer::ARRAY_BUFFER); - glNormalPointer(gl_types[normal_.depth()], 0, 0); - CV_CheckGlError(); - - normal_.unbind(); - } - - if (!color_.empty()) - { - glEnableClientState(GL_COLOR_ARRAY); - CV_CheckGlError(); - - color_.bind(); - - int cn = color_.channels(); - int format = cn == 3 ? cn : (bgra_ ? GL_BGRA : 4); - - glColorPointer(format, gl_types[color_.depth()], 0, 0); - CV_CheckGlError(); - - color_.unbind(); - } - - if (!vertex_.empty()) - { - glEnableClientState(GL_VERTEX_ARRAY); - CV_CheckGlError(); - - vertex_.bind(); - - glVertexPointer(vertex_.channels(), gl_types[vertex_.depth()], 0, 0); - CV_CheckGlError(); - - vertex_.unbind(); - } -#endif -} - -void cv::GlArrays::unbind() const -{ -#ifndef HAVE_OPENGL - throw_nogl; -#else - if (!texCoord_.empty()) - { - glDisableClientState(GL_TEXTURE_COORD_ARRAY); + gl::TexCoordPointer(texCoord_.channels(), gl_types[texCoord_.depth()], 0, 0); CV_CheckGlError(); } - if (!normal_.empty()) + if (normal_.empty()) { - glDisableClientState(GL_NORMAL_ARRAY); + gl::DisableClientState(gl::NORMAL_ARRAY); + CV_CheckGlError(); + } + else + { + gl::EnableClientState(gl::NORMAL_ARRAY); + CV_CheckGlError(); + + normal_.bind(GlBuffer::ARRAY_BUFFER); + + gl::NormalPointer(gl_types[normal_.depth()], 0, 0); CV_CheckGlError(); } - if (!color_.empty()) + if (color_.empty()) { - glDisableClientState(GL_COLOR_ARRAY); + gl::DisableClientState(gl::COLOR_ARRAY); + CV_CheckGlError(); + } + else + { + gl::EnableClientState(gl::COLOR_ARRAY); + CV_CheckGlError(); + + color_.bind(GlBuffer::ARRAY_BUFFER); + + const int cn = color_.channels(); + + gl::ColorPointer(cn, gl_types[color_.depth()], 0, 0); CV_CheckGlError(); } - if (!vertex_.empty()) + if (vertex_.empty()) { - glDisableClientState(GL_VERTEX_ARRAY); + gl::DisableClientState(gl::VERTEX_ARRAY); CV_CheckGlError(); } -#endif -} - -//////////////////////////////////////////////////////////////////////// -// GlFont - -cv::GlFont::GlFont(const string& _family, int _height, Weight _weight, Style _style) - : family_(_family), height_(_height), weight_(_weight), style_(_style), base_(0) -{ -#ifndef HAVE_OPENGL - throw_nogl; -#else - base_ = glGenLists(256); - CV_CheckGlError(); - - glFuncTab()->generateBitmapFont(family_, height_, weight_, (style_ & STYLE_ITALIC) != 0, (style_ & STYLE_UNDERLINE) != 0, 0, 256, base_); -#endif -} - -void cv::GlFont::draw(const char* str, int len) const -{ -#ifndef HAVE_OPENGL - (void)str; - (void)len; - throw_nogl; -#else - if (base_ && len > 0) + else { - glPushAttrib(GL_LIST_BIT); - glListBase(base_); + gl::EnableClientState(gl::VERTEX_ARRAY); + CV_CheckGlError(); - glCallLists(static_cast(len), GL_UNSIGNED_BYTE, str); - - glPopAttrib(); + vertex_.bind(GlBuffer::ARRAY_BUFFER); + gl::VertexPointer(vertex_.channels(), gl_types[vertex_.depth()], 0, 0); CV_CheckGlError(); } -#endif -} -namespace -{ - class FontCompare : public unary_function, bool> - { - public: - inline FontCompare(const string& family, int height, GlFont::Weight weight, GlFont::Style style) - : family_(family), height_(height), weight_(weight), style_(style) - { - } - - bool operator ()(const cv::Ptr& font) - { - return font->family() == family_ && font->height() == height_ && font->weight() == weight_ && font->style() == style_; - } - - private: - string family_; - int height_; - GlFont::Weight weight_; - GlFont::Style style_; - }; -} - -Ptr cv::GlFont::get(const std::string& family, int height, Weight weight, Style style) -{ -#ifndef HAVE_OPENGL - (void)family; - (void)height; - (void)weight; - (void)style; - throw_nogl; - return Ptr(); -#else - static vector< Ptr > fonts; - fonts.reserve(10); - - vector< Ptr >::iterator fontIt = find_if(fonts.begin(), fonts.end(), FontCompare(family, height, weight, style)); - - if (fontIt == fonts.end()) - { - fonts.push_back(new GlFont(family, height, weight, style)); - - fontIt = fonts.end() - 1; - } - - return *fontIt; + GlBuffer::unbind(GlBuffer::ARRAY_BUFFER); #endif } @@ -1341,34 +1419,71 @@ Ptr cv::GlFont::get(const std::string& family, int height, Weight weight void cv::render(const GlTexture& tex, Rect_ wndRect, Rect_ texRect) { #ifndef HAVE_OPENGL - (void)tex; - (void)wndRect; - (void)texRect; - throw_nogl; + (void) tex; + (void) wndRect; + (void) texRect; + throw_nogl(); #else if (!tex.empty()) { - tex.bind(); - - glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); - - glBegin(GL_QUADS); - glTexCoord2d(texRect.x, texRect.y); - glVertex2d(wndRect.x, wndRect.y); - - glTexCoord2d(texRect.x, texRect.y + texRect.height); - glVertex2d(wndRect.x, (wndRect.y + wndRect.height)); - - glTexCoord2d(texRect.x + texRect.width, texRect.y + texRect.height); - glVertex2d(wndRect.x + wndRect.width, (wndRect.y + wndRect.height)); - - glTexCoord2d(texRect.x + texRect.width, texRect.y); - glVertex2d(wndRect.x + wndRect.width, wndRect.y); - glEnd(); - + gl::MatrixMode(gl::PROJECTION); + gl::LoadIdentity(); + gl::Ortho(0.0, 1.0, 1.0, 0.0, -1.0, 1.0); CV_CheckGlError(); - tex.unbind(); + gl::MatrixMode(gl::MODELVIEW); + gl::LoadIdentity(); + CV_CheckGlError(); + + gl::Disable(gl::LIGHTING); + CV_CheckGlError(); + + tex.bind(); + + gl::Enable(gl::TEXTURE_2D); + CV_CheckGlError(); + + gl::TexEnvi(gl::TEXTURE_ENV, gl::TEXTURE_ENV_MODE, gl::REPLACE); + CV_CheckGlError(); + + gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::LINEAR); + CV_CheckGlError(); + + const float vertex[] = + { + wndRect.x, wndRect.y, 0.0f, + wndRect.x, (wndRect.y + wndRect.height), 0.0f, + wndRect.x + wndRect.width, (wndRect.y + wndRect.height), 0.0f, + wndRect.x + wndRect.width, wndRect.y, 0.0f + }; + const float texCoords[] = + { + texRect.x, texRect.y, + texRect.x, texRect.y + texRect.height, + texRect.x + texRect.width, texRect.y + texRect.height, + texRect.x + texRect.width, texRect.y + }; + + GlBuffer::unbind(GlBuffer::ARRAY_BUFFER); + + gl::EnableClientState(gl::TEXTURE_COORD_ARRAY); + CV_CheckGlError(); + + gl::TexCoordPointer(2, gl::FLOAT, 0, texCoords); + CV_CheckGlError(); + + gl::DisableClientState(gl::NORMAL_ARRAY); + gl::DisableClientState(gl::COLOR_ARRAY); + CV_CheckGlError(); + + gl::EnableClientState(gl::VERTEX_ARRAY); + CV_CheckGlError(); + + gl::VertexPointer(3, gl::FLOAT, 0, vertex); + CV_CheckGlError(); + + gl::DrawArrays(cv::RenderMode::QUADS, 0, 4); + CV_CheckGlError(); } #endif } @@ -1376,222 +1491,90 @@ void cv::render(const GlTexture& tex, Rect_ wndRect, Rect_ texRe void cv::render(const GlArrays& arr, int mode, Scalar color) { #ifndef HAVE_OPENGL - (void)arr; - (void)mode; - (void)color; - throw_nogl; + (void) arr; + (void) mode; + (void) color; + throw_nogl(); #else - glColor3d(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0); - - arr.bind(); - - glDrawArrays(mode, 0, arr.size().area()); - - arr.unbind(); -#endif -} - -void cv::render(const string& str, const Ptr& font, Scalar color, Point2d pos) -{ -#ifndef HAVE_OPENGL - (void)str; - (void)font; - (void)color; - (void)pos; - throw_nogl; -#else - glPushAttrib(GL_DEPTH_BUFFER_BIT); - - GLint viewport[4]; - glGetIntegerv(GL_VIEWPORT, viewport); - - glDisable(GL_DEPTH_TEST); - - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); - - glColor3d(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0); - - glRasterPos2d(2.0 * (viewport[0] + pos.x) / viewport[2] - 1.0, 1.0 - 2.0 * (viewport[1] + pos.y + font->height()) / viewport[3]); - - font->draw(str.c_str(), (int)str.length()); - - glPopAttrib(); -#endif -} - -//////////////////////////////////////////////////////////////////////// -// 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) -{ -} - -void cv::GlCamera::lookAt(Point3d eye, Point3d center, Point3d up) -{ - eye_ = eye; - center_ = center; - up_ = up; - useLookAtParams_ = true; -} - -void cv::GlCamera::setCameraPos(Point3d pos, double yaw, double pitch, double roll) -{ - pos_ = pos; - yaw_ = yaw; - pitch_ = pitch; - roll_ = roll; - useLookAtParams_ = false; -} - -void cv::GlCamera::setScale(Point3d scale) -{ - scale_ = scale; -} - -void cv::GlCamera::setProjectionMatrix(const Mat& projectionMatrix, bool transpose) -{ - CV_Assert(projectionMatrix.type() == CV_32F || projectionMatrix.type() == CV_64F); - CV_Assert(projectionMatrix.cols == 4 && projectionMatrix.rows == 4); - - projectionMatrix_ = transpose ? projectionMatrix.t() : projectionMatrix; -} - -void cv::GlCamera::setPerspectiveProjection(double fov, double aspect, double zNear, double zFar) -{ - fov_ = fov; - aspect_ = aspect; - zNear_ = zNear; - zFar_ = zFar; - - projectionMatrix_.release(); - perspectiveProjection_ = true; -} - -void cv::GlCamera::setOrthoProjection(double left, double right, double bottom, double top, double zNear, double zFar) -{ - left_ = left; - right_ = right; - bottom_ = bottom; - top_ = top; - zNear_ = zNear; - zFar_ = zFar; - - projectionMatrix_.release(); - perspectiveProjection_ = false; -} - -void cv::GlCamera::setupProjectionMatrix() const -{ -#ifndef HAVE_OPENGL - throw_nogl; -#else - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - - if (projectionMatrix_.empty()) + if (!arr.empty()) { - if (perspectiveProjection_) - gluPerspective(fov_, aspect_, zNear_, zFar_); - else - glOrtho(left_, right_, bottom_, top_, zNear_, zFar_); + gl::Color3d(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0); + + arr.bind(); + + gl::DrawArrays(mode, 0, arr.size()); } - else - { - if (projectionMatrix_.type() == CV_32F) - glLoadMatrixf(projectionMatrix_.ptr()); - else - glLoadMatrixd(projectionMatrix_.ptr()); - } - - CV_CheckGlError(); #endif } -void cv::GlCamera::setupModelViewMatrix() const +void cv::render(const GlArrays& arr, InputArray indices, int mode, Scalar color) { #ifndef HAVE_OPENGL - throw_nogl; + (void) arr; + (void) indices; + (void) mode; + (void) color; + throw_nogl(); #else - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); - - if (useLookAtParams_) - gluLookAt(eye_.x, eye_.y, eye_.z, center_.x, center_.y, center_.z, up_.x, up_.y, up_.z); - else + if (!arr.empty() && !indices.empty()) { - glRotated(-yaw_, 0.0, 1.0, 0.0); - glRotated(-pitch_, 1.0, 0.0, 0.0); - glRotated(-roll_, 0.0, 0.0, 1.0); - glTranslated(-pos_.x, -pos_.y, -pos_.z); - } + gl::Color3d(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0); - glScaled(scale_.x, scale_.y, scale_.z); + arr.bind(); - CV_CheckGlError(); -#endif -} + const int kind = indices.kind(); -//////////////////////////////////////////////////////////////////////// -// Error handling - -bool icvCheckGlError(const char* file, const int line, const char* func) -{ -#ifndef HAVE_OPENGL - (void)file; - (void)line; - (void)func; - return true; -#else - GLenum err = glGetError(); - - if (err != GL_NO_ERROR) - { - const char* msg; - - switch (err) + switch (kind) { - case GL_INVALID_ENUM: - msg = "An unacceptable value is specified for an enumerated argument"; - break; - case GL_INVALID_VALUE: - msg = "A numeric argument is out of range"; - break; - case GL_INVALID_OPERATION: - msg = "The specified operation is not allowed in the current state"; - break; - case GL_STACK_OVERFLOW: - msg = "This command would cause a stack overflow"; - break; - case GL_STACK_UNDERFLOW: - msg = "This command would cause a stack underflow"; - break; - case GL_OUT_OF_MEMORY: - msg = "There is not enough memory left to execute the command"; - break; + case _InputArray::OPENGL_BUFFER : + { + GlBuffer buf = indices.getGlBuffer(); + + const int depth = buf.depth(); + + CV_Assert( buf.channels() == 1 ); + CV_Assert( depth <= CV_32S ); + + GLenum type; + if (depth < CV_16U) + type = gl::UNSIGNED_BYTE; + else if (depth < CV_32S) + type = gl::UNSIGNED_SHORT; + else + type = gl::UNSIGNED_INT; + + buf.bind(GlBuffer::ELEMENT_ARRAY_BUFFER); + + gl::DrawElements(mode, buf.size().area(), type, 0); + + GlBuffer::unbind(GlBuffer::ELEMENT_ARRAY_BUFFER); + + break; + } + default: - msg = "Unknown error"; - }; + { + Mat mat = indices.getMat(); - cvError(CV_OpenGlApiCallError, func, msg, file, line); + const int depth = mat.depth(); - return false; + CV_Assert( mat.channels() == 1 ); + CV_Assert( depth <= CV_32S ); + CV_Assert( mat.isContinuous() ); + + GLenum type; + if (depth < CV_16U) + type = gl::UNSIGNED_BYTE; + else if (depth < CV_32S) + type = gl::UNSIGNED_SHORT; + else + type = gl::UNSIGNED_INT; + + GlBuffer::unbind(GlBuffer::ELEMENT_ARRAY_BUFFER); + + gl::DrawElements(mode, mat.size().area(), type, mat.data); + } + } } - - return true; #endif } diff --git a/modules/gpu/test/test_opengl.cpp b/modules/gpu/test/test_opengl.cpp new file mode 100644 index 0000000000..cd266ee413 --- /dev/null +++ b/modules/gpu/test/test_opengl.cpp @@ -0,0 +1,508 @@ +/*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. +// +// +// Intel License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2000, Intel Corporation, 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 Intel Corporation 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 "test_precomp.hpp" + +#if defined(HAVE_CUDA) && defined(HAVE_OPENGL) + +///////////////////////////////////////////// +// GlBuffer + +PARAM_TEST_CASE(GlBuffer, cv::Size, MatType) +{ + static void SetUpTestCase() + { + cv::namedWindow("test", cv::WINDOW_OPENGL); + } + + static void TearDownTestCase() + { + cv::destroyAllWindows(); + } + + cv::Size size; + int type; + + virtual void SetUp() + { + size = GET_PARAM(0); + type = GET_PARAM(1); + } +}; + +GPU_TEST_P(GlBuffer, Constructor1) +{ + cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true); + + EXPECT_EQ(size.height, buf.rows()); + EXPECT_EQ(size.width, buf.cols()); + EXPECT_EQ(type, buf.type()); +} + +GPU_TEST_P(GlBuffer, Constructor2) +{ + cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true); + + EXPECT_EQ(size.height, buf.rows()); + EXPECT_EQ(size.width, buf.cols()); + EXPECT_EQ(type, buf.type()); +} + +GPU_TEST_P(GlBuffer, ConstructorFromMat) +{ + cv::Mat gold = randomMat(size, type); + + cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); +} + +GPU_TEST_P(GlBuffer, ConstructorFromGpuMat) +{ + cv::Mat gold = randomMat(size, type); + cv::gpu::GpuMat d_gold(gold); + + cv::GlBuffer buf(d_gold, cv::GlBuffer::ARRAY_BUFFER); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); +} + +GPU_TEST_P(GlBuffer, ConstructorFromGlBuffer) +{ + cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true); + + cv::GlBuffer buf(buf_gold); + + EXPECT_EQ(buf_gold.bufId(), buf.bufId()); + EXPECT_EQ(buf_gold.rows(), buf.rows()); + EXPECT_EQ(buf_gold.cols(), buf.cols()); + EXPECT_EQ(buf_gold.type(), buf.type()); +} + +GPU_TEST_P(GlBuffer, ConstructorFromGlTexture) +{ + const int depth = CV_MAT_DEPTH(type); + const int cn = CV_MAT_CN(type); + + if (depth != CV_32F || cn == 2) + return; + + cv::Mat gold = randomMat(size, type, 0, 1.0); + cv::GlTexture tex_gold(gold, true); + + cv::GlBuffer buf(tex_gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 1e-2); +} + +GPU_TEST_P(GlBuffer, Create) +{ + cv::GlBuffer buf; + buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true); + + EXPECT_EQ(size.height, buf.rows()); + EXPECT_EQ(size.width, buf.cols()); + EXPECT_EQ(type, buf.type()); +} + +GPU_TEST_P(GlBuffer, CopyFromMat) +{ + cv::Mat gold = randomMat(size, type); + + cv::GlBuffer buf; + buf.copyFrom(gold, cv::GlBuffer::ARRAY_BUFFER, true); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); +} + +GPU_TEST_P(GlBuffer, CopyFromGpuMat) +{ + cv::Mat gold = randomMat(size, type); + cv::gpu::GpuMat d_gold(gold); + + cv::GlBuffer buf; + buf.copyFrom(d_gold, cv::GlBuffer::ARRAY_BUFFER, true); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); +} + +GPU_TEST_P(GlBuffer, CopyFromGlBuffer) +{ + cv::Mat gold = randomMat(size, type); + cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true); + + cv::GlBuffer buf; + buf.copyFrom(buf_gold, cv::GlBuffer::ARRAY_BUFFER, true); + + EXPECT_NE(buf_gold.bufId(), buf.bufId()); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); +} + +GPU_TEST_P(GlBuffer, CopyFromGlTexture) +{ + const int depth = CV_MAT_DEPTH(type); + const int cn = CV_MAT_CN(type); + + if (depth != CV_32F || cn == 2) + return; + + cv::Mat gold = randomMat(size, type, 0, 1.0); + cv::GlTexture tex_gold(gold, true); + + cv::GlBuffer buf; + buf.copyFrom(tex_gold, cv::GlBuffer::ARRAY_BUFFER, true); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 1e-2); +} + +GPU_TEST_P(GlBuffer, CopyToGpuMat) +{ + cv::Mat gold = randomMat(size, type); + + cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + + cv::gpu::GpuMat dst; + buf.copyTo(dst); + + EXPECT_MAT_NEAR(gold, dst, 0); +} + +GPU_TEST_P(GlBuffer, CopyToGlBuffer) +{ + cv::Mat gold = randomMat(size, type); + + cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + + cv::GlBuffer dst; + buf.copyTo(dst, cv::GlBuffer::ARRAY_BUFFER, true); + + EXPECT_NE(buf.bufId(), dst.bufId()); + + cv::Mat bufData; + dst.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); +} + +GPU_TEST_P(GlBuffer, CopyToGlTexture) +{ + const int depth = CV_MAT_DEPTH(type); + const int cn = CV_MAT_CN(type); + + if (depth != CV_32F || cn == 2) + return; + + cv::Mat gold = randomMat(size, type, 0, 1.0); + + cv::GlBuffer buf(gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true); + + cv::GlTexture tex; + buf.copyTo(tex, cv::GlBuffer::PIXEL_PACK_BUFFER, true); + + cv::Mat texData; + tex.copyTo(texData); + + EXPECT_MAT_NEAR(gold, texData, 1e-2); +} + +GPU_TEST_P(GlBuffer, Clone) +{ + cv::Mat gold = randomMat(size, type); + + cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + + cv::GlBuffer dst = buf.clone(cv::GlBuffer::ARRAY_BUFFER, true); + + EXPECT_NE(buf.bufId(), dst.bufId()); + + cv::Mat bufData; + dst.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); +} + +GPU_TEST_P(GlBuffer, MapHostRead) +{ + cv::Mat gold = randomMat(size, type); + + cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + + cv::Mat dst = buf.mapHost(cv::GlBuffer::READ_ONLY); + + EXPECT_MAT_NEAR(gold, dst, 0); + + buf.unmapHost(); +} + +GPU_TEST_P(GlBuffer, MapHostWrite) +{ + cv::Mat gold = randomMat(size, type); + + cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true); + + cv::Mat dst = buf.mapHost(cv::GlBuffer::WRITE_ONLY); + gold.copyTo(dst); + buf.unmapHost(); + dst.release(); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); +} + +GPU_TEST_P(GlBuffer, MapDevice) +{ + cv::Mat gold = randomMat(size, type); + + cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + + cv::gpu::GpuMat dst = buf.mapDevice(); + + EXPECT_MAT_NEAR(gold, dst, 0); + + buf.unmapDevice(); +} + +INSTANTIATE_TEST_CASE_P(OpenGL, GlBuffer, testing::Combine(DIFFERENT_SIZES, ALL_TYPES)); + +///////////////////////////////////////////// +// GlTexture + +PARAM_TEST_CASE(GlTexture, cv::Size, MatType) +{ + static void SetUpTestCase() + { + cv::namedWindow("test", cv::WINDOW_OPENGL); + } + + static void TearDownTestCase() + { + cv::destroyAllWindows(); + } + + cv::Size size; + int type; + int depth; + int cn; + cv::GlTexture::Format format; + + virtual void SetUp() + { + size = GET_PARAM(0); + type = GET_PARAM(1); + + depth = CV_MAT_DEPTH(type); + cn = CV_MAT_CN(type); + format = cn == 1 ? cv::GlTexture::DEPTH_COMPONENT : cn == 3 ? cv::GlTexture::RGB : cn == 4 ? cv::GlTexture::RGBA : cv::GlTexture::NONE; + } +}; + +GPU_TEST_P(GlTexture, Constructor1) +{ + cv::GlTexture tex(size.height, size.width, format, true); + + EXPECT_EQ(size.height, tex.rows()); + EXPECT_EQ(size.width, tex.cols()); + EXPECT_EQ(format, tex.format()); +} + +GPU_TEST_P(GlTexture, Constructor2) +{ + cv::GlTexture tex(size, format, true); + + EXPECT_EQ(size.height, tex.rows()); + EXPECT_EQ(size.width, tex.cols()); + EXPECT_EQ(format, tex.format()); +} + +GPU_TEST_P(GlTexture, ConstructorFromMat) +{ + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + + cv::GlTexture tex(gold, true); + + cv::Mat texData; + tex.copyTo(texData, depth); + + EXPECT_MAT_NEAR(gold, texData, 1e-2); +} + +GPU_TEST_P(GlTexture, ConstructorFromGpuMat) +{ + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + cv::gpu::GpuMat d_gold(gold); + + cv::GlTexture tex(d_gold, true); + + cv::Mat texData; + tex.copyTo(texData, depth); + + EXPECT_MAT_NEAR(gold, texData, 1e-2); +} + +GPU_TEST_P(GlTexture, ConstructorFromGlBuffer) +{ + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true); + + cv::GlTexture tex(buf_gold, true); + + cv::Mat texData; + tex.copyTo(texData, depth); + + EXPECT_MAT_NEAR(gold, texData, 1e-2); +} + +GPU_TEST_P(GlTexture, ConstructorFromGlTexture) +{ + cv::GlTexture tex_gold(size, format, true); + cv::GlTexture tex(tex_gold); + + EXPECT_EQ(tex_gold.texId(), tex.texId()); + EXPECT_EQ(tex_gold.rows(), tex.rows()); + EXPECT_EQ(tex_gold.cols(), tex.cols()); + EXPECT_EQ(tex_gold.format(), tex.format()); +} + +GPU_TEST_P(GlTexture, Create) +{ + cv::GlTexture tex; + tex.create(size.height, size.width, format, true); + + EXPECT_EQ(size.height, tex.rows()); + EXPECT_EQ(size.width, tex.cols()); + EXPECT_EQ(format, tex.format()); +} + +GPU_TEST_P(GlTexture, CopyFromMat) +{ + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + + cv::GlTexture tex; + tex.copyFrom(gold, true); + + cv::Mat texData; + tex.copyTo(texData, depth); + + EXPECT_MAT_NEAR(gold, texData, 1e-2); +} + +GPU_TEST_P(GlTexture, CopyFromGpuMat) +{ + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + cv::gpu::GpuMat d_gold(gold); + + cv::GlTexture tex; + tex.copyFrom(d_gold, true); + + cv::Mat texData; + tex.copyTo(texData, depth); + + EXPECT_MAT_NEAR(gold, texData, 1e-2); +} + +GPU_TEST_P(GlTexture, CopyFromGlBuffer) +{ + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true); + + cv::GlTexture tex; + tex.copyFrom(buf_gold, true); + + cv::Mat texData; + tex.copyTo(texData, depth); + + EXPECT_MAT_NEAR(gold, texData, 1e-2); +} + +GPU_TEST_P(GlTexture, CopyToGpuMat) +{ + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + + cv::GlTexture tex(gold, true); + + cv::gpu::GpuMat dst; + tex.copyTo(dst, depth); + + EXPECT_MAT_NEAR(gold, dst, 1e-2); +} + +GPU_TEST_P(GlTexture, CopyToGlBuffer) +{ + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + + cv::GlTexture tex(gold, true); + + cv::GlBuffer dst; + tex.copyTo(dst, depth, true); + + cv::Mat bufData; + dst.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 1e-2); +} + +INSTANTIATE_TEST_CASE_P(OpenGL, GlTexture, testing::Combine(DIFFERENT_SIZES, testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4))); + +#endif diff --git a/modules/gpu/test/test_precomp.hpp b/modules/gpu/test/test_precomp.hpp index ac172eb879..e7ade6aed7 100644 --- a/modules/gpu/test/test_precomp.hpp +++ b/modules/gpu/test/test_precomp.hpp @@ -70,6 +70,7 @@ #include #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" diff --git a/modules/highgui/include/opencv2/highgui/highgui.hpp b/modules/highgui/include/opencv2/highgui/highgui.hpp index 57aef6314d..43cf13dc13 100644 --- a/modules/highgui/include/opencv2/highgui/highgui.hpp +++ b/modules/highgui/include/opencv2/highgui/highgui.hpp @@ -125,16 +125,13 @@ CV_EXPORTS_W void setTrackbarPos(const string& trackbarname, const string& winna // OpenGL support -typedef void (*OpenGlDrawCallback)(void* userdata); +typedef void (CV_CDECL *OpenGlDrawCallback)(void* userdata); CV_EXPORTS void setOpenGlDrawCallback(const string& winname, OpenGlDrawCallback onOpenGlDraw, void* userdata = 0); CV_EXPORTS void setOpenGlContext(const string& winname); CV_EXPORTS void updateWindow(const string& winname); -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 CV_EXPORTS CvFont fontQt(const string& nameFont, int pointSize=-1, diff --git a/modules/highgui/src/precomp.hpp b/modules/highgui/src/precomp.hpp index 0cef4e77ae..9572e30100 100644 --- a/modules/highgui/src/precomp.hpp +++ b/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 diff --git a/modules/highgui/src/window.cpp b/modules/highgui/src/window.cpp index e6b3b1f7ab..05dee07e3f 100644 --- a/modules/highgui/src/window.cpp +++ b/modules/highgui/src/window.cpp @@ -40,6 +40,7 @@ //M*/ #include "precomp.hpp" +#include #include "opencv2/core/opengl_interop.hpp" // in later times, use this file as a dispatcher to implementations like cvcap.cpp @@ -240,94 +241,15 @@ void cv::updateWindow(const string& windowName) #ifdef HAVE_OPENGL namespace { - const int CV_TEXTURE_MAGIC_VAL = 0x00287653; - const int CV_POINT_CLOUD_MAGIC_VAL = 0x00287654; - - struct GlObjBase - { - int flag; - GlObjBase* next; - GlObjBase* prev; - std::string winname; - - virtual ~GlObjBase() {} - }; - - GlObjBase* g_glObjs = 0; - - GlObjBase* findGlObjByName(const std::string& winname) - { - GlObjBase* obj = g_glObjs; - - while(obj && obj->winname != winname) - obj = obj->next; - - return obj; - } - - void addGlObj(GlObjBase* glObj) - { - glObj->next = g_glObjs; - glObj->prev = 0; - if (g_glObjs) - g_glObjs->prev = glObj; - g_glObjs = glObj; - } - - void removeGlObj(GlObjBase* glObj) - { - if (glObj->prev) - glObj->prev->next = glObj->next; - else - g_glObjs = glObj->next; - - if (glObj->next) - glObj->next->prev = glObj->prev; - - delete glObj; - } - - struct GlObjTex : GlObjBase - { - cv::GlTexture tex; - }; + std::map wndTexs; + std::map ownWndTexs; + std::map ownWndBufs; void CV_CDECL glDrawTextureCallback(void* userdata) { - GlObjTex* texObj = static_cast(userdata); + cv::GlTexture* texObj = static_cast(userdata); - CV_DbgAssert(texObj->flag == CV_TEXTURE_MAGIC_VAL); - - static cv::GlCamera glCamera; - - glCamera.setupProjectionMatrix(); - - cv::render(texObj->tex); - } - - struct GlObjPointCloud : GlObjBase - { - cv::GlArrays arr; - cv::GlCamera camera; - }; - - void CV_CDECL glDrawPointCloudCallback(void* userdata) - { - GlObjPointCloud* pointCloudObj = static_cast(userdata); - - CV_DbgAssert(pointCloudObj->flag == CV_POINT_CLOUD_MAGIC_VAL); - - pointCloudObj->camera.setupProjectionMatrix(); - pointCloudObj->camera.setupModelViewMatrix(); - - cv::render(pointCloudObj->arr); - } - - void CV_CDECL glCleanCallback(void* userdata) - { - GlObjBase* glObj = static_cast(userdata); - - removeGlObj(glObj); + cv::render(*texObj); } } #endif // HAVE_OPENGL @@ -339,7 +261,8 @@ void cv::imshow( const string& winname, InputArray _img ) CvMat c_img = img; cvShowImage(winname.c_str(), &c_img); #else - double useGl = getWindowProperty(winname, WND_PROP_OPENGL); + const double useGl = getWindowProperty(winname, WND_PROP_OPENGL); + if (useGl <= 0) { Mat img = _img.getMat(); @@ -348,7 +271,7 @@ void cv::imshow( const string& winname, InputArray _img ) } else { - double autoSize = getWindowProperty(winname, WND_PROP_AUTOSIZE); + const double autoSize = getWindowProperty(winname, WND_PROP_AUTOSIZE); if (autoSize > 0) { @@ -358,145 +281,44 @@ void cv::imshow( const string& winname, InputArray _img ) setOpenGlContext(winname); - GlObjBase* glObj = findGlObjByName(winname); - - if (glObj && glObj->flag != CV_TEXTURE_MAGIC_VAL) + if (_img.kind() == _InputArray::OPENGL_TEXTURE) { - icvSetOpenGlCleanCallback(winname.c_str(), 0, 0); - glObj = 0; - } + cv::GlTexture& tex = wndTexs[winname]; - if (glObj) - { - GlObjTex* texObj = static_cast(glObj); - texObj->tex.copyFrom(_img); + tex = _img.getGlTexture(); + + tex.setAutoRelease(false); + + setOpenGlDrawCallback(winname, glDrawTextureCallback, &tex); } else { - GlObjTex* texObj = new GlObjTex; - texObj->tex.copyFrom(_img); + cv::GlTexture& tex = ownWndTexs[winname]; - glObj = texObj; - glObj->flag = CV_TEXTURE_MAGIC_VAL; - glObj->winname = winname; + if (_img.kind() == _InputArray::GPU_MAT) + { + cv::GlBuffer& buf = ownWndBufs[winname]; + buf.copyFrom(_img); + buf.setAutoRelease(false); - addGlObj(glObj); + tex.copyFrom(buf); + tex.setAutoRelease(false); + } + else + { + tex.copyFrom(_img); + } - icvSetOpenGlCleanCallback(winname.c_str(), glCleanCallback, glObj); + tex.setAutoRelease(false); + + setOpenGlDrawCallback(winname, glDrawTextureCallback, &tex); } - setOpenGlDrawCallback(winname, glDrawTextureCallback, glObj); - updateWindow(winname); } #endif } -void cv::pointCloudShow(const string& winname, const GlCamera& camera, const GlArrays& arr) -{ -#ifndef HAVE_OPENGL - CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); - (void)winname; - (void)camera; - (void)arr; -#else - namedWindow(winname, WINDOW_OPENGL); - - setOpenGlContext(winname); - - GlObjBase* glObj = findGlObjByName(winname); - - if (glObj && glObj->flag != CV_POINT_CLOUD_MAGIC_VAL) - { - icvSetOpenGlCleanCallback(winname.c_str(), 0, 0); - glObj = 0; - } - - if (glObj) - { - GlObjPointCloud* pointCloudObj = static_cast(glObj); - pointCloudObj->arr = arr; - pointCloudObj->camera = camera; - } - else - { - GlObjPointCloud* pointCloudObj = new GlObjPointCloud; - pointCloudObj->arr = arr; - pointCloudObj->camera = camera; - - glObj = pointCloudObj; - glObj->flag = CV_POINT_CLOUD_MAGIC_VAL; - glObj->winname = winname; - - addGlObj(glObj); - - icvSetOpenGlCleanCallback(winname.c_str(), glCleanCallback, glObj); - } - - setOpenGlDrawCallback(winname, glDrawPointCloudCallback, glObj); - - updateWindow(winname); -#endif -} - -void cv::pointCloudShow(const std::string& winname, const cv::GlCamera& camera, InputArray points, InputArray colors) -{ -#ifndef HAVE_OPENGL - (void)winname; - (void)camera; - (void)points; - (void)colors; - CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); -#else - namedWindow(winname, WINDOW_OPENGL); - - setOpenGlContext(winname); - - GlObjBase* glObj = findGlObjByName(winname); - - if (glObj && glObj->flag != CV_POINT_CLOUD_MAGIC_VAL) - { - icvSetOpenGlCleanCallback(winname.c_str(), 0, 0); - glObj = 0; - } - - if (glObj) - { - GlObjPointCloud* pointCloudObj = static_cast(glObj); - - pointCloudObj->arr.setVertexArray(points); - if (colors.empty()) - pointCloudObj->arr.resetColorArray(); - else - pointCloudObj->arr.setColorArray(colors); - - pointCloudObj->camera = camera; - } - else - { - GlObjPointCloud* pointCloudObj = new GlObjPointCloud; - - pointCloudObj->arr.setVertexArray(points); - if (!colors.empty()) - pointCloudObj->arr.setColorArray(colors); - - pointCloudObj->camera = camera; - - glObj = pointCloudObj; - glObj->flag = CV_POINT_CLOUD_MAGIC_VAL; - glObj->winname = winname; - - addGlObj(glObj); - - icvSetOpenGlCleanCallback(winname.c_str(), glCleanCallback, glObj); - } - - setOpenGlDrawCallback(winname, glDrawPointCloudCallback, glObj); - - updateWindow(winname); -#endif -} - // Without OpenGL #ifndef HAVE_OPENGL @@ -516,11 +338,6 @@ CV_IMPL void cvUpdateWindow(const char*) CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); } -void icvSetOpenGlCleanCallback(const char*, CvOpenGlCleanCallback, void*) -{ - CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); -} - #endif // !HAVE_OPENGL #if defined (HAVE_QT) diff --git a/modules/highgui/src/window_QT.cpp b/modules/highgui/src/window_QT.cpp index 973b23c0c0..50f2b9e787 100644 --- a/modules/highgui/src/window_QT.cpp +++ b/modules/highgui/src/window_QT.cpp @@ -685,20 +685,6 @@ CV_IMPL void cvSetOpenGlDrawCallback(const char* window_name, CvOpenGlDrawCallba } -void icvSetOpenGlCleanCallback(const char* window_name, CvOpenGlCleanCallback callback, void* userdata) -{ - if (!guiMainThread) - CV_Error( CV_StsNullPtr, "NULL guiReceiver (please create a window)" ); - - QMetaObject::invokeMethod(guiMainThread, - "setOpenGlCleanCallback", - Qt::AutoConnection, - Q_ARG(QString, QString(window_name)), - Q_ARG(void*, (void*)callback), - Q_ARG(void*, userdata)); -} - - CV_IMPL void cvSetOpenGlContext(const char* window_name) { if (!guiMainThread) @@ -1175,14 +1161,6 @@ void GuiReceiver::setOpenGlDrawCallback(QString name, void* callback, void* user w->setOpenGlDrawCallback((CvOpenGlDrawCallback) callback, userdata); } -void GuiReceiver::setOpenGlCleanCallback(QString name, void* callback, void* userdata) -{ - QPointer w = icvFindWindowByName(name); - - if (w) - w->setOpenGlCleanCallback((CvOpenGlCleanCallback) callback, userdata); -} - void GuiReceiver::setOpenGlContext(QString name) { QPointer w = icvFindWindowByName(name); @@ -1828,12 +1806,6 @@ void CvWindow::setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userda } -void CvWindow::setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata) -{ - myView->setOpenGlCleanCallback(callback, userdata); -} - - void CvWindow::makeCurrentOpenGlContext() { myView->makeCurrentOpenGlContext(); @@ -2420,12 +2392,6 @@ void DefaultViewPort::setOpenGlDrawCallback(CvOpenGlDrawCallback /*callback*/, v } -void DefaultViewPort::setOpenGlCleanCallback(CvOpenGlCleanCallback /*callback*/, void* /*userdata*/) -{ - CV_Error(CV_OpenGlNotSupported, "Window doesn't support OpenGL"); -} - - void DefaultViewPort::makeCurrentOpenGlContext() { CV_Error(CV_OpenGlNotSupported, "Window doesn't support OpenGL"); @@ -3074,19 +3040,10 @@ OpenGlViewPort::OpenGlViewPort(QWidget* _parent) : QGLWidget(_parent), size(-1, glDrawCallback = 0; glDrawData = 0; - - glCleanCallback = 0; - glCleanData = 0; - - glFuncTab = 0; } OpenGlViewPort::~OpenGlViewPort() { - if (glFuncTab) - delete glFuncTab; - - setOpenGlCleanCallback(0, 0); } QWidget* OpenGlViewPort::getWidget() @@ -3131,21 +3088,9 @@ void OpenGlViewPort::setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* glDrawData = userdata; } -void OpenGlViewPort::setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata) -{ - makeCurrentOpenGlContext(); - - if (glCleanCallback) - glCleanCallback(glCleanData); - - glCleanCallback = callback; - glCleanData = userdata; -} - void OpenGlViewPort::makeCurrentOpenGlContext() { makeCurrent(); - icvSetOpenGlFuncTab(glFuncTab); } void OpenGlViewPort::updateGl() @@ -3153,255 +3098,9 @@ void OpenGlViewPort::updateGl() QGLWidget::updateGL(); } -#ifndef APIENTRY - #define APIENTRY -#endif - -#ifndef APIENTRYP - #define APIENTRYP APIENTRY * -#endif - -#ifndef GL_VERSION_1_5 - /* GL types for handling large vertex buffer objects */ - typedef ptrdiff_t GLintptr; - typedef ptrdiff_t GLsizeiptr; -#endif - -typedef void (APIENTRYP PFNGLGENBUFFERSPROC ) (GLsizei n, GLuint *buffers); -typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers); - -typedef void (APIENTRYP PFNGLBUFFERDATAPROC ) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage); -typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); - -typedef void (APIENTRYP PFNGLBINDBUFFERPROC ) (GLenum target, GLuint buffer); - -typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERPROC) (GLenum target, GLenum access); -typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC) (GLenum target); - -class GlFuncTab_QT : public CvOpenGlFuncTab -{ -public: -#ifdef Q_WS_WIN - GlFuncTab_QT(HDC hDC); -#else - GlFuncTab_QT(); -#endif - - void genBuffers(int n, unsigned int* buffers) const; - void deleteBuffers(int n, const unsigned int* buffers) const; - - void bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const; - void bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const; - - void bindBuffer(unsigned int target, unsigned int buffer) const; - - void* mapBuffer(unsigned int target, unsigned int access) const; - void unmapBuffer(unsigned int target) const; - - void generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const; - - bool isGlContextInitialized() const; - - PFNGLGENBUFFERSPROC glGenBuffersExt; - PFNGLDELETEBUFFERSPROC glDeleteBuffersExt; - - PFNGLBUFFERDATAPROC glBufferDataExt; - PFNGLBUFFERSUBDATAPROC glBufferSubDataExt; - - PFNGLBINDBUFFERPROC glBindBufferExt; - - PFNGLMAPBUFFERPROC glMapBufferExt; - PFNGLUNMAPBUFFERPROC glUnmapBufferExt; - - bool initialized; - -#ifdef Q_WS_WIN - HDC hDC; -#endif -}; - -#ifdef Q_WS_WIN - GlFuncTab_QT::GlFuncTab_QT(HDC hDC_) : hDC(hDC_) -#else - GlFuncTab_QT::GlFuncTab_QT() -#endif -{ - glGenBuffersExt = 0; - glDeleteBuffersExt = 0; - - glBufferDataExt = 0; - glBufferSubDataExt = 0; - - glBindBufferExt = 0; - - glMapBufferExt = 0; - glUnmapBufferExt = 0; - - initialized = false; -} - -void GlFuncTab_QT::genBuffers(int n, unsigned int* buffers) const -{ - CV_FUNCNAME( "GlFuncTab_QT::genBuffers" ); - - __BEGIN__; - - if (!glGenBuffersExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glGenBuffersExt(n, buffers); - CV_CheckGlError(); - - __END__; -} - -void GlFuncTab_QT::deleteBuffers(int n, const unsigned int* buffers) const -{ - CV_FUNCNAME( "GlFuncTab_QT::deleteBuffers" ); - - __BEGIN__; - - if (!glDeleteBuffersExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glDeleteBuffersExt(n, buffers); - CV_CheckGlError(); - - __END__; -} - -void GlFuncTab_QT::bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const -{ - CV_FUNCNAME( "GlFuncTab_QT::bufferData" ); - - __BEGIN__; - - if (!glBufferDataExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBufferDataExt(target, size, data, usage); - CV_CheckGlError(); - - __END__; -} - -void GlFuncTab_QT::bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const -{ - CV_FUNCNAME( "GlFuncTab_QT::bufferSubData" ); - - __BEGIN__; - - if (!glBufferSubDataExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBufferSubDataExt(target, offset, size, data); - CV_CheckGlError(); - - __END__; -} - -void GlFuncTab_QT::bindBuffer(unsigned int target, unsigned int buffer) const -{ - CV_FUNCNAME( "GlFuncTab_QT::bindBuffer" ); - - __BEGIN__; - - if (!glBindBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBindBufferExt(target, buffer); - CV_CheckGlError(); - - __END__; -} - -void* GlFuncTab_QT::mapBuffer(unsigned int target, unsigned int access) const -{ - CV_FUNCNAME( "GlFuncTab_QT::mapBuffer" ); - - void* res = 0; - - __BEGIN__; - - if (!glMapBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - res = glMapBufferExt(target, access); - CV_CheckGlError(); - - __END__; - - return res; -} - -void GlFuncTab_QT::unmapBuffer(unsigned int target) const -{ - CV_FUNCNAME( "GlFuncTab_QT::unmapBuffer" ); - - __BEGIN__; - - if (!glUnmapBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glUnmapBufferExt(target); - CV_CheckGlError(); - - __END__; -} - -void GlFuncTab_QT::generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool /*underline*/, int start, int count, int base) const -{ -#ifdef Q_WS_WIN - CV_FUNCNAME( "GlFuncTab_QT::generateBitmapFont" ); -#endif - - QFont font(QString(family.c_str()), height, weight, italic); - - __BEGIN__; - -#ifndef Q_WS_WIN - font.setStyleStrategy(QFont::OpenGLCompatible); - if (font.handle()) - glXUseXFont(font.handle(), start, count, base); -#else - SelectObject(hDC, font.handle()); - if (!wglUseFontBitmaps(hDC, start, count, base)) - CV_ERROR(CV_OpenGlApiCallError, "Can't create font"); -#endif - - __END__; -} - -bool GlFuncTab_QT::isGlContextInitialized() const -{ - return initialized; -} - void OpenGlViewPort::initializeGL() { glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); - -#ifdef Q_WS_WIN - std::auto_ptr qglFuncTab(new GlFuncTab_QT(getDC())); -#else - std::auto_ptr qglFuncTab(new GlFuncTab_QT); -#endif - - // Load extensions - - qglFuncTab->glGenBuffersExt = (PFNGLGENBUFFERSPROC)context()->getProcAddress("glGenBuffers"); - qglFuncTab->glDeleteBuffersExt = (PFNGLDELETEBUFFERSPROC)context()->getProcAddress("glDeleteBuffers"); - qglFuncTab->glBufferDataExt = (PFNGLBUFFERDATAPROC)context()->getProcAddress("glBufferData"); - qglFuncTab->glBufferSubDataExt = (PFNGLBUFFERSUBDATAPROC)context()->getProcAddress("glBufferSubData"); - qglFuncTab->glBindBufferExt = (PFNGLBINDBUFFERPROC)context()->getProcAddress("glBindBuffer"); - qglFuncTab->glMapBufferExt = (PFNGLMAPBUFFERPROC)context()->getProcAddress("glMapBuffer"); - qglFuncTab->glUnmapBufferExt = (PFNGLUNMAPBUFFERPROC)context()->getProcAddress("glUnmapBuffer"); - - qglFuncTab->initialized = true; - - glFuncTab = qglFuncTab.release(); - - icvSetOpenGlFuncTab(glFuncTab); } void OpenGlViewPort::resizeGL(int w, int h) @@ -3411,14 +3110,10 @@ void OpenGlViewPort::resizeGL(int w, int h) void OpenGlViewPort::paintGL() { - icvSetOpenGlFuncTab(glFuncTab); - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if (glDrawCallback) glDrawCallback(glDrawData); - - CV_CheckGlError(); } void OpenGlViewPort::mousePressEvent(QMouseEvent* evnt) diff --git a/modules/highgui/src/window_QT.h b/modules/highgui/src/window_QT.h index 64faee0f41..1b07442dc9 100644 --- a/modules/highgui/src/window_QT.h +++ b/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(); diff --git a/modules/highgui/src/window_gtk.cpp b/modules/highgui/src/window_gtk.cpp index 99b16d93c1..3ee3d0c480 100644 --- a/modules/highgui/src/window_gtk.cpp +++ b/modules/highgui/src/window_gtk.cpp @@ -417,9 +417,6 @@ typedef struct CvWindow CvOpenGlDrawCallback glDrawCallback; void* glDrawData; - - CvOpenGlCleanCallback glCleanCallback; - void* glCleanData; #endif } CvWindow; @@ -692,238 +689,6 @@ double cvGetOpenGlProp_GTK(const char* name) namespace { - class GlFuncTab_GTK : public CvOpenGlFuncTab - { - public: - GlFuncTab_GTK(); - - void genBuffers(int n, unsigned int* buffers) const; - void deleteBuffers(int n, const unsigned int* buffers) const; - - void bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const; - void bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const; - - void bindBuffer(unsigned int target, unsigned int buffer) const; - - void* mapBuffer(unsigned int target, unsigned int access) const; - void unmapBuffer(unsigned int target) const; - - void generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const; - - bool isGlContextInitialized() const; - - PFNGLGENBUFFERSPROC glGenBuffersExt; - PFNGLDELETEBUFFERSPROC glDeleteBuffersExt; - - PFNGLBUFFERDATAPROC glBufferDataExt; - PFNGLBUFFERSUBDATAPROC glBufferSubDataExt; - - PFNGLBINDBUFFERPROC glBindBufferExt; - - PFNGLMAPBUFFERPROC glMapBufferExt; - PFNGLUNMAPBUFFERPROC glUnmapBufferExt; - - bool initialized; - }; - - GlFuncTab_GTK::GlFuncTab_GTK() - { - glGenBuffersExt = 0; - glDeleteBuffersExt = 0; - - glBufferDataExt = 0; - glBufferSubDataExt = 0; - - glBindBufferExt = 0; - - glMapBufferExt = 0; - glUnmapBufferExt = 0; - - initialized = false; - } - - void GlFuncTab_GTK::genBuffers(int n, unsigned int* buffers) const - { - CV_FUNCNAME( "GlFuncTab_GTK::genBuffers" ); - - __BEGIN__; - - if (!glGenBuffersExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glGenBuffersExt(n, buffers); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_GTK::deleteBuffers(int n, const unsigned int* buffers) const - { - CV_FUNCNAME( "GlFuncTab_GTK::deleteBuffers" ); - - __BEGIN__; - - if (!glDeleteBuffersExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glDeleteBuffersExt(n, buffers); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_GTK::bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const - { - CV_FUNCNAME( "GlFuncTab_GTK::bufferData" ); - - __BEGIN__; - - if (!glBufferDataExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBufferDataExt(target, size, data, usage); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_GTK::bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const - { - CV_FUNCNAME( "GlFuncTab_GTK::bufferSubData" ); - - __BEGIN__; - - if (!glBufferSubDataExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBufferSubDataExt(target, offset, size, data); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_GTK::bindBuffer(unsigned int target, unsigned int buffer) const - { - CV_FUNCNAME( "GlFuncTab_GTK::bindBuffer" ); - - __BEGIN__; - - if (!glBindBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBindBufferExt(target, buffer); - CV_CheckGlError(); - - __END__; - } - - void* GlFuncTab_GTK::mapBuffer(unsigned int target, unsigned int access) const - { - CV_FUNCNAME( "GlFuncTab_GTK::mapBuffer" ); - - void* res = 0; - - __BEGIN__; - - if (!glMapBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - res = glMapBufferExt(target, access); - CV_CheckGlError(); - - __END__; - - return res; - } - - void GlFuncTab_GTK::unmapBuffer(unsigned int target) const - { - CV_FUNCNAME( "GlFuncTab_GTK::unmapBuffer" ); - - __BEGIN__; - - if (!glUnmapBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glUnmapBufferExt(target); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_GTK::generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool /*underline*/, int start, int count, int base) const - { - PangoFontDescription* fontDecr; - PangoFont* pangoFont; - - CV_FUNCNAME( "GlFuncTab_GTK::generateBitmapFont" ); - - __BEGIN__; - - fontDecr = pango_font_description_new(); - - pango_font_description_set_size(fontDecr, height); - - pango_font_description_set_family_static(fontDecr, family.c_str()); - - pango_font_description_set_weight(fontDecr, static_cast(weight)); - - pango_font_description_set_style(fontDecr, italic ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL); - - pangoFont = gdk_gl_font_use_pango_font(fontDecr, start, count, base); - - pango_font_description_free(fontDecr); - - if (!pangoFont) - CV_ERROR(CV_OpenGlApiCallError, "Can't create font"); - - __END__; - } - - bool GlFuncTab_GTK::isGlContextInitialized() const - { - return initialized; - } - - void initGl() - { - static GlFuncTab_GTK glFuncTab; - static bool first = true; - - if (first) - { - // Load extensions - GdkGLProc func; - - func = gdk_gl_get_proc_address("glGenBuffers"); - glFuncTab.glGenBuffersExt = (PFNGLGENBUFFERSPROC)func; - - func = gdk_gl_get_proc_address("glDeleteBuffers"); - glFuncTab.glDeleteBuffersExt = (PFNGLDELETEBUFFERSPROC)func; - - func = gdk_gl_get_proc_address("glBufferData"); - glFuncTab.glBufferDataExt = (PFNGLBUFFERDATAPROC)func; - - func = gdk_gl_get_proc_address("glBufferSubData"); - glFuncTab.glBufferSubDataExt = (PFNGLBUFFERSUBDATAPROC)func; - - func = gdk_gl_get_proc_address("glBindBuffer"); - glFuncTab.glBindBufferExt = (PFNGLBINDBUFFERPROC)func; - - func = gdk_gl_get_proc_address("glMapBuffer"); - glFuncTab.glMapBufferExt = (PFNGLMAPBUFFERPROC)func; - - func = gdk_gl_get_proc_address("glUnmapBuffer"); - glFuncTab.glUnmapBufferExt = (PFNGLUNMAPBUFFERPROC)func; - - glFuncTab.initialized = true; - - icvSetOpenGlFuncTab(&glFuncTab); - - first = false; - } - } - void createGlContext(CvWindow* window) { GdkGLConfig* glconfig; @@ -932,8 +697,6 @@ namespace __BEGIN__; - window->useGl = false; - // Try double-buffered visual glconfig = gdk_gl_config_new_by_mode((GdkGLConfigMode)(GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE)); if (!glconfig) @@ -943,24 +706,11 @@ namespace if (!gtk_widget_set_gl_capability(window->widget, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE)) CV_ERROR( CV_OpenGlApiCallError, "Can't Create A GL Device Context" ); - initGl(); - window->useGl = true; __END__; } - void releaseGlContext(CvWindow* window) - { - //CV_FUNCNAME( "releaseGlContext" ); - - //__BEGIN__; - - window->useGl = false; - - //__END__; - } - void drawGl(CvWindow* window) { CV_FUNCNAME( "drawGl" ); @@ -980,8 +730,6 @@ namespace if (window->glDrawCallback) window->glDrawCallback(window->glDrawData); - CV_CheckGlError(); - if (gdk_gl_drawable_is_double_buffered (gldrawable)) gdk_gl_drawable_swap_buffers(gldrawable); else @@ -1101,9 +849,6 @@ CV_IMPL int cvNamedWindow( const char* name, int flags ) window->glDrawCallback = 0; window->glDrawData = 0; - - window->glCleanCallback = 0; - window->glCleanData = 0; #endif // @@ -1233,40 +978,6 @@ CV_IMPL void cvSetOpenGlDrawCallback(const char* name, CvOpenGlDrawCallback call __END__; } -void icvSetOpenGlCleanCallback(const char* name, CvOpenGlCleanCallback callback, void* userdata) -{ - CvWindow* window; - GdkGLContext* glcontext; - GdkGLDrawable* gldrawable; - - CV_FUNCNAME( "icvSetOpenGlCleanCallback" ); - - __BEGIN__; - - if (!name) - CV_ERROR(CV_StsNullPtr, "NULL name string"); - - window = icvFindWindowByName(name); - if (!window) - EXIT; - - if (!window->useGl) - CV_ERROR( CV_OpenGlNotSupported, "Window doesn't support OpenGL" ); - - glcontext = gtk_widget_get_gl_context(window->widget); - gldrawable = gtk_widget_get_gl_drawable(window->widget); - - gdk_gl_drawable_make_current(gldrawable, glcontext); - - if (window->glCleanCallback) - window->glCleanCallback(window->glCleanData); - - window->glCleanCallback = callback; - window->glCleanData = userdata; - - __END__; -} - #endif // HAVE_OPENGL @@ -1276,25 +987,6 @@ static void icvDeleteWindow( CvWindow* window ) { CvTrackbar* trackbar; -#ifdef HAVE_OPENGL - if (window->useGl) - { - GdkGLContext* glcontext = gtk_widget_get_gl_context(window->widget); - GdkGLDrawable* gldrawable = gtk_widget_get_gl_drawable(window->widget); - - gdk_gl_drawable_make_current(gldrawable, glcontext); - - if (window->glCleanCallback) - { - window->glCleanCallback(window->glCleanData); - window->glCleanCallback = 0; - window->glCleanData = 0; - } - - releaseGlContext(window); - } -#endif - if( window->prev ) window->prev->next = window->next; else diff --git a/modules/highgui/src/window_w32.cpp b/modules/highgui/src/window_w32.cpp index 348420afdb..094819740d 100644 --- a/modules/highgui/src/window_w32.cpp +++ b/modules/highgui/src/window_w32.cpp @@ -192,11 +192,6 @@ typedef struct CvWindow CvOpenGlDrawCallback glDrawCallback; void* glDrawData; - - CvOpenGlCleanCallback glCleanCallback; - void* glCleanData; - - CvOpenGlFuncTab* glFuncTab; #endif } CvWindow; @@ -580,272 +575,8 @@ double cvGetOpenGlProp_W32(const char* name) #ifdef HAVE_OPENGL -#ifndef APIENTRY - #define APIENTRY -#endif - -#ifndef APIENTRYP - #define APIENTRYP APIENTRY * -#endif - -#ifndef GL_VERSION_1_5 - /* GL types for handling large vertex buffer objects */ - typedef ptrdiff_t GLintptr; - typedef ptrdiff_t GLsizeiptr; -#endif - namespace { - typedef void (APIENTRYP PFNGLGENBUFFERSPROC ) (GLsizei n, GLuint *buffers); - typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers); - - typedef void (APIENTRYP PFNGLBUFFERDATAPROC ) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage); - typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); - - typedef void (APIENTRYP PFNGLBINDBUFFERPROC ) (GLenum target, GLuint buffer); - - typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERPROC) (GLenum target, GLenum access); - typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC) (GLenum target); - - class GlFuncTab_W32 : public CvOpenGlFuncTab - { - public: - GlFuncTab_W32(HDC hDC); - - void genBuffers(int n, unsigned int* buffers) const; - void deleteBuffers(int n, const unsigned int* buffers) const; - - void bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const; - void bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const; - - void bindBuffer(unsigned int target, unsigned int buffer) const; - - void* mapBuffer(unsigned int target, unsigned int access) const; - void unmapBuffer(unsigned int target) const; - - void generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const; - - bool isGlContextInitialized() const; - - PFNGLGENBUFFERSPROC glGenBuffersExt; - PFNGLDELETEBUFFERSPROC glDeleteBuffersExt; - - PFNGLBUFFERDATAPROC glBufferDataExt; - PFNGLBUFFERSUBDATAPROC glBufferSubDataExt; - - PFNGLBINDBUFFERPROC glBindBufferExt; - - PFNGLMAPBUFFERPROC glMapBufferExt; - PFNGLUNMAPBUFFERPROC glUnmapBufferExt; - - bool initialized; - - HDC hDC; - }; - - GlFuncTab_W32::GlFuncTab_W32(HDC hDC_) - { - glGenBuffersExt = 0; - glDeleteBuffersExt = 0; - - glBufferDataExt = 0; - glBufferSubDataExt = 0; - - glBindBufferExt = 0; - - glMapBufferExt = 0; - glUnmapBufferExt = 0; - - initialized = false; - - hDC = hDC_; - } - - void GlFuncTab_W32::genBuffers(int n, unsigned int* buffers) const - { - CV_FUNCNAME( "GlFuncTab_W32::genBuffers" ); - - __BEGIN__; - - if (!glGenBuffersExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glGenBuffersExt(n, buffers); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_W32::deleteBuffers(int n, const unsigned int* buffers) const - { - CV_FUNCNAME( "GlFuncTab_W32::deleteBuffers" ); - - __BEGIN__; - - if (!glDeleteBuffersExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glDeleteBuffersExt(n, buffers); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_W32::bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const - { - CV_FUNCNAME( "GlFuncTab_W32::bufferData" ); - - __BEGIN__; - - if (!glBufferDataExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBufferDataExt(target, size, data, usage); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_W32::bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const - { - CV_FUNCNAME( "GlFuncTab_W32::bufferSubData" ); - - __BEGIN__; - - if (!glBufferSubDataExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBufferSubDataExt(target, offset, size, data); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_W32::bindBuffer(unsigned int target, unsigned int buffer) const - { - CV_FUNCNAME( "GlFuncTab_W32::bindBuffer" ); - - __BEGIN__; - - if (!glBindBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBindBufferExt(target, buffer); - CV_CheckGlError(); - - __END__; - } - - void* GlFuncTab_W32::mapBuffer(unsigned int target, unsigned int access) const - { - CV_FUNCNAME( "GlFuncTab_W32::mapBuffer" ); - - void* res = 0; - - __BEGIN__; - - if (!glMapBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - res = glMapBufferExt(target, access); - CV_CheckGlError(); - - __END__; - - return res; - } - - void GlFuncTab_W32::unmapBuffer(unsigned int target) const - { - CV_FUNCNAME( "GlFuncTab_W32::unmapBuffer" ); - - __BEGIN__; - - if (!glUnmapBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glUnmapBufferExt(target); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_W32::generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const - { - HFONT font; - - CV_FUNCNAME( "GlFuncTab_W32::generateBitmapFont" ); - - __BEGIN__; - - font = CreateFont - ( - -height, // height - 0, // cell width - 0, // Angle of Escapement - 0, // Orientation Angle - weight, // font weight - italic ? TRUE : FALSE, // Italic - underline ? TRUE : FALSE, // Underline - FALSE, // StrikeOut - ANSI_CHARSET, // CharSet - OUT_TT_PRECIS, // OutPrecision - CLIP_DEFAULT_PRECIS, // ClipPrecision - ANTIALIASED_QUALITY, // Quality - FF_DONTCARE | DEFAULT_PITCH, // PitchAndFamily - family.c_str() // FaceName - ); - - SelectObject(hDC, font); - - if (!wglUseFontBitmaps(hDC, start, count, base)) - CV_ERROR(CV_OpenGlApiCallError, "Can't create font"); - - __END__; - } - - bool GlFuncTab_W32::isGlContextInitialized() const - { - return initialized; - } - - void initGl(CvWindow* window) - { - glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); - - std::auto_ptr glFuncTab(new GlFuncTab_W32(window->dc)); - - // Load extensions - PROC func; - - func = wglGetProcAddress("glGenBuffers"); - glFuncTab->glGenBuffersExt = (PFNGLGENBUFFERSPROC)func; - - func = wglGetProcAddress("glDeleteBuffers"); - glFuncTab->glDeleteBuffersExt = (PFNGLDELETEBUFFERSPROC)func; - - func = wglGetProcAddress("glBufferData"); - glFuncTab->glBufferDataExt = (PFNGLBUFFERDATAPROC)func; - - func = wglGetProcAddress("glBufferSubData"); - glFuncTab->glBufferSubDataExt = (PFNGLBUFFERSUBDATAPROC)func; - - func = wglGetProcAddress("glBindBuffer"); - glFuncTab->glBindBufferExt = (PFNGLBINDBUFFERPROC)func; - - func = wglGetProcAddress("glMapBuffer"); - glFuncTab->glMapBufferExt = (PFNGLMAPBUFFERPROC)func; - - func = wglGetProcAddress("glUnmapBuffer"); - glFuncTab->glUnmapBufferExt = (PFNGLUNMAPBUFFERPROC)func; - - glFuncTab->initialized = true; - - window->glFuncTab = glFuncTab.release(); - - icvSetOpenGlFuncTab(window->glFuncTab); - } - void createGlContext(HWND hWnd, HDC& hGLDC, HGLRC& hGLRC, bool& useGl) { CV_FUNCNAME( "createGlContext" ); @@ -907,8 +638,6 @@ namespace __BEGIN__; - delete window->glFuncTab; - if (window->hGLRC) { wglDeleteContext(window->hGLRC); @@ -940,8 +669,6 @@ namespace if (window->glDrawCallback) window->glDrawCallback(window->glDrawData); - CV_CheckGlError(); - if (!SwapBuffers(window->dc)) CV_ERROR( CV_OpenGlApiCallError, "Can't swap OpenGL buffers" ); @@ -1042,7 +769,6 @@ CV_IMPL int cvNamedWindow( const char* name, int flags ) #ifndef HAVE_OPENGL window->dc = CreateCompatibleDC(0); #else - window->glFuncTab = 0; if (!useGl) { window->dc = CreateCompatibleDC(0); @@ -1054,14 +780,10 @@ CV_IMPL int cvNamedWindow( const char* name, int flags ) window->dc = hGLDC; window->hGLRC = hGLRC; window->useGl = true; - initGl(window); } window->glDrawCallback = 0; window->glDrawData = 0; - - window->glCleanCallback = 0; - window->glCleanData = 0; #endif window->last_key = 0; @@ -1112,8 +834,6 @@ CV_IMPL void cvSetOpenGlContext(const char* name) if (!wglMakeCurrent(window->dc, window->hGLRC)) CV_ERROR( CV_OpenGlApiCallError, "Can't Activate The GL Rendering Context" ); - icvSetOpenGlFuncTab(window->glFuncTab); - __END__; } @@ -1161,30 +881,6 @@ CV_IMPL void cvSetOpenGlDrawCallback(const char* name, CvOpenGlDrawCallback call __END__; } -void icvSetOpenGlCleanCallback(const char* name, CvOpenGlCleanCallback callback, void* userdata) -{ - CV_FUNCNAME( "icvSetOpenGlCleanCallback" ); - - __BEGIN__; - - CvWindow* window; - - if (!name) - CV_ERROR(CV_StsNullPtr, "NULL name string"); - - window = icvFindWindowByName(name); - if (!window) - EXIT; - - if (window->glCleanCallback) - window->glCleanCallback(window->glCleanData); - - window->glCleanCallback = callback; - window->glCleanData = userdata; - - __END__; -} - #endif // HAVE_OPENGL static void icvRemoveWindow( CvWindow* window ) @@ -1194,18 +890,7 @@ static void icvRemoveWindow( CvWindow* window ) #ifdef HAVE_OPENGL if (window->useGl) - { - wglMakeCurrent(window->dc, window->hGLRC); - - if (window->glCleanCallback) - { - window->glCleanCallback(window->glCleanData); - window->glCleanCallback = 0; - window->glCleanData = 0; - } - releaseGlContext(window); - } #endif if( window->frame ) diff --git a/samples/cpp/point_cloud.cpp b/samples/cpp/point_cloud.cpp deleted file mode 100644 index 2780df38e7..0000000000 --- a/samples/cpp/point_cloud.cpp +++ /dev/null @@ -1,353 +0,0 @@ -#include -#include -#include -#include -#include - -#include "opencv2/core/core.hpp" -#include "opencv2/core/opengl_interop.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" -#include "opencv2/calib3d/calib3d.hpp" -#include "opencv2/contrib/contrib.hpp" - -using namespace std; -using namespace cv; -using namespace cv::gpu; - -class PointCloudRenderer -{ -public: - PointCloudRenderer(const Mat& points, const Mat& img, double scale); - - void onMouseEvent(int event, int x, int y, int flags); - void draw(); - void update(int key, double aspect); - - int fov_; - -private: - int mouse_dx_; - int mouse_dy_; - - double yaw_; - double pitch_; - Point3d pos_; - - TickMeter tm_; - static const int step_; - int frame_; - - GlCamera camera_; - GlArrays pointCloud_; - string fps_; -}; - -bool stop = false; - -static void mouseCallback(int event, int x, int y, int flags, void* userdata) -{ - if (stop) - return; - - PointCloudRenderer* renderer = static_cast(userdata); - renderer->onMouseEvent(event, x, y, flags); -} - -static void openGlDrawCallback(void* userdata) -{ - if (stop) - return; - - PointCloudRenderer* renderer = static_cast(userdata); - renderer->draw(); -} - -int main(int argc, const char* argv[]) -{ - const char* keys = - "{ l | left | | left image file name }" - "{ r | right | | right image file name }" - "{ i | intrinsic | | intrinsic camera parameters file name }" - "{ e | extrinsic | | extrinsic camera parameters file name }" - "{ d | ndisp | 256 | number of disparities }" - "{ s | scale | 1.0 | scale factor for point cloud }" - "{ h | help | false | print help message }"; - - CommandLineParser cmd(argc, argv, keys); - - if (cmd.get("help")) - { - cout << "Avaible options:" << endl; - cmd.printParams(); - return 0; - } - - string left = cmd.get("left"); - string right = cmd.get("right"); - string intrinsic = cmd.get("intrinsic"); - string extrinsic = cmd.get("extrinsic"); - int ndisp = cmd.get("ndisp"); - double scale = cmd.get("scale"); - - if (left.empty() || right.empty()) - { - cout << "Missed input images" << endl; - cout << "Avaible options:" << endl; - cmd.printParams(); - return 0; - } - - if (intrinsic.empty() ^ extrinsic.empty()) - { - cout << "Boss camera parameters must be specified" << endl; - cout << "Avaible options:" << endl; - cmd.printParams(); - return 0; - } - - Mat imgLeftColor = imread(left, IMREAD_COLOR); - Mat imgRightColor = imread(right, IMREAD_COLOR); - - if (imgLeftColor.empty()) - { - cout << "Can't load image " << left << endl; - return -1; - } - - if (imgRightColor.empty()) - { - cout << "Can't load image " << right << endl; - return -1; - } - - Mat Q = Mat::eye(4, 4, CV_32F); - if (!intrinsic.empty() && !extrinsic.empty()) - { - FileStorage fs; - - // reading intrinsic parameters - fs.open(intrinsic, CV_STORAGE_READ); - if (!fs.isOpened()) - { - cout << "Failed to open file " << intrinsic << endl; - return -1; - } - - Mat M1, D1, M2, D2; - fs["M1"] >> M1; - fs["D1"] >> D1; - fs["M2"] >> M2; - fs["D2"] >> D2; - - // reading extrinsic parameters - fs.open(extrinsic, CV_STORAGE_READ); - if (!fs.isOpened()) - { - cout << "Failed to open file " << extrinsic << endl; - return -1; - } - - Mat R, T, R1, P1, R2, P2; - fs["R"] >> R; - fs["T"] >> T; - - Size img_size = imgLeftColor.size(); - - Rect roi1, roi2; - stereoRectify(M1, D1, M2, D2, img_size, R, T, R1, R2, P1, P2, Q, CALIB_ZERO_DISPARITY, -1, img_size, &roi1, &roi2); - - Mat map11, map12, map21, map22; - initUndistortRectifyMap(M1, D1, R1, P1, img_size, CV_16SC2, map11, map12); - initUndistortRectifyMap(M2, D2, R2, P2, img_size, CV_16SC2, map21, map22); - - Mat img1r, img2r; - remap(imgLeftColor, img1r, map11, map12, INTER_LINEAR); - remap(imgRightColor, img2r, map21, map22, INTER_LINEAR); - - imgLeftColor = img1r(roi1); - imgRightColor = img2r(roi2); - } - - Mat imgLeftGray, imgRightGray; - cvtColor(imgLeftColor, imgLeftGray, COLOR_BGR2GRAY); - cvtColor(imgRightColor, imgRightGray, COLOR_BGR2GRAY); - - cvtColor(imgLeftColor, imgLeftColor, COLOR_BGR2RGB); - - Mat disp, points; - - StereoBM bm(0, ndisp); - - bm(imgLeftGray, imgRightGray, disp); - disp.convertTo(disp, CV_8U, 1.0 / 16.0); - - disp = disp(Range(21, disp.rows - 21), Range(ndisp, disp.cols - 21)).clone(); - imgLeftColor = imgLeftColor(Range(21, imgLeftColor.rows - 21), Range(ndisp, imgLeftColor.cols - 21)).clone(); - - reprojectImageTo3D(disp, points, Q); - - const string windowName = "OpenGL Sample"; - - namedWindow(windowName, WINDOW_OPENGL); - resizeWindow(windowName, 400, 400); - - PointCloudRenderer renderer(points, imgLeftColor, scale); - - createTrackbar("Fov", windowName, &renderer.fov_, 100); - setMouseCallback(windowName, mouseCallback, &renderer); - setOpenGlDrawCallback(windowName, openGlDrawCallback, &renderer); - - for(;;) - { - int key = waitKey(10); - - if (key >= 0) - key = key & 0xff; - - if (key == 27) - { - stop = true; - break; - } - - double aspect = getWindowProperty(windowName, WND_PROP_ASPECT_RATIO); - - key = tolower(key); - - renderer.update(key, aspect); - - updateWindow(windowName); - } - - return 0; -} - -const int PointCloudRenderer::step_ = 20; - -PointCloudRenderer::PointCloudRenderer(const Mat& points, const Mat& img, double scale) -{ - mouse_dx_ = 0; - mouse_dy_ = 0; - - fov_ = 0; - yaw_ = 0.0; - pitch_ = 0.0; - - frame_ = 0; - - camera_.setScale(Point3d(scale, scale, scale)); - - pointCloud_.setVertexArray(points); - pointCloud_.setColorArray(img, false); - - tm_.start(); -} - -inline int clamp(int val, int minVal, int maxVal) -{ - return max(min(val, maxVal), minVal); -} - -void PointCloudRenderer::onMouseEvent(int event, int x, int y, int /*flags*/) -{ - static int oldx = x; - static int oldy = y; - static bool moving = false; - - if (event == EVENT_LBUTTONDOWN) - { - oldx = x; - oldy = y; - moving = true; - } - else if (event == EVENT_LBUTTONUP) - { - moving = false; - } - - if (moving) - { - mouse_dx_ = oldx - x; - mouse_dy_ = oldy - y; - } - else - { - mouse_dx_ = 0; - mouse_dy_ = 0; - } - - const int mouseClamp = 300; - mouse_dx_ = clamp(mouse_dx_, -mouseClamp, mouseClamp); - mouse_dy_ = clamp(mouse_dy_, -mouseClamp, mouseClamp); -} - -static Point3d rotate(Point3d v, double yaw, double pitch) -{ - Point3d t1; - t1.x = v.x * cos(-yaw / 180.0 * CV_PI) - v.z * sin(-yaw / 180.0 * CV_PI); - t1.y = v.y; - t1.z = v.x * sin(-yaw / 180.0 * CV_PI) + v.z * cos(-yaw / 180.0 * CV_PI); - - Point3d t2; - t2.x = t1.x; - t2.y = t1.y * cos(pitch / 180.0 * CV_PI) - t1.z * sin(pitch / 180.0 * CV_PI); - t2.z = t1.y * sin(pitch / 180.0 * CV_PI) + t1.z * cos(pitch / 180.0 * CV_PI); - - return t2; -} - -void PointCloudRenderer::update(int key, double aspect) -{ - const Point3d dirVec(0.0, 0.0, -1.0); - const Point3d upVec(0.0, 1.0, 0.0); - const Point3d leftVec(-1.0, 0.0, 0.0); - - const double posStep = 0.1; - - const double mouseStep = 0.001; - - camera_.setPerspectiveProjection(30.0 + fov_ / 100.0 * 40.0, aspect, 0.1, 1000.0); - - yaw_ += mouse_dx_ * mouseStep; - pitch_ += mouse_dy_ * mouseStep; - - if (key == 'w') - pos_ += posStep * rotate(dirVec, yaw_, pitch_); - else if (key == 's') - pos_ -= posStep * rotate(dirVec, yaw_, pitch_); - else if (key == 'a') - pos_ += posStep * rotate(leftVec, yaw_, pitch_); - else if (key == 'd') - pos_ -= posStep * rotate(leftVec, yaw_, pitch_); - else if (key == 'q') - pos_ += posStep * rotate(upVec, yaw_, pitch_); - else if (key == 'e') - pos_ -= posStep * rotate(upVec, yaw_, pitch_); - - camera_.setCameraPos(pos_, yaw_, pitch_, 0.0); - - tm_.stop(); - - if (frame_++ >= step_) - { - ostringstream ostr; - ostr << "FPS: " << step_ / tm_.getTimeSec(); - fps_ = ostr.str(); - - frame_ = 0; - tm_.reset(); - } - - tm_.start(); -} - -void PointCloudRenderer::draw() -{ - camera_.setupProjectionMatrix(); - camera_.setupModelViewMatrix(); - - render(pointCloud_); - - render(fps_, GlFont::get("Courier New", 16), Scalar::all(255), Point2d(3.0, 0.0)); -} diff --git a/samples/gpu/brox_optical_flow.cpp b/samples/gpu/brox_optical_flow.cpp index 9942a885c0..4a4ffe39d6 100644 --- a/samples/gpu/brox_optical_flow.cpp +++ b/samples/gpu/brox_optical_flow.cpp @@ -4,7 +4,6 @@ #include "cvconfig.h" #include "opencv2/core/core.hpp" -#include "opencv2/core/opengl_interop.hpp" #include "opencv2/highgui/highgui.hpp" #include "opencv2/gpu/gpu.hpp" @@ -14,12 +13,6 @@ using namespace cv::gpu; void getFlowField(const Mat& u, const Mat& v, Mat& flowField); -#ifdef HAVE_OPENGL - -void needleMapDraw(void* userdata); - -#endif - int main(int argc, const char* argv[]) { try @@ -80,12 +73,8 @@ int main(int argc, const char* argv[]) namedWindow("Forward flow"); namedWindow("Backward flow"); - namedWindow("Needle Map", WINDOW_OPENGL); - namedWindow("Interpolated frame"); - setGlDevice(); - cout << "Press:" << endl; cout << "\tESC to quit" << endl; cout << "\t'a' to move to the previous frame" << endl; @@ -124,14 +113,6 @@ int main(int argc, const char* argv[]) Mat flowFieldBackward; getFlowField(Mat(d_bu), Mat(d_bv), flowFieldBackward); -#ifdef HAVE_OPENGL - cout << "Create Optical Flow Needle Map..." << endl; - - GpuMat d_vertex, d_colors; - - createOpticalFlowNeedleMap(d_fu, d_fv, d_vertex, d_colors); -#endif - cout << "Interpolating..." << endl; // first frame color components @@ -196,14 +177,6 @@ int main(int argc, const char* argv[]) imshow("Forward flow", flowFieldForward); imshow("Backward flow", flowFieldBackward); -#ifdef HAVE_OPENGL - GlArrays arr; - arr.setVertexArray(d_vertex); - arr.setColorArray(d_colors, false); - - setOpenGlDrawCallback("Needle Map", needleMapDraw, &arr); -#endif - int currentFrame = 0; imshow("Interpolated frame", frames[currentFrame]); @@ -292,22 +265,4 @@ void getFlowField(const Mat& u, const Mat& v, Mat& flowField) row[j][3] = 255; } } -} - -#ifdef HAVE_OPENGL - -void needleMapDraw(void* userdata) -{ - const GlArrays* arr = static_cast(userdata); - - GlCamera camera; - camera.setOrthoProjection(0.0, 1.0, 1.0, 0.0, 0.0, 1.0); - camera.lookAt(Point3d(0.0, 0.0, 1.0), Point3d(0.0, 0.0, 0.0), Point3d(0.0, 1.0, 0.0)); - - camera.setupProjectionMatrix(); - camera.setupModelViewMatrix(); - - render(*arr, RenderMode::TRIANGLES); -} - -#endif +} \ No newline at end of file diff --git a/samples/gpu/highgui_gpu.cpp b/samples/gpu/highgui_gpu.cpp deleted file mode 100644 index 368a6f6084..0000000000 --- a/samples/gpu/highgui_gpu.cpp +++ /dev/null @@ -1,135 +0,0 @@ -#include -#include - -#include "opencv2/core/core.hpp" -#include "opencv2/core/gpumat.hpp" -#include "opencv2/core/opengl_interop.hpp" -#include "opencv2/gpu/gpu.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/contrib/contrib.hpp" - -using namespace std; -using namespace cv; -using namespace cv::gpu; - -struct Timer -{ - Timer(const string& msg_) - { - msg = msg_; - - tm.reset(); - tm.start(); - } - - ~Timer() - { - tm.stop(); - cout << msg << " " << tm.getTimeMilli() << " ms\n"; - } - - string msg; - TickMeter tm; -}; - -int main(int argc, char* argv[]) -{ - if (argc < 2) - { - cout << "Usage: " << argv[0] << " image" << endl; - return -1; - } - - try - { - bool haveCuda = getCudaEnabledDeviceCount() > 0; - - const string openGlMatWnd = "OpenGL Mat"; - const string openGlBufferWnd = "OpenGL GlBuffer"; - const string openGlTextureWnd = "OpenGL GlTexture"; - const string openGlGpuMatWnd = "OpenGL GpuMat"; - const string matWnd = "Mat"; - - namedWindow(openGlMatWnd, WINDOW_OPENGL | WINDOW_AUTOSIZE); - namedWindow(openGlBufferWnd, WINDOW_OPENGL | WINDOW_AUTOSIZE); - namedWindow(openGlTextureWnd, WINDOW_OPENGL | WINDOW_AUTOSIZE); - if (haveCuda) - namedWindow(openGlGpuMatWnd, WINDOW_OPENGL | WINDOW_AUTOSIZE); - namedWindow("Mat", WINDOW_AUTOSIZE); - - Mat img = imread(argv[1]); - - if (haveCuda) - setGlDevice(); - - setOpenGlContext(openGlBufferWnd); - GlBuffer buf(img, GlBuffer::TEXTURE_BUFFER); - - setOpenGlContext(openGlTextureWnd); - GlTexture tex(img); - - GpuMat d_img; - if (haveCuda) - d_img.upload(img); - - cout << "=== First call\n\n"; - - { - Timer t("OpenGL Mat "); - imshow(openGlMatWnd, img); - } - { - Timer t("OpenGL GlBuffer "); - imshow(openGlBufferWnd, buf); - } - { - Timer t("OpenGL GlTexture"); - imshow(openGlTextureWnd, tex); - } - if (haveCuda) - { - Timer t("OpenGL GpuMat "); - imshow(openGlGpuMatWnd, d_img); - } - { - Timer t("Mat "); - imshow(matWnd, img); - } - - waitKey(); - - cout << "\n=== Second call\n\n"; - - { - Timer t("OpenGL Mat "); - imshow(openGlMatWnd, img); - } - { - Timer t("OpenGL GlBuffer "); - imshow(openGlBufferWnd, buf); - } - { - Timer t("OpenGL GlTexture"); - imshow(openGlTextureWnd, tex); - } - if (haveCuda) - { - Timer t("OpenGL GpuMat "); - imshow(openGlGpuMatWnd, d_img); - } - { - Timer t("Mat "); - imshow(matWnd, img); - } - - cout << "\n"; - - waitKey(); - } - catch(const exception& e) - { - cout << e.what() << endl; - } - - return 0; -} diff --git a/samples/gpu/opengl.cpp b/samples/gpu/opengl.cpp new file mode 100644 index 0000000000..11243377d4 --- /dev/null +++ b/samples/gpu/opengl.cpp @@ -0,0 +1,125 @@ +#include +#include "cvconfig.h" + +#ifndef HAVE_OPENGL +int main() +{ + std::cerr << "Library was built without OpenGL support" << std::endl; + return -1; +} +#else + +#ifdef WIN32 + #define WIN32_LEAN_AND_MEAN 1 + #define NOMINMAX 1 + #include +#endif + +#if defined(__APPLE__) + #include + #include +#else + #include + #include +#endif + +#include "opencv2/core/core.hpp" +#include "opencv2/core/opengl_interop.hpp" +#include "opencv2/core/gpumat.hpp" +#include "opencv2/highgui/highgui.hpp" + +using namespace std; +using namespace cv; +using namespace cv::gpu; + +const int win_width = 800; +const int win_height = 640; + +struct DrawData +{ + GlArrays arr; + GlTexture tex; + GlBuffer indices; +}; + +void CV_CDECL draw(void* userdata); + +void CV_CDECL draw(void* userdata) +{ + static double angle = 0.0; + + DrawData* data = static_cast(userdata); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + gluPerspective(45.0, (double)win_width / win_height, 0.1, 100.0); + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + gluLookAt(0, 0, 3, 0, 0, 0, 0, 1, 0); + glRotated(angle, 0, 1, 0); + + glEnable(GL_TEXTURE_2D); + data->tex.bind(); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexEnvi(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_REPLACE); + + glDisable(GL_CULL_FACE); + + render(data->arr, data->indices, RenderMode::TRIANGLES); + + angle += 0.3; +} + +int main(int argc, char* argv[]) +{ + if (argc < 2) + { + cout << "Usage: " << argv[0] << " image" << endl; + return -1; + } + + Mat img = imread(argv[1]); + if (img.empty()) + { + cerr << "Can't open image " << argv[1] << endl; + return -1; + } + + namedWindow("OpenGL", WINDOW_OPENGL); + resizeWindow("OpenGL", win_width, win_height); + + Mat_ vertex(1, 4); + vertex << Vec2f(-1, 1), Vec2f(-1, -1), Vec2f(1, -1), Vec2f(1, 1); + + Mat_ texCoords(1, 4); + texCoords << Vec2f(0, 0), Vec2f(0, 1), Vec2f(1, 1), Vec2f(1, 0); + + Mat_ indices(1, 6); + indices << 0, 1, 2, 2, 3, 0; + + DrawData data; + + data.arr.setVertexArray(vertex); + data.arr.setTexCoordArray(texCoords); + data.indices.copyFrom(indices); + data.tex.copyFrom(img); + + setOpenGlDrawCallback("OpenGL", draw, &data); + + for (;;) + { + updateWindow("OpenGL"); + int key = waitKey(10); + if ((key & 0xff) == 27) + break; + } + + setOpenGlDrawCallback("OpenGL", 0, 0); + destroyAllWindows(); + + return 0; +} + +#endif \ No newline at end of file diff --git a/samples/gpu/pyrlk_optical_flow.cpp b/samples/gpu/pyrlk_optical_flow.cpp index 1f26665465..5ccd66009b 100644 --- a/samples/gpu/pyrlk_optical_flow.cpp +++ b/samples/gpu/pyrlk_optical_flow.cpp @@ -3,7 +3,6 @@ #include "cvconfig.h" #include "opencv2/core/core.hpp" -#include "opencv2/core/opengl_interop.hpp" #include "opencv2/imgproc/imgproc.hpp" #include "opencv2/highgui/highgui.hpp" #include "opencv2/video/video.hpp" @@ -66,40 +65,6 @@ static void drawArrows(Mat& frame, const vector& prevPts, const vector< } } -#ifdef HAVE_OPENGL - -struct DrawData -{ - GlTexture tex; - GlArrays arr; -}; - -static void drawCallback(void* userdata) -{ - DrawData* data = static_cast(userdata); - - if (data->tex.empty() || data->arr.empty()) - return; - - static GlCamera camera; - static bool init_camera = true; - - if (init_camera) - { - camera.setOrthoProjection(0.0, 1.0, 1.0, 0.0, 0.0, 1.0); - camera.lookAt(Point3d(0.0, 0.0, 1.0), Point3d(0.0, 0.0, 0.0), Point3d(0.0, 1.0, 0.0)); - init_camera = false; - } - - camera.setupProjectionMatrix(); - camera.setupModelViewMatrix(); - - render(data->tex); - render(data->arr, RenderMode::TRIANGLES); -} - -#endif - template inline T clamp (T x, T a, T b) { return ((x) > (a) ? ((x) < (b) ? (x) : (b)) : (a)); @@ -200,12 +165,6 @@ int main(int argc, const char* argv[]) namedWindow("PyrLK [Sparse]", WINDOW_NORMAL); namedWindow("PyrLK [Dense] Flow Field", WINDOW_NORMAL); - #ifdef HAVE_OPENGL - namedWindow("PyrLK [Dense]", WINDOW_OPENGL); - - setGlDevice(); - #endif - cout << "Image size : " << frame0.cols << " x " << frame0.rows << endl; cout << "Points count : " << points << endl; @@ -271,21 +230,6 @@ int main(int argc, const char* argv[]) imshow("PyrLK [Dense] Flow Field", flowField); - #ifdef HAVE_OPENGL - setOpenGlContext("PyrLK [Dense]"); - - GpuMat d_vertex, d_colors; - createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors); - - DrawData drawData; - - drawData.tex.copyFrom(d_frame0Gray); - drawData.arr.setVertexArray(d_vertex); - drawData.arr.setColorArray(d_colors, false); - - setOpenGlDrawCallback("PyrLK [Dense]", drawCallback, &drawData); - #endif - waitKey(); return 0; From 637b48eec8cc6c547c77ff25667100e1d5b368b8 Mon Sep 17 00:00:00 2001 From: Alexander Smorkalov Date: Tue, 12 Feb 2013 17:53:36 +0400 Subject: [PATCH 02/24] Tutorial for ARM Linux cross compilation added. --- doc/tutorials/definitions/tocDefinitions.rst | 1 + .../arm_crosscompile_with_cmake.rst | 115 ++++++++++++++++++ .../table_of_content_introduction.rst | 25 +++- 3 files changed, 139 insertions(+), 2 deletions(-) create mode 100644 doc/tutorials/introduction/crosscompilation/arm_crosscompile_with_cmake.rst diff --git a/doc/tutorials/definitions/tocDefinitions.rst b/doc/tutorials/definitions/tocDefinitions.rst index 49ada684eb..946dbb0a47 100644 --- a/doc/tutorials/definitions/tocDefinitions.rst +++ b/doc/tutorials/definitions/tocDefinitions.rst @@ -10,3 +10,4 @@ .. |Author_AlexB| unicode:: Alexandre U+0020 Benoit .. |Author_EricCh| unicode:: Eric U+0020 Christiansen .. |Author_AndreyP| unicode:: Andrey U+0020 Pavlenko +.. |Author_AlexS| unicode:: Alexander U+0020 Smorkalov diff --git a/doc/tutorials/introduction/crosscompilation/arm_crosscompile_with_cmake.rst b/doc/tutorials/introduction/crosscompilation/arm_crosscompile_with_cmake.rst new file mode 100644 index 0000000000..c40b86c974 --- /dev/null +++ b/doc/tutorials/introduction/crosscompilation/arm_crosscompile_with_cmake.rst @@ -0,0 +1,115 @@ + +.. _ARM-Linux-cross-compile: + +Cross compilation for ARM based Linux systems +********************************************* + +This steps are tested on Ubuntu Linux 12.04, but should work for other Linux distributions. +I case of other distributions package names and names of cross compilation tools may differ. +There are several popular EABI versions that are used on ARM platform. This tutorial is +written for *gnueabi* and *gnueabihf*, but other variants should work with minimal changes. + + +Prerequisites +============= + + * Host computer with Linux; + * Git; + * CMake 2.6 or higher; + * Cross compilation tools for ARM: gcc, libstc++, etc. Depending on target platform you need + to choose *gnueabi* or *gnueabihf* tools. + Install command for *gnueabi*: + + .. code-block:: bash + + sudo apt-get install gcc-arm-linux-gnueabi + + Install command for *gnueabihf*: + + .. code-block:: bash + + sudo apt-get install gcc-arm-linux-gnueabihf + + * pkgconfig; + * Python 2.6 for host system; + * [optional] ffmpeg or libav development packages for armeabi(hf): libavcodec-dev, libavformat-dev, libswscale-dev; + * [optional] GTK+2.x or higher, including headers (libgtk2.0-dev) for armeabi(hf); + * [optional] libdc1394 2.x; + * [optional] libjpeg-dev, libpng-dev, libtiff-dev, libjasper-dev for armeabi(hf). + + +Getting OpenCV Source Code +========================== + +You can use the latest stable OpenCV version available in *sourceforge* or you can grab the latest +snapshot from our `Git repository `_. + + +Getting the Latest Stable OpenCV Version +---------------------------------------- + +* Go to our `page on Sourceforge `_; + +* Download the source tarball and unpack it. + + +Getting the Cutting-edge OpenCV from the Git Repository +------------------------------------------------------- + +Launch Git client and clone `OpenCV repository `_ + +In Linux it can be achieved with the following command in Terminal: + +.. code-block:: bash + + cd ~/ + git clone https://github.com/Itseez/opencv.git + + +Building OpenCV +=============== + +#. Create a build directory, make it current and run the following command: + + .. code-block:: bash + + cmake [] -DCMAKE_TOOLCHAIN_FILE=/platforms/linux/arm-gnueabi.toolchain.cmake + + Toolchain uses *gnueabihf* EABI convention by default. Add ``-DSOFTFP=ON`` cmake argument to switch on softfp compiler. + + .. code-block:: bash + + cmake [] -DSOFTFP=ON -DCMAKE_TOOLCHAIN_FILE=/platforms/linux/arm-gnueabi.toolchain.cmake + + For example: + + .. code-block:: bash + + cd ~/opencv/platforms/linux + mkdir -p build_hardfp + cd build_hardfp + + cmake -DCMAKE_TOOLCHAIN_FILE=../arm-gnueabi.toolchain.cmake ../../.. + +#. Run make in build () directory: + + .. code-block:: bash + + make + +.. note:: + + Optionally you can strip symbols info from the created library via install/strip make target. + This option produces smaller binary (~ twice smaller) but makes further debugging harder. + +Enable hardware optimizations +----------------------------- + +Depending on target platfrom architecture different instruction sets can be used. By default +compiler generates code for armv5l without VFPv3 and NEON extensions. Add ``-DUSE_VFPV3=ON`` +to cmake command line to enable code generation for VFPv3 and ``-DUSE_NEON=ON`` for using +NEON SIMD extensions. + +TBB is supported on multi core ARM SoCs also. +Add ``-DWITH_TBB=ON`` and ``-DBUILD_TBB=ON`` to enable it. Cmake scripts download TBB sources +from official project site ``_ and build it. diff --git a/doc/tutorials/introduction/table_of_content_introduction/table_of_content_introduction.rst b/doc/tutorials/introduction/table_of_content_introduction/table_of_content_introduction.rst index 504e5e5639..5e91a5392c 100644 --- a/doc/tutorials/introduction/table_of_content_introduction/table_of_content_introduction.rst +++ b/doc/tutorials/introduction/table_of_content_introduction/table_of_content_introduction.rst @@ -3,7 +3,9 @@ Introduction to OpenCV ----------------------------------------------------------- -Here you can read tutorials about how to set up your computer to work with the OpenCV library. Additionaly you can find a few very basic sample source code that will let introduce you to the world of the OpenCV. +Here you can read tutorials about how to set up your computer to work with the OpenCV library. +Additionally you can find a few very basic sample source code that will let introduce you to the +world of the OpenCV. .. include:: ../../definitions/tocDefinitions.rst @@ -189,6 +191,24 @@ Here you can read tutorials about how to set up your computer to work with the O .. |Install_iOS| image:: images/opencv_ios.png :width: 90pt +* **Embedded Linux** + + .. tabularcolumns:: m{100pt} m{300pt} + .. cssclass:: toctableopencv + + =========== ====================================================== + |Usage_1| **Title:** :ref:`ARM-Linux-cross-compile` + + *Compatibility:* > OpenCV 2.4.4 + + *Author:* |Author_AlexS| + + We will learn how to setup OpenCV cross compilation environment for ARM Linux. + + =========== ====================================================== + +* **Common** + .. tabularcolumns:: m{100pt} m{300pt} .. cssclass:: toctableopencv @@ -249,7 +269,7 @@ Here you can read tutorials about how to set up your computer to work with the O \pagebreak -.. We use a custom table of content format and as the table of content only imforms Sphinx about the hierarchy of the files, no need to show it. +.. We use a custom table of content format and as the table of content only informs Sphinx about the hierarchy of the files, no need to show it. .. toctree:: :hidden: @@ -263,6 +283,7 @@ Here you can read tutorials about how to set up your computer to work with the O ../android_binary_package/O4A_SDK ../android_binary_package/dev_with_OCV_on_Android ../ios_install/ios_install + ../crosscompilation/arm_crosscompile_with_cmake ../display_image/display_image ../load_save_image/load_save_image ../how_to_write_a_tutorial/how_to_write_a_tutorial From 429ae44ae357a05af9248ffdb3d1e59b765fb379 Mon Sep 17 00:00:00 2001 From: yao Date: Wed, 20 Feb 2013 17:46:43 +0800 Subject: [PATCH 03/24] add openCLExecuteKernelInterop method --- modules/ocl/include/opencv2/ocl/ocl.hpp | 18 ++++ modules/ocl/src/initialization.cpp | 134 +++++++++++++++++++++++- 2 files changed, 151 insertions(+), 1 deletion(-) diff --git a/modules/ocl/include/opencv2/ocl/ocl.hpp b/modules/ocl/include/opencv2/ocl/ocl.hpp index bd31c170d3..fcaff4e549 100644 --- a/modules/ocl/include/opencv2/ocl/ocl.hpp +++ b/modules/ocl/include/opencv2/ocl/ocl.hpp @@ -125,6 +125,24 @@ namespace cv Impl *impl; }; + //! Calls a kernel, by string. Pass globalThreads = NULL, and cleanUp = true, to finally clean-up without executing. + CV_EXPORTS double openCLExecuteKernelInterop(Context *clCxt , + const char **source, string kernelName, + size_t globalThreads[3], size_t localThreads[3], + std::vector< std::pair > &args, + int channels, int depth, const char *build_options, + bool finish = true, bool measureKernelTime = false, + bool cleanUp = true); + + //! Calls a kernel, by file. Pass globalThreads = NULL, and cleanUp = true, to finally clean-up without executing. + CV_EXPORTS double openCLExecuteKernelInterop(Context *clCxt , + const char **fileName, const int numFiles, string kernelName, + size_t globalThreads[3], size_t localThreads[3], + std::vector< std::pair > &args, + int channels, int depth, const char *build_options, + bool finish = true, bool measureKernelTime = false, + bool cleanUp = true); + class CV_EXPORTS oclMatExpr; //////////////////////////////// oclMat //////////////////////////////// class CV_EXPORTS oclMat diff --git a/modules/ocl/src/initialization.cpp b/modules/ocl/src/initialization.cpp index 643626bce1..8f8c19b945 100644 --- a/modules/ocl/src/initialization.cpp +++ b/modules/ocl/src/initialization.cpp @@ -47,6 +47,7 @@ #include "precomp.hpp" #include +#include #include "binarycaching.hpp" using namespace cv; @@ -729,8 +730,139 @@ namespace cv cout << "average kernel total time: " << total_kernel_time / RUN_TIMES << endl; // "ms" << endl; #endif } + + double openCLExecuteKernelInterop(Context *clCxt , const char **source, string kernelName, + size_t globalThreads[3], size_t localThreads[3], + vector< pair > &args, int channels, int depth, const char *build_options, + bool finish, bool measureKernelTime, bool cleanUp) - cl_mem load_constant(cl_context context, cl_command_queue command_queue, const void *value, + { + //construct kernel name + //The rule is functionName_Cn_Dn, C represent Channels, D Represent DataType Depth, n represent an integer number + //for exmaple split_C2_D2, represent the split kernel with channels =2 and dataType Depth = 2(Data type is char) + stringstream idxStr; + if(channels != -1) + idxStr << "_C" << channels; + if(depth != -1) + idxStr << "_D" << depth; + kernelName += idxStr.str(); + + cl_kernel kernel; + kernel = openCLGetKernelFromSource(clCxt, source, kernelName, build_options); + + double kernelTime = 0.0; + + if( globalThreads != NULL) + { + if ( localThreads != NULL) + { + globalThreads[0] = divUp(globalThreads[0], localThreads[0]) * localThreads[0]; + globalThreads[1] = divUp(globalThreads[1], localThreads[1]) * localThreads[1]; + globalThreads[2] = divUp(globalThreads[2], localThreads[2]) * localThreads[2]; + + //size_t blockSize = localThreads[0] * localThreads[1] * localThreads[2]; + cv::ocl::openCLVerifyKernel(clCxt, kernel, localThreads); + } + for(size_t i = 0; i < args.size(); i ++) + openCLSafeCall(clSetKernelArg(kernel, i, args[i].first, args[i].second)); + + if(measureKernelTime == false) + { + openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 3, NULL, globalThreads, + localThreads, 0, NULL, NULL)); + } + else + { + cl_event event = NULL; + openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 3, NULL, globalThreads, + localThreads, 0, NULL, &event)); + + cl_ulong end_time, queue_time; + + openCLSafeCall(clWaitForEvents(1, &event)); + + openCLSafeCall(clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END, + sizeof(cl_ulong), &end_time, 0)); + + openCLSafeCall(clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_QUEUED, + sizeof(cl_ulong), &queue_time, 0)); + + kernelTime = (double)(end_time - queue_time) / (1000 * 1000); + + clReleaseEvent(event); + } + } + + if(finish) + { + clFinish(clCxt->impl->clCmdQueue); + } + + if(cleanUp) + { + openCLSafeCall(clReleaseKernel(kernel)); + } + + return kernelTime; + } + + // Converts the contents of a file into a string + static int convertToString(const char *filename, std::string& s) + { + size_t size; + char* str; + + std::fstream f(filename, (std::fstream::in | std::fstream::binary)); + if(f.is_open()) + { + size_t fileSize; + f.seekg(0, std::fstream::end); + size = fileSize = (size_t)f.tellg(); + f.seekg(0, std::fstream::beg); + + str = new char[size+1]; + if(!str) + { + f.close(); + return -1; + } + + f.read(str, fileSize); + f.close(); + str[size] = '\0'; + + s = str; + delete[] str; + return 0; + } + printf("Error: Failed to open file %s\n", filename); + return -1; + } + + double openCLExecuteKernelInterop(Context *clCxt , const char **fileName, const int numFiles, string kernelName, + size_t globalThreads[3], size_t localThreads[3], + vector< pair > &args, int channels, int depth, const char *build_options, + bool finish, bool measureKernelTime, bool cleanUp) + + { + std::vector fsource; + for (int i = 0 ; i < numFiles ; i++) + { + std::string str; + if (convertToString(fileName[i], str) >= 0) + fsource.push_back(str); + } + const char **source = new const char *[numFiles]; + for (int i = 0 ; i < numFiles ; i++) + source[i] = fsource[i].c_str(); + double kernelTime = openCLExecuteKernelInterop(clCxt ,source, kernelName, globalThreads, localThreads, + args, channels, depth, build_options, finish, measureKernelTime, cleanUp); + fsource.clear(); + delete []source; + return kernelTime; + } + + cl_mem load_constant(cl_context context, cl_command_queue command_queue, const void *value, const size_t size) { int status; From a567c03fdfc8ddfd5f760e32930ff84b4b25cae4 Mon Sep 17 00:00:00 2001 From: Anna Kogan Date: Wed, 6 Feb 2013 14:53:33 +0400 Subject: [PATCH 04/24] Switched to TEST_CYCLE_MULTIRUN for fast tests --- modules/core/perf/perf_compare.cpp | 3 ++- modules/core/perf/perf_convertTo.cpp | 4 ++-- modules/core/perf/perf_mat.cpp | 6 ++++-- modules/core/perf/perf_merge.cpp | 3 ++- modules/core/perf/perf_split.cpp | 4 ++-- modules/core/perf/perf_stat.cpp | 3 ++- modules/imgproc/perf/perf_cvt_color.cpp | 4 ++-- modules/imgproc/perf/perf_threshold.cpp | 4 ++-- 8 files changed, 18 insertions(+), 13 deletions(-) diff --git a/modules/core/perf/perf_compare.cpp b/modules/core/perf/perf_compare.cpp index 32f8ba7682..5fb755d956 100644 --- a/modules/core/perf/perf_compare.cpp +++ b/modules/core/perf/perf_compare.cpp @@ -52,7 +52,8 @@ PERF_TEST_P( Size_MatType_CmpType, compareScalar, declare.in(src1, src2, WARMUP_RNG).out(dst); - TEST_CYCLE() cv::compare(src1, src2, dst, cmpType); + int runs = (sz.width <= 640) ? 8 : 1; + TEST_CYCLE_MULTIRUN(runs) cv::compare(src1, src2, dst, cmpType); SANITY_CHECK(dst); } diff --git a/modules/core/perf/perf_convertTo.cpp b/modules/core/perf/perf_convertTo.cpp index c4e832f1f7..8007361228 100644 --- a/modules/core/perf/perf_convertTo.cpp +++ b/modules/core/perf/perf_convertTo.cpp @@ -29,9 +29,9 @@ PERF_TEST_P( Size_DepthSrc_DepthDst_Channels_alpha, convertTo, Mat src(sz, CV_MAKETYPE(depthSrc, channels)); randu(src, 0, 255); Mat dst(sz, CV_MAKETYPE(depthDst, channels)); - declare.iterations(500); - TEST_CYCLE() src.convertTo(dst, depthDst, alpha); + int runs = (sz.width <= 640) ? 8 : 1; + TEST_CYCLE_MULTIRUN(runs) src.convertTo(dst, depthDst, alpha); SANITY_CHECK(dst, alpha == 1.0 ? 1e-12 : 1e-7); } diff --git a/modules/core/perf/perf_mat.cpp b/modules/core/perf/perf_mat.cpp index 3749feb384..79a3ecd1ff 100644 --- a/modules/core/perf/perf_mat.cpp +++ b/modules/core/perf/perf_mat.cpp @@ -18,7 +18,8 @@ PERF_TEST_P(Size_MatType, Mat_Eye, declare.out(diagonalMatrix); - TEST_CYCLE() + int runs = (size.width <= 640) ? 15 : 5; + TEST_CYCLE_MULTIRUN(runs) { diagonalMatrix = Mat::eye(size, type); } @@ -38,7 +39,8 @@ PERF_TEST_P(Size_MatType, Mat_Zeros, declare.out(zeroMatrix); - TEST_CYCLE() + int runs = (size.width <= 640) ? 15 : 5; + TEST_CYCLE_MULTIRUN(runs) { zeroMatrix = Mat::zeros(size, type); } diff --git a/modules/core/perf/perf_merge.cpp b/modules/core/perf/perf_merge.cpp index d10cc81542..d82941a92b 100644 --- a/modules/core/perf/perf_merge.cpp +++ b/modules/core/perf/perf_merge.cpp @@ -30,7 +30,8 @@ PERF_TEST_P( Size_SrcDepth_DstChannels, merge, } Mat dst; - TEST_CYCLE() merge( (vector &)mv, dst ); + int runs = (sz.width <= 640) ? 8 : 1; + TEST_CYCLE_MULTIRUN(runs) merge( (vector &)mv, dst ); SANITY_CHECK(dst, 1e-12); } \ No newline at end of file diff --git a/modules/core/perf/perf_split.cpp b/modules/core/perf/perf_split.cpp index f5de9b6707..df9095fc61 100644 --- a/modules/core/perf/perf_split.cpp +++ b/modules/core/perf/perf_split.cpp @@ -26,8 +26,8 @@ PERF_TEST_P( Size_Depth_Channels, split, randu(m, 0, 255); vector mv; - - TEST_CYCLE() split(m, (vector&)mv); + int runs = (sz.width <= 640) ? 8 : 1; + TEST_CYCLE_MULTIRUN(runs) split(m, (vector&)mv); SANITY_CHECK(mv, 1e-12); } diff --git a/modules/core/perf/perf_stat.cpp b/modules/core/perf/perf_stat.cpp index 79e849e081..b7fc43d120 100644 --- a/modules/core/perf/perf_stat.cpp +++ b/modules/core/perf/perf_stat.cpp @@ -97,7 +97,8 @@ PERF_TEST_P(Size_MatType, countNonZero, testing::Combine( testing::Values( TYPIC declare.in(src, WARMUP_RNG); - TEST_CYCLE() cnt = countNonZero(src); + int runs = (sz.width <= 640) ? 8 : 1; + TEST_CYCLE_MULTIRUN(runs) cnt = countNonZero(src); SANITY_CHECK(cnt); } diff --git a/modules/imgproc/perf/perf_cvt_color.cpp b/modules/imgproc/perf/perf_cvt_color.cpp index 3919539ef5..fd1d0459a8 100644 --- a/modules/imgproc/perf/perf_cvt_color.cpp +++ b/modules/imgproc/perf/perf_cvt_color.cpp @@ -299,10 +299,10 @@ PERF_TEST_P(Size_CvtMode2, cvtColorYUV420, Mat src(sz.height + sz.height / 2, sz.width, CV_8UC(ch.scn)); Mat dst(sz, CV_8UC(ch.dcn)); - declare.time(100); declare.in(src, WARMUP_RNG).out(dst); - TEST_CYCLE() cvtColor(src, dst, mode, ch.dcn); + int runs = (sz.width <= 640) ? 8 : 1; + TEST_CYCLE_MULTIRUN(runs) cvtColor(src, dst, mode, ch.dcn); SANITY_CHECK(dst, 1); } diff --git a/modules/imgproc/perf/perf_threshold.cpp b/modules/imgproc/perf/perf_threshold.cpp index dd1602cd20..8727b6339e 100644 --- a/modules/imgproc/perf/perf_threshold.cpp +++ b/modules/imgproc/perf/perf_threshold.cpp @@ -31,9 +31,9 @@ PERF_TEST_P(Size_MatType_ThreshType, threshold, double maxval = theRNG().uniform(1, 254); declare.in(src, WARMUP_RNG).out(dst); - declare.iterations(500); - TEST_CYCLE() threshold(src, dst, thresh, maxval, threshType); + int runs = (sz.width <= 640) ? 8 : 1; + TEST_CYCLE_MULTIRUN(runs) threshold(src, dst, thresh, maxval, threshType); SANITY_CHECK(dst); } From f6e0d327b05dc584b527189147eeef8b29acdeed Mon Sep 17 00:00:00 2001 From: Anna Kogan Date: Wed, 20 Feb 2013 16:59:17 +0400 Subject: [PATCH 05/24] Increased time limits --- modules/imgproc/perf/perf_matchTemplate.cpp | 6 ++++-- modules/video/perf/perf_tvl1optflow.cpp | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/modules/imgproc/perf/perf_matchTemplate.cpp b/modules/imgproc/perf/perf_matchTemplate.cpp index 0c727d5a48..a89435b535 100644 --- a/modules/imgproc/perf/perf_matchTemplate.cpp +++ b/modules/imgproc/perf/perf_matchTemplate.cpp @@ -33,7 +33,8 @@ PERF_TEST_P(ImgSize_TmplSize_Method, matchTemplateSmall, declare .in(img, WARMUP_RNG) .in(tmpl, WARMUP_RNG) - .out(result); + .out(result) + .time(30); TEST_CYCLE() matchTemplate(img, tmpl, result, method); @@ -66,7 +67,8 @@ PERF_TEST_P(ImgSize_TmplSize_Method, matchTemplateBig, declare .in(img, WARMUP_RNG) .in(tmpl, WARMUP_RNG) - .out(result); + .out(result) + .time(30); TEST_CYCLE() matchTemplate(img, tmpl, result, method); diff --git a/modules/video/perf/perf_tvl1optflow.cpp b/modules/video/perf/perf_tvl1optflow.cpp index ad90915128..36f16d9943 100644 --- a/modules/video/perf/perf_tvl1optflow.cpp +++ b/modules/video/perf/perf_tvl1optflow.cpp @@ -13,7 +13,7 @@ pair impair(const char* im1, const char* im2) PERF_TEST_P(ImagePair, OpticalFlowDual_TVL1, testing::Values(impair("cv/optflow/RubberWhale1.png", "cv/optflow/RubberWhale2.png"))) { - declare.time(40); + declare.time(260); Mat frame1 = imread(getDataPath(GetParam().first), IMREAD_GRAYSCALE); Mat frame2 = imread(getDataPath(GetParam().second), IMREAD_GRAYSCALE); From ce2559b332a537f784e405645c7191b4610964be Mon Sep 17 00:00:00 2001 From: Vladislav Vinogradov Date: Tue, 19 Feb 2013 16:16:23 +0400 Subject: [PATCH 06/24] optimized DeviceInfo class and ensureSizeIsEnough --- modules/core/include/opencv2/core/gpumat.hpp | 33 +- modules/core/src/gpumat.cpp | 351 +++++++++++-------- 2 files changed, 219 insertions(+), 165 deletions(-) diff --git a/modules/core/include/opencv2/core/gpumat.hpp b/modules/core/include/opencv2/core/gpumat.hpp index c2bf124906..66daa96a14 100644 --- a/modules/core/include/opencv2/core/gpumat.hpp +++ b/modules/core/include/opencv2/core/gpumat.hpp @@ -73,12 +73,16 @@ namespace cv { namespace gpu FEATURE_SET_COMPUTE_20 = 20, FEATURE_SET_COMPUTE_21 = 21, FEATURE_SET_COMPUTE_30 = 30, + FEATURE_SET_COMPUTE_35 = 35, + GLOBAL_ATOMICS = FEATURE_SET_COMPUTE_11, SHARED_ATOMICS = FEATURE_SET_COMPUTE_12, NATIVE_DOUBLE = FEATURE_SET_COMPUTE_13, - WARP_SHUFFLE_FUNCTIONS = FEATURE_SET_COMPUTE_30 + WARP_SHUFFLE_FUNCTIONS = FEATURE_SET_COMPUTE_30, + DYNAMIC_PARALLELISM = FEATURE_SET_COMPUTE_35 }; + // Checks whether current device supports the given feature CV_EXPORTS bool deviceSupports(FeatureSet feature_set); // Gives information about what GPU archs this OpenCV GPU module was @@ -116,6 +120,9 @@ namespace cv { namespace gpu int multiProcessorCount() const { return multi_processor_count_; } + size_t sharedMemPerBlock() const; + + void queryMemory(size_t& totalMemory, size_t& freeMemory) const; size_t freeMemory() const; size_t totalMemory() const; @@ -129,7 +136,6 @@ namespace cv { namespace gpu private: void query(); - void queryMemory(size_t& free_memory, size_t& total_memory) const; int device_id_; @@ -549,29 +555,6 @@ namespace cv { namespace gpu { ensureSizeIsEnough(size.height, size.width, type, m); } - - inline void createContinuous(int rows, int cols, int type, GpuMat& m) - { - int area = rows * cols; - if (!m.isContinuous() || m.type() != type || m.size().area() != area) - ensureSizeIsEnough(1, area, type, m); - m = m.reshape(0, rows); - } - - inline void ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m) - { - if (m.type() == type && m.rows >= rows && m.cols >= cols) - m = m(Rect(0, 0, cols, rows)); - else - m.create(rows, cols, type); - } - - inline GpuMat allocMatFromBuf(int rows, int cols, int type, GpuMat &mat) - { - if (!mat.empty() && mat.type() == type && mat.rows >= rows && mat.cols >= cols) - return mat(Rect(0, 0, cols, rows)); - return mat = GpuMat(rows, cols, type); - } }} #endif // __cplusplus diff --git a/modules/core/src/gpumat.cpp b/modules/core/src/gpumat.cpp index 01c613ec75..269e11b635 100644 --- a/modules/core/src/gpumat.cpp +++ b/modules/core/src/gpumat.cpp @@ -48,8 +48,8 @@ #include #include - #define CUDART_MINIMUM_REQUIRED_VERSION 4010 - #define NPP_MINIMUM_REQUIRED_VERSION 4100 + #define CUDART_MINIMUM_REQUIRED_VERSION 4020 + #define NPP_MINIMUM_REQUIRED_VERSION 4200 #if (CUDART_VERSION < CUDART_MINIMUM_REQUIRED_VERSION) #error "Insufficient Cuda Runtime library version, please update it." @@ -64,8 +64,108 @@ using namespace std; using namespace cv; using namespace cv::gpu; +#ifndef HAVE_CUDA + +#define throw_nogpu CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support") + +#else // HAVE_CUDA + +namespace +{ +#if defined(__GNUC__) + #define cudaSafeCall(expr) ___cudaSafeCall(expr, __FILE__, __LINE__, __func__) + #define nppSafeCall(expr) ___nppSafeCall(expr, __FILE__, __LINE__, __func__) +#else /* defined(__CUDACC__) || defined(__MSVC__) */ + #define cudaSafeCall(expr) ___cudaSafeCall(expr, __FILE__, __LINE__) + #define nppSafeCall(expr) ___nppSafeCall(expr, __FILE__, __LINE__) +#endif + + inline void ___cudaSafeCall(cudaError_t err, const char *file, const int line, const char *func = "") + { + if (cudaSuccess != err) + cv::gpu::error(cudaGetErrorString(err), file, line, func); + } + + inline void ___nppSafeCall(int err, const char *file, const int line, const char *func = "") + { + if (err < 0) + { + std::ostringstream msg; + msg << "NPP API Call Error: " << err; + cv::gpu::error(msg.str().c_str(), file, line, func); + } + } +} + +#endif // HAVE_CUDA + //////////////////////////////// Initialization & Info //////////////////////// +#ifndef HAVE_CUDA + +int cv::gpu::getCudaEnabledDeviceCount() { return 0; } + +void cv::gpu::setDevice(int) { throw_nogpu; } +int cv::gpu::getDevice() { throw_nogpu; return 0; } + +void cv::gpu::resetDevice() { throw_nogpu; } + +bool cv::gpu::deviceSupports(FeatureSet) { throw_nogpu; return false; } + +bool cv::gpu::TargetArchs::builtWith(FeatureSet) { throw_nogpu; return false; } +bool cv::gpu::TargetArchs::has(int, int) { throw_nogpu; return false; } +bool cv::gpu::TargetArchs::hasPtx(int, int) { throw_nogpu; return false; } +bool cv::gpu::TargetArchs::hasBin(int, int) { throw_nogpu; return false; } +bool cv::gpu::TargetArchs::hasEqualOrLessPtx(int, int) { throw_nogpu; return false; } +bool cv::gpu::TargetArchs::hasEqualOrGreater(int, int) { throw_nogpu; return false; } +bool cv::gpu::TargetArchs::hasEqualOrGreaterPtx(int, int) { throw_nogpu; return false; } +bool cv::gpu::TargetArchs::hasEqualOrGreaterBin(int, int) { throw_nogpu; return false; } + +size_t cv::gpu::DeviceInfo::sharedMemPerBlock() const { throw_nogpu; return 0; } +void cv::gpu::DeviceInfo::queryMemory(size_t&, size_t&) const { throw_nogpu; } +size_t cv::gpu::DeviceInfo::freeMemory() const { throw_nogpu; return 0; } +size_t cv::gpu::DeviceInfo::totalMemory() const { throw_nogpu; return 0; } +bool cv::gpu::DeviceInfo::supports(FeatureSet) const { throw_nogpu; return false; } +bool cv::gpu::DeviceInfo::isCompatible() const { throw_nogpu; return false; } +void cv::gpu::DeviceInfo::query() { throw_nogpu; } + +void cv::gpu::printCudaDeviceInfo(int) { throw_nogpu; } +void cv::gpu::printShortCudaDeviceInfo(int) { throw_nogpu; } + +#else // HAVE_CUDA + +int cv::gpu::getCudaEnabledDeviceCount() +{ + int count; + cudaError_t error = cudaGetDeviceCount( &count ); + + if (error == cudaErrorInsufficientDriver) + return -1; + + if (error == cudaErrorNoDevice) + return 0; + + cudaSafeCall( error ); + return count; +} + +void cv::gpu::setDevice(int device) +{ + cudaSafeCall( cudaSetDevice( device ) ); +} + +int cv::gpu::getDevice() +{ + int device; + cudaSafeCall( cudaGetDevice( &device ) ); + return device; +} + +void cv::gpu::resetDevice() +{ + cudaSafeCall( cudaDeviceReset() ); +} + namespace { class CudaArch @@ -92,11 +192,9 @@ namespace CudaArch::CudaArch() { - #ifdef HAVE_CUDA fromStr(CUDA_ARCH_BIN, bin); fromStr(CUDA_ARCH_PTX, ptx); fromStr(CUDA_ARCH_FEATURES, features); - #endif } bool CudaArch::builtWith(FeatureSet feature_set) const @@ -149,12 +247,7 @@ namespace bool cv::gpu::TargetArchs::builtWith(cv::gpu::FeatureSet feature_set) { -#if defined (HAVE_CUDA) return cudaArch.builtWith(feature_set); -#else - (void)feature_set; - return false; -#endif } bool cv::gpu::TargetArchs::has(int major, int minor) @@ -164,35 +257,17 @@ bool cv::gpu::TargetArchs::has(int major, int minor) bool cv::gpu::TargetArchs::hasPtx(int major, int minor) { -#if defined (HAVE_CUDA) return cudaArch.hasPtx(major, minor); -#else - (void)major; - (void)minor; - return false; -#endif } bool cv::gpu::TargetArchs::hasBin(int major, int minor) { -#if defined (HAVE_CUDA) return cudaArch.hasBin(major, minor); -#else - (void)major; - (void)minor; - return false; -#endif } bool cv::gpu::TargetArchs::hasEqualOrLessPtx(int major, int minor) { -#if defined (HAVE_CUDA) return cudaArch.hasEqualOrLessPtx(major, minor); -#else - (void)major; - (void)minor; - return false; -#endif } bool cv::gpu::TargetArchs::hasEqualOrGreater(int major, int minor) @@ -202,24 +277,12 @@ bool cv::gpu::TargetArchs::hasEqualOrGreater(int major, int minor) bool cv::gpu::TargetArchs::hasEqualOrGreaterPtx(int major, int minor) { -#if defined (HAVE_CUDA) return cudaArch.hasEqualOrGreaterPtx(major, minor); -#else - (void)major; - (void)minor; - return false; -#endif } bool cv::gpu::TargetArchs::hasEqualOrGreaterBin(int major, int minor) { -#if defined (HAVE_CUDA) return cudaArch.hasEqualOrGreaterBin(major, minor); -#else - (void)major; - (void)minor; - return false; -#endif } bool cv::gpu::deviceSupports(FeatureSet feature_set) @@ -247,108 +310,84 @@ bool cv::gpu::deviceSupports(FeatureSet feature_set) return TargetArchs::builtWith(feature_set) && (version >= feature_set); } -#if !defined (HAVE_CUDA) - -#define throw_nogpu CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support") - -int cv::gpu::getCudaEnabledDeviceCount() { return 0; } - -void cv::gpu::setDevice(int) { throw_nogpu; } -int cv::gpu::getDevice() { throw_nogpu; return 0; } - -void cv::gpu::resetDevice() { throw_nogpu; } - -size_t cv::gpu::DeviceInfo::freeMemory() const { throw_nogpu; return 0; } -size_t cv::gpu::DeviceInfo::totalMemory() const { throw_nogpu; return 0; } - -bool cv::gpu::DeviceInfo::supports(cv::gpu::FeatureSet) const { throw_nogpu; return false; } - -bool cv::gpu::DeviceInfo::isCompatible() const { throw_nogpu; return false; } - -void cv::gpu::DeviceInfo::query() { throw_nogpu; } -void cv::gpu::DeviceInfo::queryMemory(size_t&, size_t&) const { throw_nogpu; } - -void cv::gpu::printCudaDeviceInfo(int) { throw_nogpu; } -void cv::gpu::printShortCudaDeviceInfo(int) { throw_nogpu; } - -#undef throw_nogpu - -#else // HAVE_CUDA - namespace { -#if defined(__GNUC__) - #define cudaSafeCall(expr) ___cudaSafeCall(expr, __FILE__, __LINE__, __func__) - #define nppSafeCall(expr) ___nppSafeCall(expr, __FILE__, __LINE__, __func__) -#else /* defined(__CUDACC__) || defined(__MSVC__) */ - #define cudaSafeCall(expr) ___cudaSafeCall(expr, __FILE__, __LINE__) - #define nppSafeCall(expr) ___nppSafeCall(expr, __FILE__, __LINE__) -#endif - - inline void ___cudaSafeCall(cudaError_t err, const char *file, const int line, const char *func = "") + class DeviceProps { - if (cudaSuccess != err) - cv::gpu::error(cudaGetErrorString(err), file, line, func); + public: + DeviceProps(); + ~DeviceProps(); + + cudaDeviceProp* get(int devID); + + private: + std::vector props_; + }; + + DeviceProps::DeviceProps() + { + props_.resize(10, 0); } - inline void ___nppSafeCall(int err, const char *file, const int line, const char *func = "") + DeviceProps::~DeviceProps() { - if (err < 0) + for (size_t i = 0; i < props_.size(); ++i) { - std::ostringstream msg; - msg << "NPP API Call Error: " << err; - cv::gpu::error(msg.str().c_str(), file, line, func); + if (props_[i]) + delete props_[i]; } + props_.clear(); } + + cudaDeviceProp* DeviceProps::get(int devID) + { + if (devID >= (int) props_.size()) + props_.resize(devID + 5, 0); + + if (!props_[devID]) + { + props_[devID] = new cudaDeviceProp; + cudaSafeCall( cudaGetDeviceProperties(props_[devID], devID) ); + } + + return props_[devID]; + } + + DeviceProps deviceProps; } -int cv::gpu::getCudaEnabledDeviceCount() +size_t cv::gpu::DeviceInfo::sharedMemPerBlock() const { - int count; - cudaError_t error = cudaGetDeviceCount( &count ); - - if (error == cudaErrorInsufficientDriver) - return -1; - - if (error == cudaErrorNoDevice) - return 0; - - cudaSafeCall(error); - return count; + return deviceProps.get(device_id_)->sharedMemPerBlock; } -void cv::gpu::setDevice(int device) +void cv::gpu::DeviceInfo::queryMemory(size_t& totalMemory, size_t& freeMemory) const { - cudaSafeCall( cudaSetDevice( device ) ); -} + int prevDeviceID = getDevice(); + if (prevDeviceID != device_id_) + setDevice(device_id_); -int cv::gpu::getDevice() -{ - int device; - cudaSafeCall( cudaGetDevice( &device ) ); - return device; -} + cudaSafeCall( cudaMemGetInfo(&freeMemory, &totalMemory) ); -void cv::gpu::resetDevice() -{ - cudaSafeCall( cudaDeviceReset() ); + if (prevDeviceID != device_id_) + setDevice(prevDeviceID); } size_t cv::gpu::DeviceInfo::freeMemory() const { - size_t free_memory, total_memory; - queryMemory(free_memory, total_memory); - return free_memory; + size_t totalMemory, freeMemory; + queryMemory(totalMemory, freeMemory); + return freeMemory; } size_t cv::gpu::DeviceInfo::totalMemory() const { - size_t free_memory, total_memory; - queryMemory(free_memory, total_memory); - return total_memory; + size_t totalMemory, freeMemory; + queryMemory(totalMemory, freeMemory); + return totalMemory; } -bool cv::gpu::DeviceInfo::supports(cv::gpu::FeatureSet feature_set) const +bool cv::gpu::DeviceInfo::supports(FeatureSet feature_set) const { int version = majorVersion() * 10 + minorVersion(); return version >= feature_set; @@ -370,24 +409,12 @@ bool cv::gpu::DeviceInfo::isCompatible() const void cv::gpu::DeviceInfo::query() { - cudaDeviceProp prop; - cudaSafeCall(cudaGetDeviceProperties(&prop, device_id_)); - name_ = prop.name; - multi_processor_count_ = prop.multiProcessorCount; - majorVersion_ = prop.major; - minorVersion_ = prop.minor; -} + const cudaDeviceProp* prop = deviceProps.get(device_id_); -void cv::gpu::DeviceInfo::queryMemory(size_t& free_memory, size_t& total_memory) const -{ - int prev_device_id = getDevice(); - if (prev_device_id != device_id_) - setDevice(device_id_); - - cudaSafeCall(cudaMemGetInfo(&free_memory, &total_memory)); - - if (prev_device_id != device_id_) - setDevice(prev_device_id); + name_ = prop->name; + multi_processor_count_ = prop->multiProcessorCount; + majorVersion_ = prop->major; + minorVersion_ = prop->minor; } namespace @@ -764,6 +791,50 @@ cv::Mat::Mat(const GpuMat& m) : flags(0), dims(0), rows(0), cols(0), data(0), re m.download(*this); } +void cv::gpu::createContinuous(int rows, int cols, int type, GpuMat& m) +{ + int area = rows * cols; + if (m.empty() || m.type() != type || !m.isContinuous() || m.size().area() < area) + m.create(1, area, type); + + m.cols = cols; + m.rows = rows; + m.step = m.elemSize() * cols; + m.flags |= Mat::CONTINUOUS_FLAG; +} + +void cv::gpu::ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m) +{ + if (m.empty() || m.type() != type || m.data != m.datastart) + m.create(rows, cols, type); + else + { + const size_t esz = m.elemSize(); + const ptrdiff_t delta2 = m.dataend - m.datastart; + + const size_t minstep = m.cols * esz; + + Size wholeSize; + wholeSize.height = std::max(static_cast((delta2 - minstep) / m.step + 1), m.rows); + wholeSize.width = std::max(static_cast((delta2 - m.step * (wholeSize.height - 1)) / esz), m.cols); + + if (wholeSize.height < rows || wholeSize.width < cols) + m.create(rows, cols, type); + else + { + m.cols = cols; + m.rows = rows; + } + } +} + +GpuMat cv::gpu::allocMatFromBuf(int rows, int cols, int type, GpuMat &mat) +{ + if (!mat.empty() && mat.type() == type && mat.rows >= rows && mat.cols >= cols) + return mat(Rect(0, 0, cols, rows)); + return mat = GpuMat(rows, cols, type); +} + namespace { class GpuFuncTable @@ -787,25 +858,25 @@ namespace }; } -#if !defined HAVE_CUDA || defined(CUDA_DISABLER_) +#ifndef HAVE_CUDA namespace { class EmptyFuncTable : public GpuFuncTable { public: - void copy(const Mat&, GpuMat&) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); } - void copy(const GpuMat&, Mat&) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); } - void copy(const GpuMat&, GpuMat&) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); } + void copy(const Mat&, GpuMat&) const { throw_nogpu; } + void copy(const GpuMat&, Mat&) const { throw_nogpu; } + void copy(const GpuMat&, GpuMat&) const { throw_nogpu; } - void copyWithMask(const GpuMat&, GpuMat&, const GpuMat&) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); } + void copyWithMask(const GpuMat&, GpuMat&, const GpuMat&) const { throw_nogpu; } - void convert(const GpuMat&, GpuMat&) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); } - void convert(const GpuMat&, GpuMat&, double, double) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); } + void convert(const GpuMat&, GpuMat&) const { throw_nogpu; } + void convert(const GpuMat&, GpuMat&, double, double) const { throw_nogpu; } - void setTo(GpuMat&, Scalar, const GpuMat&) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); } + void setTo(GpuMat&, Scalar, const GpuMat&) const { throw_nogpu; } - void mallocPitch(void**, size_t*, size_t, size_t) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); } + void mallocPitch(void**, size_t*, size_t, size_t) const { throw_nogpu; } void free(void*) const {} }; From e21a1d3124e260d94fe97e04cd6cfc666e33fb2c Mon Sep 17 00:00:00 2001 From: Alexander Smorkalov Date: Thu, 21 Feb 2013 11:46:03 +0400 Subject: [PATCH 07/24] Test system refactoring cmpEps replaced on cmpEps2 to reduce code dublication; Constants for cmpEps return values added. --- modules/ts/src/ts_arrtest.cpp | 26 ++------------------------ modules/ts/src/ts_func.cpp | 24 ++++++++++++++---------- 2 files changed, 16 insertions(+), 34 deletions(-) diff --git a/modules/ts/src/ts_arrtest.cpp b/modules/ts/src/ts_arrtest.cpp index 47dcbaf53a..ec3f18330d 100644 --- a/modules/ts/src/ts_arrtest.cpp +++ b/modules/ts/src/ts_arrtest.cpp @@ -296,37 +296,15 @@ int ArrayTest::validate_test_results( int test_case_idx ) for( j = 0; j < sizei; j++ ) { double err_level; - vector idx; - double max_diff = 0; int code; - char msg[100]; if( !test_array[i1][j] ) continue; err_level = get_success_error_level( test_case_idx, i0, (int)j ); - code = cmpEps( test_mat[i0][j], test_mat[i1][j], &max_diff, err_level, &idx, element_wise_relative_error ); + code = cmpEps2(ts, test_mat[i0][j], test_mat[i1][j], err_level, element_wise_relative_error, arr_names[i0]); - switch( code ) - { - case -1: - sprintf( msg, "Too big difference (=%g)", max_diff ); - code = TS::FAIL_BAD_ACCURACY; - break; - case -2: - strcpy( msg, "Invalid output" ); - code = TS::FAIL_INVALID_OUTPUT; - break; - case -3: - strcpy( msg, "Invalid output in the reference array" ); - code = TS::FAIL_INVALID_OUTPUT; - break; - default: - continue; - } - string idxstr = vec2str(", ", &idx[0], idx.size()); - - ts->printf( TS::LOG, "%s in %s array %d at (%s)", msg, arr_names[i0], j, idxstr.c_str() ); + if (code == 0) continue; for( i0 = 0; i0 < (int)test_array.size(); i0++ ) { diff --git a/modules/ts/src/ts_func.cpp b/modules/ts/src/ts_func.cpp index fbbe8ecc6e..62e16fee4d 100644 --- a/modules/ts/src/ts_func.cpp +++ b/modules/ts/src/ts_func.cpp @@ -1934,6 +1934,10 @@ int check( const Mat& a, double fmin, double fmax, vector* _idx ) return idx == 0 ? 0 : -1; } +#define CMP_EPS_OK 0 +#define CMP_EPS_BIG_DIFF -1 +#define CMP_EPS_INVALID_TEST_DATA -2 // there is NaN or Inf value in test data +#define CMP_EPS_INVALID_REF_DATA -3 // there is NaN or Inf value in reference data // compares two arrays. max_diff is the maximum actual difference, // success_err_level is maximum allowed difference, idx is the index of the first @@ -1946,7 +1950,7 @@ int cmpEps( const Mat& arr, const Mat& refarr, double* _realmaxdiff, CV_Assert( arr.type() == refarr.type() && arr.size == refarr.size ); int ilevel = refarr.depth() <= CV_32S ? cvFloor(success_err_level) : 0; - int result = 0; + int result = CMP_EPS_OK; const Mat *arrays[]={&arr, &refarr, 0}; Mat planes[2]; @@ -1998,13 +2002,13 @@ int cmpEps( const Mat& arr, const Mat& refarr, double* _realmaxdiff, continue; if( cvIsNaN(a_val) || cvIsInf(a_val) ) { - result = -2; + result = CMP_EPS_INVALID_TEST_DATA; idx = startidx + j; break; } if( cvIsNaN(b_val) || cvIsInf(b_val) ) { - result = -3; + result = CMP_EPS_INVALID_REF_DATA; idx = startidx + j; break; } @@ -2029,13 +2033,13 @@ int cmpEps( const Mat& arr, const Mat& refarr, double* _realmaxdiff, continue; if( cvIsNaN(a_val) || cvIsInf(a_val) ) { - result = -2; + result = CMP_EPS_INVALID_TEST_DATA; idx = startidx + j; break; } if( cvIsNaN(b_val) || cvIsInf(b_val) ) { - result = -3; + result = CMP_EPS_INVALID_REF_DATA; idx = startidx + j; break; } @@ -2051,7 +2055,7 @@ int cmpEps( const Mat& arr, const Mat& refarr, double* _realmaxdiff, break; default: assert(0); - return -1; + return CMP_EPS_BIG_DIFF; } if(_realmaxdiff) *_realmaxdiff = MAX(*_realmaxdiff, realmaxdiff); @@ -2060,7 +2064,7 @@ int cmpEps( const Mat& arr, const Mat& refarr, double* _realmaxdiff, } if( result == 0 && idx != 0 ) - result = -1; + result = CMP_EPS_BIG_DIFF; if( result < -1 && _realmaxdiff ) *_realmaxdiff = exp(1000.); @@ -2081,15 +2085,15 @@ int cmpEps2( TS* ts, const Mat& a, const Mat& b, double success_err_level, switch( code ) { - case -1: + case CMP_EPS_BIG_DIFF: sprintf( msg, "%s: Too big difference (=%g)", desc, diff ); code = TS::FAIL_BAD_ACCURACY; break; - case -2: + case CMP_EPS_INVALID_TEST_DATA: sprintf( msg, "%s: Invalid output", desc ); code = TS::FAIL_INVALID_OUTPUT; break; - case -3: + case CMP_EPS_INVALID_REF_DATA: sprintf( msg, "%s: Invalid reference output", desc ); code = TS::FAIL_INVALID_OUTPUT; break; From f816e10ac92e963c4e2ce666db93b3d6978d35d0 Mon Sep 17 00:00:00 2001 From: yao Date: Thu, 21 Feb 2013 16:11:18 +0800 Subject: [PATCH 08/24] Add auto detection to Intel OCL --- cmake/OpenCVDetectOpenCL.cmake | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/cmake/OpenCVDetectOpenCL.cmake b/cmake/OpenCVDetectOpenCL.cmake index cbbc3e8c16..12ab9d3eae 100644 --- a/cmake/OpenCVDetectOpenCL.cmake +++ b/cmake/OpenCVDetectOpenCL.cmake @@ -81,6 +81,7 @@ else() set(ENV_AMDAPPSDKROOT $ENV{AMDAPPSDKROOT}) set(ENV_OPENCLROOT $ENV{OPENCLROOT}) set(ENV_CUDA_PATH $ENV{CUDA_PATH}) + set(ENV_INTELOCLSDKROOT $ENV{INTELOCLSDKROOT}) if(ENV_AMDSTREAMSDKROOT) set(OPENCL_INCLUDE_SEARCH_PATH ${ENV_AMDAPPSDKROOT}/include) if(CMAKE_SIZEOF_VOID_P EQUAL 4) @@ -109,6 +110,13 @@ else() else() set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} /usr/lib64) endif() + elseif(ENV_INTELOCLSDKROOT) + set(OPENCL_INCLUDE_SEARCH_PATH ${ENV_INTELOCLSDKROOT}/include) + if(CMAKE_SIZEOF_VOID_P EQUAL 4) + set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_INTELOCLSDKROOT}/lib/x86) + else() + set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_INTELOCLSDKROOT}/lib/x64) + endif() endif() if(OPENCL_INCLUDE_SEARCH_PATH) From 4091eab45e831a51da57bcf4db7a2ece07ddd4fa Mon Sep 17 00:00:00 2001 From: Alexander Date: Sun, 17 Feb 2013 18:18:12 +0400 Subject: [PATCH 09/24] cv::Ptr description extended. --- modules/core/doc/basic_structures.rst | 134 +++++++++++++++++++++----- 1 file changed, 110 insertions(+), 24 deletions(-) diff --git a/modules/core/doc/basic_structures.rst b/modules/core/doc/basic_structures.rst index 2e680229ee..134e969e65 100644 --- a/modules/core/doc/basic_structures.rst +++ b/modules/core/doc/basic_structures.rst @@ -238,7 +238,7 @@ The constructors. :param epsilon: The desired accuracy or change in parameters at which the iterative algorithm stops. :param criteria: Termination criteria in the deprecated ``CvTermCriteria`` format. - + TermCriteria::operator CvTermCriteria ------------------------------------- Converts to the deprecated ``CvTermCriteria`` format. @@ -418,27 +418,47 @@ Template class for smart reference-counting pointers :: }; -The ``Ptr<_Tp>`` class is a template class that wraps pointers of the corresponding type. It is similar to ``shared_ptr`` that is part of the Boost library ( -http://www.boost.org/doc/libs/1_40_0/libs/smart_ptr/shared_ptr.htm -) and also part of the `C++0x `_ -standard. +The ``Ptr<_Tp>`` class is a template class that wraps pointers of the corresponding type. It is +similar to ``shared_ptr`` that is part of the Boost library +(http://www.boost.org/doc/libs/1_40_0/libs/smart_ptr/shared_ptr.htm) and also part of the +`C++0x `_ standard. This class provides the following options: * - Default constructor, copy constructor, and assignment operator for an arbitrary C++ class or a C structure. For some objects, like files, windows, mutexes, sockets, and others, a copy constructor or an assignment operator are difficult to define. For some other objects, like complex classifiers in OpenCV, copy constructors are absent and not easy to implement. Finally, some of complex OpenCV and your own data structures may be written in C. However, copy constructors and default constructors can simplify programming a lot. Besides, they are often required (for example, by STL containers). By wrapping a pointer to such a complex object ``TObj`` to ``Ptr`` , you automatically get all of the necessary constructors and the assignment operator. + Default constructor, copy constructor, and assignment operator for an arbitrary C++ class + or a C structure. For some objects, like files, windows, mutexes, sockets, and others, a copy + constructor or an assignment operator are difficult to define. For some other objects, like + complex classifiers in OpenCV, copy constructors are absent and not easy to implement. Finally, + some of complex OpenCV and your own data structures may be written in C. + However, copy constructors and default constructors can simplify programming a lot.Besides, + they are often required (for example, by STL containers). By wrapping a pointer to such a + complex object ``TObj`` to ``Ptr``, you automatically get all of the necessary + constructors and the assignment operator. * - *O(1)* complexity of the above-mentioned operations. While some structures, like ``std::vector``, provide a copy constructor and an assignment operator, the operations may take a considerable amount of time if the data structures are large. But if the structures are put into ``Ptr<>`` , the overhead is small and independent of the data size. + *O(1)* complexity of the above-mentioned operations. While some structures, like ``std::vector``, + provide a copy constructor and an assignment operator, the operations may take a considerable + amount of time if the data structures are large. But if the structures are put into ``Ptr<>``, + the overhead is small and independent of the data size. * - Automatic destruction, even for C structures. See the example below with ``FILE*`` . + Automatic destruction, even for C structures. See the example below with ``FILE*``. * - Heterogeneous collections of objects. The standard STL and most other C++ and OpenCV containers can store only objects of the same type and the same size. The classical solution to store objects of different types in the same container is to store pointers to the base class ``base_class_t*`` instead but then you loose the automatic memory management. Again, by using ``Ptr()`` instead of the raw pointers, you can solve the problem. + Heterogeneous collections of objects. The standard STL and most other C++ and OpenCV containers + can store only objects of the same type and the same size. The classical solution to store objects + of different types in the same container is to store pointers to the base class ``base_class_t*`` + instead but then you loose the automatic memory management. Again, by using ``Ptr()`` + instead of the raw pointers, you can solve the problem. -The ``Ptr`` class treats the wrapped object as a black box. The reference counter is allocated and managed separately. The only thing the pointer class needs to know about the object is how to deallocate it. This knowledge is encapsulated in the ``Ptr::delete_obj()`` method that is called when the reference counter becomes 0. If the object is a C++ class instance, no additional coding is needed, because the default implementation of this method calls ``delete obj;`` . -However, if the object is deallocated in a different way, the specialized method should be created. For example, if you want to wrap ``FILE`` , the ``delete_obj`` may be implemented as follows: :: +The ``Ptr`` class treats the wrapped object as a black box. The reference counter is allocated and +managed separately. The only thing the pointer class needs to know about the object is how to +deallocate it. This knowledge is encapsulated in the ``Ptr::delete_obj()`` method that is called when +the reference counter becomes 0. If the object is a C++ class instance, no additional coding is +needed, because the default implementation of this method calls ``delete obj;``. However, if the +object is deallocated in a different way, the specialized method should be created. For example, +if you want to wrap ``FILE``, the ``delete_obj`` may be implemented as follows: :: template<> inline void Ptr::delete_obj() { @@ -456,7 +476,73 @@ However, if the object is deallocated in a different way, the specialized method // the file will be closed automatically by the Ptr destructor. -.. note:: The reference increment/decrement operations are implemented as atomic operations, and therefore it is normally safe to use the classes in multi-threaded applications. The same is true for :ocv:class:`Mat` and other C++ OpenCV classes that operate on the reference counters. +.. note:: The reference increment/decrement operations are implemented as atomic operations, + and therefore it is normally safe to use the classes in multi-threaded applications. + The same is true for :ocv:class:`Mat` and other C++ OpenCV classes that operate on + the reference counters. + +Ptr::Ptr +-------- +Various Ptr constructors. + +.. ocv:function:: Ptr::Ptr() +.. ocv:function:: Ptr::Ptr(_Tp* _obj) +.. ocv:function:: Ptr::Ptr(const Ptr& ptr) + +Ptr::~Ptr +--------- +The Ptr destructor. + +.. ocv:function:: Ptr::~Ptr() + +Ptr::operator = +---------------- +Assignment operator. + +.. ocv:function:: Ptr& Ptr::operator = (const Ptr& ptr) + +Decrements own reference counter (with ``release()``) and increments ptr's reference counter. + +Ptr::addref +----------- +Increments reference counter. + +.. ocv:function:: void Ptr::addref() + +Ptr::release +------------ +Decrements reference counter; when it becomes 0, ``delete_obj()`` is called. + +.. ocv:function:: void Ptr::release() + +Ptr::delete_obj +--------------- +User-specified custom object deletion operation. By default, ``delete obj;`` is called. + +.. ocv:function:: void Ptr::delete_obj() + +Ptr::empty +---------- +Returns true if obj == 0; + +bool empty() const; + +Ptr::operator -> +---------------- +Provide access to the object fields and methods. + + .. ocv:function:: template _Tp* Ptr::operator -> () + .. ocv:function:: template const _Tp* Ptr::operator -> () const + + +Ptr::operator _Tp* +------------------ +Returns the underlying object pointer. Thanks to the methods, the ``Ptr<_Tp>`` can be used instead +of ``_Tp*``. + + .. ocv:function:: template Ptr::operator _Tp* () + .. ocv:function:: template Ptr::operator const _Tp*() const + Mat --- @@ -494,9 +580,9 @@ OpenCV C++ n-dimensional dense array class :: The class ``Mat`` represents an n-dimensional dense numerical single-channel or multi-channel array. It can be used to store real or complex-valued vectors and matrices, grayscale or color images, voxel volumes, vector fields, point clouds, tensors, histograms (though, very high-dimensional histograms may be better stored in a ``SparseMat`` ). The data layout of the array -:math:`M` is defined by the array ``M.step[]`` , so that the address of element -:math:`(i_0,...,i_{M.dims-1})` , where -:math:`0\leq i_k= 2 (can also be 0 when the array is empty). + It passes the number of dimensions =1 to the ``Mat`` constructor but the created array will be 2-dimensional with the number of columns set to 1. So, ``Mat::dims`` is always >= 2 (can also be 0 when the array is empty). * @@ -573,7 +659,7 @@ There are many different ways to create a ``Mat`` object. The most popular optio .. - Due to the additional ``datastart`` and ``dataend`` members, it is possible to compute a relative sub-array position in the main *container* array using ``locateROI()``: + Due to the additional ``datastart`` and ``dataend`` members, it is possible to compute a relative sub-array position in the main *container* array using ``locateROI()``: :: @@ -589,7 +675,7 @@ There are many different ways to create a ``Mat`` object. The most popular optio .. - As in case of whole matrices, if you need a deep copy, use the ``clone()`` method of the extracted sub-matrices. + As in case of whole matrices, if you need a deep copy, use the ``clone()`` method of the extracted sub-matrices. * @@ -619,7 +705,7 @@ There are many different ways to create a ``Mat`` object. The most popular optio .. - Partial yet very common cases of this *user-allocated data* case are conversions from ``CvMat`` and ``IplImage`` to ``Mat``. For this purpose, there are special constructors taking pointers to ``CvMat`` or ``IplImage`` and the optional flag indicating whether to copy the data or not. + Partial yet very common cases of this *user-allocated data* case are conversions from ``CvMat`` and ``IplImage`` to ``Mat``. For this purpose, there are special constructors taking pointers to ``CvMat`` or ``IplImage`` and the optional flag indicating whether to copy the data or not. Backward conversion from ``Mat`` to ``CvMat`` or ``IplImage`` is provided via cast operators ``Mat::operator CvMat() const`` and ``Mat::operator IplImage()``. The operators do NOT copy the data. @@ -905,7 +991,7 @@ Provides matrix assignment operators. :param m: Assigned, right-hand-side matrix. Matrix assignment is an O(1) operation. This means that no data is copied but the data is shared and the reference counter, if any, is incremented. Before assigning new data, the old data is de-referenced via :ocv:func:`Mat::release` . - :param expr: Assigned matrix expression object. As opposite to the first form of the assignment operation, the second form can reuse already allocated matrix if it has the right size and type to fit the matrix expression result. It is automatically handled by the real function that the matrix expressions is expanded to. For example, ``C=A+B`` is expanded to ``add(A, B, C)`` , and :func:`add` takes care of automatic ``C`` reallocation. + :param expr: Assigned matrix expression object. As opposite to the first form of the assignment operation, the second form can reuse already allocated matrix if it has the right size and type to fit the matrix expression result. It is automatically handled by the real function that the matrix expressions is expanded to. For example, ``C=A+B`` is expanded to ``add(A, B, C)``, and :func:`add` takes care of automatic ``C`` reallocation. :param s: Scalar assigned to each matrix element. The matrix size or type is not changed. @@ -970,7 +1056,7 @@ Creates a matrix header for the specified row span. :param endrow: An exclusive 0-based ending index of the row span. - :param r: :ocv:class:`Range` structure containing both the start and the end indices. + :param r: :ocv:class:`Range` structure containing both the start and the end indices. The method makes a new header for the specified row span of the matrix. Similarly to :ocv:func:`Mat::row` and @@ -1983,7 +2069,7 @@ The class ``SparseMat`` represents multi-dimensional sparse numerical arrays. Su :ocv:class:`Mat` can store. *Sparse* means that only non-zero elements are stored (though, as a result of operations on a sparse matrix, some of its stored elements can actually become 0. It is up to you to detect such elements and delete them using ``SparseMat::erase`` ). The non-zero elements are stored in a hash table that grows when it is filled so that the search time is O(1) in average (regardless of whether element is there or not). Elements can be accessed using the following methods: * - Query operations ( ``SparseMat::ptr`` and the higher-level ``SparseMat::ref``, ``SparseMat::value`` and ``SparseMat::find`` ), for example: + Query operations (``SparseMat::ptr`` and the higher-level ``SparseMat::ref``, ``SparseMat::value`` and ``SparseMat::find``), for example: :: @@ -2001,7 +2087,7 @@ The class ``SparseMat`` represents multi-dimensional sparse numerical arrays. Su .. * - Sparse matrix iterators. They are similar to ``MatIterator`` but different from :ocv:class:`NAryMatIterator`. That is, the iteration loop is familiar to STL users: + Sparse matrix iterators. They are similar to ``MatIterator`` but different from :ocv:class:`NAryMatIterator`. That is, the iteration loop is familiar to STL users: :: From a938534a7e970316244875f59a213d4462fec88c Mon Sep 17 00:00:00 2001 From: Vladislav Vinogradov Date: Thu, 21 Feb 2013 12:18:08 +0400 Subject: [PATCH 10/24] restored binary compatibility --- modules/core/include/opencv2/core/core.hpp | 28 +- .../core/include/opencv2/core/internal.hpp | 31 ++ .../include/opencv2/core/opengl_interop.hpp | 105 +++--- .../core/opengl_interop_deprecated.hpp | 330 +++++++++++++++++ modules/core/src/matrix.cpp | 99 +++--- modules/core/src/opengl_interop.cpp | 248 ++++++------- .../core/src/opengl_interop_deprecated.cpp | 331 ++++++++++++++++++ modules/gpu/test/test_opengl.cpp | 176 +++++----- .../include/opencv2/highgui/highgui.hpp | 7 +- modules/highgui/src/window.cpp | 30 +- samples/gpu/opengl.cpp | 53 ++- 11 files changed, 1086 insertions(+), 352 deletions(-) create mode 100644 modules/core/include/opencv2/core/opengl_interop_deprecated.hpp create mode 100644 modules/core/src/opengl_interop_deprecated.cpp diff --git a/modules/core/include/opencv2/core/core.hpp b/modules/core/include/opencv2/core/core.hpp index 17dafb0ed4..9f18c7cbfe 100644 --- a/modules/core/include/opencv2/core/core.hpp +++ b/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 _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& 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,8 +1403,8 @@ public: template _OutputArray(Matx<_Tp, m, n>& matx); template _OutputArray(_Tp* vec, int n); _OutputArray(gpu::GpuMat& d_mat); - _OutputArray(GlBuffer& buf); - _OutputArray(GlTexture& tex); + _OutputArray(ogl::Buffer& buf); + _OutputArray(ogl::Texture2D& tex); _OutputArray(const Mat& m); template _OutputArray(const vector<_Tp>& vec); @@ -1399,16 +1415,16 @@ public: template _OutputArray(const Matx<_Tp, m, n>& matx); template _OutputArray(const _Tp* vec, int n); _OutputArray(const gpu::GpuMat& d_mat); - _OutputArray(const GlBuffer& buf); - _OutputArray(const GlTexture& tex); + _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*/ GlBuffer& getGlBufferRef() const; - /*virtual*/ GlTexture& getGlTextureRef() 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; diff --git a/modules/core/include/opencv2/core/internal.hpp b/modules/core/include/opencv2/core/internal.hpp index c042ccaf1f..8423f5afb2 100644 --- a/modules/core/include/opencv2/core/internal.hpp +++ b/modules/core/include/opencv2/core/internal.hpp @@ -750,4 +750,35 @@ typedef struct CvBigFuncTable (tab).fn_2d[CV_32F] = (void*)FUNCNAME##_32f##FLAG; \ (tab).fn_2d[CV_64F] = (void*)FUNCNAME##_64f##FLAG +#ifdef __cplusplus + +// Deprecated + +class CV_EXPORTS CvOpenGlFuncTab +{ +public: + virtual ~CvOpenGlFuncTab(); + + virtual void genBuffers(int n, unsigned int* buffers) const = 0; + virtual void deleteBuffers(int n, const unsigned int* buffers) const = 0; + + virtual void bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const = 0; + virtual void bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const = 0; + + virtual void bindBuffer(unsigned int target, unsigned int buffer) const = 0; + + virtual void* mapBuffer(unsigned int target, unsigned int access) const = 0; + virtual void unmapBuffer(unsigned int target) const = 0; + + virtual void generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const = 0; + + virtual bool isGlContextInitialized() const = 0; +}; + +CV_EXPORTS void icvSetOpenGlFuncTab(const CvOpenGlFuncTab* tab); + +CV_EXPORTS bool icvCheckGlError(const char* file, const int line, const char* func = ""); + +#endif //__cplusplus + #endif // __OPENCV_CORE_INTERNAL_HPP__ diff --git a/modules/core/include/opencv2/core/opengl_interop.hpp b/modules/core/include/opencv2/core/opengl_interop.hpp index 8f7fe8fdc2..04d8b8cf2e 100644 --- a/modules/core/include/opencv2/core/opengl_interop.hpp +++ b/modules/core/include/opencv2/core/opengl_interop.hpp @@ -47,20 +47,20 @@ #include "opencv2/core/core.hpp" -namespace cv { +namespace cv { namespace ogl { -CV_EXPORTS bool checkGlError(const char* file, const int line, const char* func = ""); +CV_EXPORTS bool checkError(const char* file, const int line, const char* func = ""); #if defined(__GNUC__) - #define CV_CheckGlError() CV_DbgAssert( (cv::checkGlError(__FILE__, __LINE__, __func__)) ) + #define CV_CheckGlError() CV_DbgAssert( (cv::gl::checkError(__FILE__, __LINE__, __func__)) ) #else - #define CV_CheckGlError() CV_DbgAssert( (cv::checkGlError(__FILE__, __LINE__)) ) + #define CV_CheckGlError() CV_DbgAssert( (cv::gl::checkError(__FILE__, __LINE__)) ) #endif /////////////////// OpenGL Objects /////////////////// //! Smart pointer for OpenGL buffer memory with reference counting. -class CV_EXPORTS GlBuffer +class CV_EXPORTS Buffer { public: enum Target @@ -79,18 +79,18 @@ public: }; //! create empty buffer - GlBuffer(); + Buffer(); //! create buffer from existed buffer id - GlBuffer(int arows, int acols, int atype, unsigned int abufId, bool autoRelease = false); - GlBuffer(Size asize, int atype, unsigned int abufId, bool autoRelease = false); + Buffer(int arows, int acols, int atype, unsigned int abufId, bool autoRelease = false); + Buffer(Size asize, int atype, unsigned int abufId, bool autoRelease = false); //! create buffer - GlBuffer(int arows, int acols, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false); - GlBuffer(Size asize, int atype, Target target = ARRAY_BUFFER, 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); //! copy from host/device memory - explicit GlBuffer(InputArray arr, Target target = ARRAY_BUFFER, bool autoRelease = false); + explicit Buffer(InputArray arr, Target target = ARRAY_BUFFER, bool autoRelease = false); //! create buffer void create(int arows, int acols, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false); @@ -109,7 +109,7 @@ public: void copyTo(OutputArray arr, Target target = ARRAY_BUFFER, bool autoRelease = false) const; //! create copy of current buffer - GlBuffer clone(Target target = ARRAY_BUFFER, bool autoRelease = false) const; + Buffer clone(Target target = ARRAY_BUFFER, bool autoRelease = false) const; //! bind buffer for specified target void bind(Target target) const; @@ -147,10 +147,8 @@ private: int type_; }; -template <> CV_EXPORTS void Ptr::delete_obj(); - //! Smart pointer for OpenGL 2D texture memory with reference counting. -class CV_EXPORTS GlTexture +class CV_EXPORTS Texture2D { public: enum Format @@ -162,18 +160,18 @@ public: }; //! create empty texture - GlTexture(); + Texture2D(); //! create texture from existed texture id - GlTexture(int arows, int acols, Format aformat, unsigned int atexId, bool autoRelease = false); - GlTexture(Size asize, Format aformat, unsigned int atexId, bool autoRelease = false); + Texture2D(int arows, int acols, Format aformat, unsigned int atexId, bool autoRelease = false); + Texture2D(Size asize, Format aformat, unsigned int atexId, bool autoRelease = false); //! create texture - GlTexture(int arows, int acols, Format aformat, bool autoRelease = false); - GlTexture(Size asize, Format aformat, bool autoRelease = false); + Texture2D(int arows, int acols, Format aformat, bool autoRelease = false); + Texture2D(Size asize, Format aformat, bool autoRelease = false); //! copy from host/device memory - explicit GlTexture(InputArray arr, bool autoRelease = false); + explicit Texture2D(InputArray arr, bool autoRelease = false); //! create texture void create(int arows, int acols, Format aformat, bool autoRelease = false); @@ -212,13 +210,11 @@ private: Format format_; }; -template <> CV_EXPORTS void Ptr::delete_obj(); - //! OpenGL Arrays -class CV_EXPORTS GlArrays +class CV_EXPORTS Arrays { public: - GlArrays(); + Arrays(); void setVertexArray(InputArray vertex); void resetVertexArray(); @@ -243,46 +239,53 @@ public: private: int size_; - GlBuffer vertex_; - GlBuffer color_; - GlBuffer normal_; - GlBuffer texCoord_; + Buffer vertex_; + Buffer color_; + Buffer normal_; + Buffer texCoord_; }; /////////////////// Render Functions /////////////////// //! render texture rectangle in window -CV_EXPORTS void render(const GlTexture& tex, +CV_EXPORTS void render(const Texture2D& tex, Rect_ wndRect = Rect_(0.0, 0.0, 1.0, 1.0), Rect_ texRect = Rect_(0.0, 0.0, 1.0, 1.0)); //! render mode -namespace RenderMode { - enum { - 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 - }; -} +enum { + 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 +}; //! render OpenGL arrays -CV_EXPORTS void render(const GlArrays& arr, int mode = RenderMode::POINTS, Scalar color = Scalar::all(255)); -CV_EXPORTS void render(const GlArrays& arr, InputArray indices, int mode = RenderMode::POINTS, Scalar color = Scalar::all(255)); +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 cv::gl + +namespace cv { namespace gpu { + +//! set a CUDA device to use OpenGL interoperability +CV_EXPORTS void setGlDevice(int device = 0); + +}} + +namespace cv { + +template <> CV_EXPORTS void Ptr::delete_obj(); +template <> CV_EXPORTS void Ptr::delete_obj(); -namespace gpu { - //! set a CUDA device to use OpenGL interoperability - CV_EXPORTS void setGlDevice(int device = 0); } -} // namespace cv - #endif // __cplusplus #endif // __OPENCV_OPENGL_INTEROP_HPP__ diff --git a/modules/core/include/opencv2/core/opengl_interop_deprecated.hpp b/modules/core/include/opencv2/core/opengl_interop_deprecated.hpp new file mode 100644 index 0000000000..e5b39fb164 --- /dev/null +++ b/modules/core/include/opencv2/core/opengl_interop_deprecated.hpp @@ -0,0 +1,330 @@ +/*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 GpuMaterials 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_OPENGL_INTEROP_DEPRECATED_HPP__ +#define __OPENCV_OPENGL_INTEROP_DEPRECATED_HPP__ + +#ifdef __cplusplus + +#include "opencv2/core/core.hpp" + +namespace cv +{ +//! Smart pointer for OpenGL buffer memory with reference counting. +class CV_EXPORTS GlBuffer +{ +public: + enum Usage + { + ARRAY_BUFFER = 0x8892, // buffer will use for OpenGL arrays (vertices, colors, normals, etc) + TEXTURE_BUFFER = 0x88EC // buffer will ise for OpenGL textures + }; + + //! create empty buffer + explicit GlBuffer(Usage usage); + + //! create buffer + GlBuffer(int rows, int cols, int type, Usage usage); + GlBuffer(Size size, int type, Usage usage); + + //! copy from host/device memory + GlBuffer(InputArray mat, Usage usage); + + void create(int rows, int cols, int type, Usage usage); + void create(Size size, int type, Usage usage); + void create(int rows, int cols, int type); + void create(Size size, int type); + + void release(); + + //! copy from host/device memory + void copyFrom(InputArray mat); + + void bind() const; + void unbind() const; + + //! map to host memory + Mat mapHost(); + void unmapHost(); + + //! map to device memory + gpu::GpuMat mapDevice(); + void unmapDevice(); + + inline int rows() const { return rows_; } + inline int cols() const { return cols_; } + inline Size size() const { return Size(cols_, rows_); } + inline bool empty() const { return rows_ == 0 || cols_ == 0; } + + inline int type() const { return type_; } + inline int depth() const { return CV_MAT_DEPTH(type_); } + inline int channels() const { return CV_MAT_CN(type_); } + inline int elemSize() const { return CV_ELEM_SIZE(type_); } + inline int elemSize1() const { return CV_ELEM_SIZE1(type_); } + + inline Usage usage() const { return usage_; } + + class Impl; +private: + int rows_; + int cols_; + int type_; + Usage usage_; + + Ptr impl_; +}; + +template <> CV_EXPORTS void Ptr::delete_obj(); + +//! Smart pointer for OpenGL 2d texture memory with reference counting. +class CV_EXPORTS GlTexture +{ +public: + //! create empty texture + GlTexture(); + + //! create texture + GlTexture(int rows, int cols, int type); + GlTexture(Size size, int type); + + //! copy from host/device memory + explicit GlTexture(InputArray mat, bool bgra = true); + + void create(int rows, int cols, int type); + void create(Size size, int type); + void release(); + + //! copy from host/device memory + void copyFrom(InputArray mat, bool bgra = true); + + void bind() const; + void unbind() const; + + inline int rows() const { return rows_; } + inline int cols() const { return cols_; } + inline Size size() const { return Size(cols_, rows_); } + inline bool empty() const { return rows_ == 0 || cols_ == 0; } + + inline int type() const { return type_; } + inline int depth() const { return CV_MAT_DEPTH(type_); } + inline int channels() const { return CV_MAT_CN(type_); } + inline int elemSize() const { return CV_ELEM_SIZE(type_); } + inline int elemSize1() const { return CV_ELEM_SIZE1(type_); } + + class Impl; +private: + int rows_; + int cols_; + int type_; + + Ptr impl_; + GlBuffer buf_; +}; + +template <> CV_EXPORTS void Ptr::delete_obj(); + +//! OpenGL Arrays +class CV_EXPORTS GlArrays +{ +public: + inline GlArrays() + : vertex_(GlBuffer::ARRAY_BUFFER), color_(GlBuffer::ARRAY_BUFFER), bgra_(true), normal_(GlBuffer::ARRAY_BUFFER), texCoord_(GlBuffer::ARRAY_BUFFER) + { + } + + void setVertexArray(InputArray vertex); + inline void resetVertexArray() { vertex_.release(); } + + void setColorArray(InputArray color, bool bgra = true); + inline void resetColorArray() { color_.release(); } + + void setNormalArray(InputArray normal); + inline void resetNormalArray() { normal_.release(); } + + void setTexCoordArray(InputArray texCoord); + inline void resetTexCoordArray() { texCoord_.release(); } + + void bind() const; + void unbind() const; + + inline int rows() const { return vertex_.rows(); } + inline int cols() const { return vertex_.cols(); } + inline Size size() const { return vertex_.size(); } + inline bool empty() const { return vertex_.empty(); } + +private: + GlBuffer vertex_; + GlBuffer color_; + bool bgra_; + GlBuffer normal_; + GlBuffer texCoord_; +}; + +//! OpenGL Font +class CV_EXPORTS GlFont +{ +public: + enum Weight + { + WEIGHT_LIGHT = 300, + WEIGHT_NORMAL = 400, + WEIGHT_SEMIBOLD = 600, + WEIGHT_BOLD = 700, + WEIGHT_BLACK = 900 + }; + + enum Style + { + STYLE_NORMAL = 0, + STYLE_ITALIC = 1, + STYLE_UNDERLINE = 2 + }; + + static Ptr get(const std::string& family, int height = 12, Weight weight = WEIGHT_NORMAL, Style style = STYLE_NORMAL); + + void draw(const char* str, int len) const; + + inline const std::string& family() const { return family_; } + inline int height() const { return height_; } + inline Weight weight() const { return weight_; } + inline Style style() const { return style_; } + +private: + GlFont(const std::string& family, int height, Weight weight, Style style); + + std::string family_; + int height_; + Weight weight_; + Style style_; + + unsigned int base_; + + GlFont(const GlFont&); + GlFont& operator =(const GlFont&); +}; + +//! render functions + +//! render texture rectangle in window +CV_EXPORTS void render(const GlTexture& tex, + Rect_ wndRect = Rect_(0.0, 0.0, 1.0, 1.0), + Rect_ texRect = Rect_(0.0, 0.0, 1.0, 1.0)); + +//! render mode +namespace RenderMode { + enum { + 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 + }; +} + +//! render OpenGL arrays +CV_EXPORTS void render(const GlArrays& arr, int mode = RenderMode::POINTS, Scalar color = Scalar::all(255)); + +CV_EXPORTS void render(const std::string& str, const Ptr& font, Scalar color, Point2d pos); + +//! OpenGL camera +class CV_EXPORTS GlCamera +{ +public: + GlCamera(); + + void lookAt(Point3d eye, Point3d center, Point3d up); + void setCameraPos(Point3d pos, double yaw, double pitch, double roll); + + void setScale(Point3d scale); + + void setProjectionMatrix(const Mat& projectionMatrix, bool transpose = true); + void setPerspectiveProjection(double fov, double aspect, double zNear, double zFar); + void setOrthoProjection(double left, double right, double bottom, double top, double zNear, double zFar); + + void setupProjectionMatrix() const; + void setupModelViewMatrix() const; + +private: + Point3d eye_; + Point3d center_; + Point3d up_; + + Point3d pos_; + double yaw_; + double pitch_; + double roll_; + + bool useLookAtParams_; + + Point3d scale_; + + Mat projectionMatrix_; + + double fov_; + double aspect_; + + double left_; + double right_; + double bottom_; + double top_; + + double zNear_; + double zFar_; + + bool perspectiveProjection_; +}; + +inline void GlBuffer::create(Size _size, int _type, Usage _usage) { create(_size.height, _size.width, _type, _usage); } +inline void GlBuffer::create(int _rows, int _cols, int _type) { create(_rows, _cols, _type, usage()); } +inline void GlBuffer::create(Size _size, int _type) { create(_size.height, _size.width, _type, usage()); } +inline void GlTexture::create(Size _size, int _type) { create(_size.height, _size.width, _type); } + +} // namespace cv + +#endif // __cplusplus + +#endif // __OPENCV_OPENGL_INTEROP_DEPRECATED_HPP__ diff --git a/modules/core/src/matrix.cpp b/modules/core/src/matrix.cpp index ca2372d3ee..11a4b02660 100644 --- a/modules/core/src/matrix.cpp +++ b/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& 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(OPENGL_BUFFER), obj((void*)&buf) {} -_InputArray::_InputArray(const GlTexture& tex) : flags(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& 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,7 +1246,7 @@ int _InputArray::type(int i) const } if( k == OPENGL_BUFFER ) - return ((const GlBuffer*)obj)->type(); + return ((const ogl::Buffer*)obj)->type(); CV_Assert( k == GPU_MAT ); //if( k == GPU_MAT ) @@ -1287,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 ) @@ -1305,14 +1316,14 @@ _OutputArray::~_OutputArray() {} _OutputArray::_OutputArray(Mat& m) : _InputArray(m) {} _OutputArray::_OutputArray(vector& vec) : _InputArray(vec) {} _OutputArray::_OutputArray(gpu::GpuMat& d_mat) : _InputArray(d_mat) {} -_OutputArray::_OutputArray(GlBuffer& buf) : _InputArray(buf) {} -_OutputArray::_OutputArray(GlTexture& tex) : _InputArray(tex) {} +_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& vec) : _InputArray(vec) {flags |= FIXED_SIZE;} _OutputArray::_OutputArray(const gpu::GpuMat& d_mat) : _InputArray(d_mat) {flags |= FIXED_SIZE|FIXED_TYPE;} -_OutputArray::_OutputArray(const GlBuffer& buf) : _InputArray(buf) {flags |= FIXED_SIZE|FIXED_TYPE;} -_OutputArray::_OutputArray(const GlTexture& tex) : _InputArray(tex) {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 @@ -1344,9 +1355,9 @@ void _OutputArray::create(Size _sz, int mtype, int i, bool allowTransposed, int } if( k == OPENGL_BUFFER && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { - CV_Assert(!fixedSize() || ((GlBuffer*)obj)->size() == _sz); - CV_Assert(!fixedType() || ((GlBuffer*)obj)->type() == mtype); - ((GlBuffer*)obj)->create(_sz, mtype); + 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}; @@ -1372,9 +1383,9 @@ void _OutputArray::create(int rows, int cols, int mtype, int i, bool allowTransp } if( k == OPENGL_BUFFER && i < 0 && !allowTransposed && fixedDepthMask == 0 ) { - CV_Assert(!fixedSize() || ((GlBuffer*)obj)->size() == Size(cols, rows)); - CV_Assert(!fixedType() || ((GlBuffer*)obj)->type() == mtype); - ((GlBuffer*)obj)->create(rows, cols, mtype); + 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}; @@ -1598,13 +1609,13 @@ void _OutputArray::release() const if( k == OPENGL_BUFFER ) { - ((GlBuffer*)obj)->release(); + ((ogl::Buffer*)obj)->release(); return; } if( k == OPENGL_TEXTURE ) { - ((GlTexture*)obj)->release(); + ((ogl::Texture2D*)obj)->release(); return; } @@ -1673,18 +1684,18 @@ gpu::GpuMat& _OutputArray::getGpuMatRef() const return *(gpu::GpuMat*)obj; } -GlBuffer& _OutputArray::getGlBufferRef() const +ogl::Buffer& _OutputArray::getOGlBufferRef() const { int k = kind(); CV_Assert( k == OPENGL_BUFFER ); - return *(GlBuffer*)obj; + return *(ogl::Buffer*)obj; } -GlTexture& _OutputArray::getGlTextureRef() const +ogl::Texture2D& _OutputArray::getOGlTexture2DRef() const { int k = kind(); CV_Assert( k == OPENGL_TEXTURE ); - return *(GlTexture*)obj; + return *(ogl::Texture2D*)obj; } static _OutputArray _none; diff --git a/modules/core/src/opengl_interop.cpp b/modules/core/src/opengl_interop.cpp index 0ef06afcb5..0cb9d3d0f5 100644 --- a/modules/core/src/opengl_interop.cpp +++ b/modules/core/src/opengl_interop.cpp @@ -84,7 +84,7 @@ namespace #endif } -bool cv::checkGlError(const char* file, const int line, const char* func) +bool cv::ogl::checkError(const char* file, const int line, const char* func) { #ifndef HAVE_OPENGL (void) file; @@ -311,17 +311,17 @@ namespace #endif //////////////////////////////////////////////////////////////////////// -// GlBuffer +// ogl::Buffer #ifndef HAVE_OPENGL -class cv::GlBuffer::Impl +class cv::ogl::Buffer::Impl { }; #else -class cv::GlBuffer::Impl +class cv::ogl::Buffer::Impl { public: static const Ptr& empty(); @@ -363,21 +363,21 @@ private: #endif }; -const Ptr& cv::GlBuffer::Impl::empty() +const Ptr& cv::ogl::Buffer::Impl::empty() { static Ptr p(new Impl); return p; } -cv::GlBuffer::Impl::Impl() : bufId_(0), autoRelease_(true) +cv::ogl::Buffer::Impl::Impl() : bufId_(0), autoRelease_(true) { } -cv::GlBuffer::Impl::Impl(GLuint abufId, bool autoRelease) : bufId_(abufId), autoRelease_(autoRelease) +cv::ogl::Buffer::Impl::Impl(GLuint abufId, bool autoRelease) : bufId_(abufId), autoRelease_(autoRelease) { } -cv::GlBuffer::Impl::Impl(GLsizeiptr size, const GLvoid* data, GLenum target, bool autoRelease) : bufId_(0), autoRelease_(autoRelease) +cv::ogl::Buffer::Impl::Impl(GLsizeiptr size, const GLvoid* data, GLenum target, bool autoRelease) : bufId_(0), autoRelease_(autoRelease) { gl::GenBuffers(1, &bufId_); CV_CheckGlError(); @@ -394,19 +394,19 @@ cv::GlBuffer::Impl::Impl(GLsizeiptr size, const GLvoid* data, GLenum target, boo CV_CheckGlError(); } -cv::GlBuffer::Impl::~Impl() +cv::ogl::Buffer::Impl::~Impl() { if (autoRelease_ && bufId_) gl::DeleteBuffers(1, &bufId_); } -void cv::GlBuffer::Impl::bind(GLenum target) const +void cv::ogl::Buffer::Impl::bind(GLenum target) const { gl::BindBuffer(target, bufId_); CV_CheckGlError(); } -void cv::GlBuffer::Impl::copyFrom(GLuint srcBuf, GLsizeiptr size) +void cv::ogl::Buffer::Impl::copyFrom(GLuint srcBuf, GLsizeiptr size) { gl::BindBuffer(gl::COPY_WRITE_BUFFER, bufId_); CV_CheckGlError(); @@ -418,7 +418,7 @@ void cv::GlBuffer::Impl::copyFrom(GLuint srcBuf, GLsizeiptr size) CV_CheckGlError(); } -void cv::GlBuffer::Impl::copyFrom(GLsizeiptr size, const GLvoid* data) +void cv::ogl::Buffer::Impl::copyFrom(GLsizeiptr size, const GLvoid* data) { gl::BindBuffer(gl::COPY_WRITE_BUFFER, bufId_); CV_CheckGlError(); @@ -427,7 +427,7 @@ void cv::GlBuffer::Impl::copyFrom(GLsizeiptr size, const GLvoid* data) CV_CheckGlError(); } -void cv::GlBuffer::Impl::copyTo(GLsizeiptr size, GLvoid* data) const +void cv::ogl::Buffer::Impl::copyTo(GLsizeiptr size, GLvoid* data) const { gl::BindBuffer(gl::COPY_READ_BUFFER, bufId_); CV_CheckGlError(); @@ -436,7 +436,7 @@ void cv::GlBuffer::Impl::copyTo(GLsizeiptr size, GLvoid* data) const CV_CheckGlError(); } -void* cv::GlBuffer::Impl::mapHost(GLenum access) +void* cv::ogl::Buffer::Impl::mapHost(GLenum access) { gl::BindBuffer(gl::COPY_READ_BUFFER, bufId_); CV_CheckGlError(); @@ -447,31 +447,31 @@ void* cv::GlBuffer::Impl::mapHost(GLenum access) return data; } -void cv::GlBuffer::Impl::unmapHost() +void cv::ogl::Buffer::Impl::unmapHost() { gl::UnmapBuffer(gl::COPY_READ_BUFFER); } #ifdef HAVE_CUDA - void cv::GlBuffer::Impl::copyFrom(const void* src, size_t spitch, size_t width, size_t height, cudaStream_t stream) + void cv::ogl::Buffer::Impl::copyFrom(const void* src, size_t spitch, size_t width, size_t height, cudaStream_t stream) { cudaResource_.registerBuffer(bufId_); cudaResource_.copyFrom(src, spitch, width, height, stream); } - void cv::GlBuffer::Impl::copyTo(void* dst, size_t dpitch, size_t width, size_t height, cudaStream_t stream) const + void cv::ogl::Buffer::Impl::copyTo(void* dst, size_t dpitch, size_t width, size_t height, cudaStream_t stream) const { cudaResource_.registerBuffer(bufId_); cudaResource_.copyTo(dst, dpitch, width, height, stream); } - void* cv::GlBuffer::Impl::mapDevice(cudaStream_t stream) + void* cv::ogl::Buffer::Impl::mapDevice(cudaStream_t stream) { cudaResource_.registerBuffer(bufId_); return cudaResource_.map(stream); } - void cv::GlBuffer::Impl::unmapDevice(cudaStream_t stream) + void cv::ogl::Buffer::Impl::unmapDevice(cudaStream_t stream) { cudaResource_.unmap(stream); } @@ -479,7 +479,7 @@ void cv::GlBuffer::Impl::unmapHost() #endif // HAVE_OPENGL -cv::GlBuffer::GlBuffer() : rows_(0), cols_(0), type_(0) +cv::ogl::Buffer::Buffer() : rows_(0), cols_(0), type_(0) { #ifndef HAVE_OPENGL throw_nogl(); @@ -488,7 +488,7 @@ cv::GlBuffer::GlBuffer() : rows_(0), cols_(0), type_(0) #endif } -cv::GlBuffer::GlBuffer(int arows, int acols, int atype, unsigned int abufId, bool autoRelease) : rows_(0), cols_(0), type_(0) +cv::ogl::Buffer::Buffer(int arows, int acols, int atype, unsigned int abufId, bool autoRelease) : rows_(0), cols_(0), type_(0) { #ifndef HAVE_OPENGL (void) arows; @@ -505,7 +505,7 @@ cv::GlBuffer::GlBuffer(int arows, int acols, int atype, unsigned int abufId, boo #endif } -cv::GlBuffer::GlBuffer(Size asize, int atype, unsigned int abufId, bool autoRelease) : rows_(0), cols_(0), type_(0) +cv::ogl::Buffer::Buffer(Size asize, int atype, unsigned int abufId, bool autoRelease) : rows_(0), cols_(0), type_(0) { #ifndef HAVE_OPENGL (void) asize; @@ -521,17 +521,17 @@ cv::GlBuffer::GlBuffer(Size asize, int atype, unsigned int abufId, bool autoRele #endif } -cv::GlBuffer::GlBuffer(int arows, int acols, int atype, Target target, bool autoRelease) : rows_(0), cols_(0), type_(0) +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); } -cv::GlBuffer::GlBuffer(Size asize, int atype, Target target, bool autoRelease) : rows_(0), cols_(0), type_(0) +cv::ogl::Buffer::Buffer(Size asize, int atype, Target target, bool autoRelease) : rows_(0), cols_(0), type_(0) { create(asize, atype, target, autoRelease); } -cv::GlBuffer::GlBuffer(InputArray arr, Target target, bool autoRelease) : rows_(0), cols_(0), type_(0) +cv::ogl::Buffer::Buffer(InputArray arr, Target target, bool autoRelease) : rows_(0), cols_(0), type_(0) { #ifndef HAVE_OPENGL (void) arr; @@ -576,7 +576,7 @@ cv::GlBuffer::GlBuffer(InputArray arr, Target target, bool autoRelease) : rows_( #endif } -void cv::GlBuffer::create(int arows, int acols, int atype, Target target, bool autoRelease) +void cv::ogl::Buffer::create(int arows, int acols, int atype, Target target, bool autoRelease) { #ifndef HAVE_OPENGL (void) arows; @@ -597,7 +597,7 @@ void cv::GlBuffer::create(int arows, int acols, int atype, Target target, bool a #endif } -void cv::GlBuffer::release() +void cv::ogl::Buffer::release() { #ifdef HAVE_OPENGL if (*impl_.refcount == 1) @@ -609,7 +609,7 @@ void cv::GlBuffer::release() #endif } -void cv::GlBuffer::setAutoRelease(bool flag) +void cv::ogl::Buffer::setAutoRelease(bool flag) { #ifndef HAVE_OPENGL (void) flag; @@ -619,7 +619,7 @@ void cv::GlBuffer::setAutoRelease(bool flag) #endif } -void cv::GlBuffer::copyFrom(InputArray arr, Target target, bool autoRelease) +void cv::ogl::Buffer::copyFrom(InputArray arr, Target target, bool autoRelease) { #ifndef HAVE_OPENGL (void) arr; @@ -631,7 +631,7 @@ void cv::GlBuffer::copyFrom(InputArray arr, Target target, bool autoRelease) if (kind == _InputArray::OPENGL_TEXTURE) { - GlTexture tex = arr.getGlTexture(); + ogl::Texture2D tex = arr.getOGlTexture2D(); tex.copyTo(*this); setAutoRelease(autoRelease); return; @@ -645,7 +645,7 @@ void cv::GlBuffer::copyFrom(InputArray arr, Target target, bool autoRelease) { case _InputArray::OPENGL_BUFFER: { - GlBuffer buf = arr.getGlBuffer(); + ogl::Buffer buf = arr.getOGlBuffer(); impl_->copyFrom(buf.bufId(), asize.area() * CV_ELEM_SIZE(atype)); break; } @@ -672,7 +672,7 @@ void cv::GlBuffer::copyFrom(InputArray arr, Target target, bool autoRelease) #endif } -void cv::GlBuffer::copyTo(OutputArray arr, Target target, bool autoRelease) const +void cv::ogl::Buffer::copyTo(OutputArray arr, Target target, bool autoRelease) const { #ifndef HAVE_OPENGL (void) arr; @@ -686,13 +686,13 @@ void cv::GlBuffer::copyTo(OutputArray arr, Target target, bool autoRelease) cons { case _InputArray::OPENGL_BUFFER: { - arr.getGlBufferRef().copyFrom(*this, target, autoRelease); + arr.getOGlBufferRef().copyFrom(*this, target, autoRelease); break; } case _InputArray::OPENGL_TEXTURE: { - arr.getGlTextureRef().copyFrom(*this, autoRelease); + arr.getOGlTexture2DRef().copyFrom(*this, autoRelease); break; } @@ -720,21 +720,21 @@ void cv::GlBuffer::copyTo(OutputArray arr, Target target, bool autoRelease) cons #endif } -GlBuffer cv::GlBuffer::clone(Target target, bool autoRelease) const +cv::ogl::Buffer cv::ogl::Buffer::clone(Target target, bool autoRelease) const { #ifndef HAVE_OPENGL (void) target; (void) autoRelease; throw_nogl(); - return GlBuffer(); + return cv::ogl::Buffer(); #else - GlBuffer buf; + ogl::Buffer buf; buf.copyFrom(*this, target, autoRelease); return buf; #endif } -void cv::GlBuffer::bind(Target target) const +void cv::ogl::Buffer::bind(Target target) const { #ifndef HAVE_OPENGL (void) target; @@ -744,7 +744,7 @@ void cv::GlBuffer::bind(Target target) const #endif } -void cv::GlBuffer::unbind(Target target) +void cv::ogl::Buffer::unbind(Target target) { #ifndef HAVE_OPENGL (void) target; @@ -755,7 +755,7 @@ void cv::GlBuffer::unbind(Target target) #endif } -Mat cv::GlBuffer::mapHost(Access access) +Mat cv::ogl::Buffer::mapHost(Access access) { #ifndef HAVE_OPENGL (void) access; @@ -766,7 +766,7 @@ Mat cv::GlBuffer::mapHost(Access access) #endif } -void cv::GlBuffer::unmapHost() +void cv::ogl::Buffer::unmapHost() { #ifndef HAVE_OPENGL throw_nogl(); @@ -775,7 +775,7 @@ void cv::GlBuffer::unmapHost() #endif } -GpuMat cv::GlBuffer::mapDevice() +GpuMat cv::ogl::Buffer::mapDevice() { #ifndef HAVE_OPENGL throw_nogl(); @@ -790,7 +790,7 @@ GpuMat cv::GlBuffer::mapDevice() #endif } -void cv::GlBuffer::unmapDevice() +void cv::ogl::Buffer::unmapDevice() { #ifndef HAVE_OPENGL throw_nogl(); @@ -803,7 +803,7 @@ void cv::GlBuffer::unmapDevice() #endif } -unsigned int cv::GlBuffer::bufId() const +unsigned int cv::ogl::Buffer::bufId() const { #ifndef HAVE_OPENGL throw_nogl(); @@ -813,23 +813,23 @@ unsigned int cv::GlBuffer::bufId() const #endif } -template <> void cv::Ptr::delete_obj() +template <> void cv::Ptr::delete_obj() { if (obj) delete obj; } ////////////////////////////////////////////////////////////////////////////////////////// -// GlTexture +// ogl::Texture #ifndef HAVE_OPENGL -class cv::GlTexture::Impl +class cv::ogl::Texture2D::Impl { }; #else -class cv::GlTexture::Impl +class cv::ogl::Texture2D::Impl { public: static const Ptr empty(); @@ -854,21 +854,21 @@ private: bool autoRelease_; }; -const Ptr cv::GlTexture::Impl::empty() +const Ptr cv::ogl::Texture2D::Impl::empty() { static Ptr p(new Impl); return p; } -cv::GlTexture::Impl::Impl() : texId_(0), autoRelease_(true) +cv::ogl::Texture2D::Impl::Impl() : texId_(0), autoRelease_(true) { } -cv::GlTexture::Impl::Impl(GLuint atexId, bool autoRelease) : texId_(atexId), autoRelease_(autoRelease) +cv::ogl::Texture2D::Impl::Impl(GLuint atexId, bool autoRelease) : texId_(atexId), autoRelease_(autoRelease) { } -cv::GlTexture::Impl::Impl(GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels, bool autoRelease) : texId_(0), autoRelease_(autoRelease) +cv::ogl::Texture2D::Impl::Impl(GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels, bool autoRelease) : texId_(0), autoRelease_(autoRelease) { gl::GenTextures(1, &texId_); CV_CheckGlError(); @@ -888,13 +888,13 @@ cv::GlTexture::Impl::Impl(GLint internalFormat, GLsizei width, GLsizei height, G CV_CheckGlError(); } -cv::GlTexture::Impl::~Impl() +cv::ogl::Texture2D::Impl::~Impl() { if (autoRelease_ && texId_) gl::DeleteTextures(1, &texId_); } -void cv::GlTexture::Impl::copyFrom(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) +void cv::ogl::Texture2D::Impl::copyFrom(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) { gl::BindTexture(gl::TEXTURE_2D, texId_); CV_CheckGlError(); @@ -909,7 +909,7 @@ void cv::GlTexture::Impl::copyFrom(GLsizei width, GLsizei height, GLenum format, CV_CheckGlError(); } -void cv::GlTexture::Impl::copyTo(GLenum format, GLenum type, GLvoid* pixels) const +void cv::ogl::Texture2D::Impl::copyTo(GLenum format, GLenum type, GLvoid* pixels) const { gl::BindTexture(gl::TEXTURE_2D, texId_); CV_CheckGlError(); @@ -921,7 +921,7 @@ void cv::GlTexture::Impl::copyTo(GLenum format, GLenum type, GLvoid* pixels) con CV_CheckGlError(); } -void cv::GlTexture::Impl::bind() const +void cv::ogl::Texture2D::Impl::bind() const { gl::BindTexture(gl::TEXTURE_2D, texId_); CV_CheckGlError(); @@ -929,7 +929,7 @@ void cv::GlTexture::Impl::bind() const #endif // HAVE_OPENGL -cv::GlTexture::GlTexture() : rows_(0), cols_(0), format_(NONE) +cv::ogl::Texture2D::Texture2D() : rows_(0), cols_(0), format_(NONE) { #ifndef HAVE_OPENGL throw_nogl(); @@ -938,7 +938,7 @@ cv::GlTexture::GlTexture() : rows_(0), cols_(0), format_(NONE) #endif } -cv::GlTexture::GlTexture(int arows, int acols, Format aformat, unsigned int atexId, bool autoRelease) : rows_(0), cols_(0), format_(NONE) +cv::ogl::Texture2D::Texture2D(int arows, int acols, Format aformat, unsigned int atexId, bool autoRelease) : rows_(0), cols_(0), format_(NONE) { #ifndef HAVE_OPENGL (void) arows; @@ -955,7 +955,7 @@ cv::GlTexture::GlTexture(int arows, int acols, Format aformat, unsigned int atex #endif } -cv::GlTexture::GlTexture(Size asize, Format aformat, unsigned int atexId, bool autoRelease) : rows_(0), cols_(0), format_(NONE) +cv::ogl::Texture2D::Texture2D(Size asize, Format aformat, unsigned int atexId, bool autoRelease) : rows_(0), cols_(0), format_(NONE) { #ifndef HAVE_OPENGL (void) asize; @@ -971,17 +971,17 @@ cv::GlTexture::GlTexture(Size asize, Format aformat, unsigned int atexId, bool a #endif } -cv::GlTexture::GlTexture(int arows, int acols, Format aformat, bool autoRelease) : rows_(0), cols_(0), format_(NONE) +cv::ogl::Texture2D::Texture2D(int arows, int acols, Format aformat, bool autoRelease) : rows_(0), cols_(0), format_(NONE) { create(arows, acols, aformat, autoRelease); } -cv::GlTexture::GlTexture(Size asize, Format aformat, bool autoRelease) : rows_(0), cols_(0), format_(NONE) +cv::ogl::Texture2D::Texture2D(Size asize, Format aformat, bool autoRelease) : rows_(0), cols_(0), format_(NONE) { create(asize, aformat, autoRelease); } -cv::GlTexture::GlTexture(InputArray arr, bool autoRelease) : rows_(0), cols_(0), format_(NONE) +cv::ogl::Texture2D::Texture2D(InputArray arr, bool autoRelease) : rows_(0), cols_(0), format_(NONE) { #ifndef HAVE_OPENGL (void) arr; @@ -1012,10 +1012,10 @@ cv::GlTexture::GlTexture(InputArray arr, bool autoRelease) : rows_(0), cols_(0), { case _InputArray::OPENGL_BUFFER: { - GlBuffer buf = arr.getGlBuffer(); - buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER); + ogl::Buffer buf = arr.getOGlBuffer(); + buf.bind(ogl::Buffer::PIXEL_UNPACK_BUFFER); impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], 0, autoRelease); - GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); + ogl::Buffer::unbind(ogl::Buffer::PIXEL_UNPACK_BUFFER); break; } @@ -1025,10 +1025,10 @@ cv::GlTexture::GlTexture(InputArray arr, bool autoRelease) : rows_(0), cols_(0), throw_nocuda(); #else GpuMat dmat = arr.getGpuMat(); - GlBuffer buf(dmat, GlBuffer::PIXEL_UNPACK_BUFFER); - buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER); + ogl::Buffer buf(dmat, ogl::Buffer::PIXEL_UNPACK_BUFFER); + buf.bind(ogl::Buffer::PIXEL_UNPACK_BUFFER); impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], 0, autoRelease); - GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); + ogl::Buffer::unbind(ogl::Buffer::PIXEL_UNPACK_BUFFER); #endif break; @@ -1038,7 +1038,7 @@ cv::GlTexture::GlTexture(InputArray arr, bool autoRelease) : rows_(0), cols_(0), { Mat mat = arr.getMat(); CV_Assert( mat.isContinuous() ); - GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); + ogl::Buffer::unbind(ogl::Buffer::PIXEL_UNPACK_BUFFER); impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], mat.data, autoRelease); break; } @@ -1050,7 +1050,7 @@ cv::GlTexture::GlTexture(InputArray arr, bool autoRelease) : rows_(0), cols_(0), #endif } -void cv::GlTexture::create(int arows, int acols, Format aformat, bool autoRelease) +void cv::ogl::Texture2D::create(int arows, int acols, Format aformat, bool autoRelease) { #ifndef HAVE_OPENGL (void) arows; @@ -1061,7 +1061,7 @@ void cv::GlTexture::create(int arows, int acols, Format aformat, bool autoReleas #else if (rows_ != arows || cols_ != acols || format_ != aformat) { - GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); + ogl::Buffer::unbind(ogl::Buffer::PIXEL_UNPACK_BUFFER); impl_ = new Impl(aformat, acols, arows, aformat, gl::FLOAT, 0, autoRelease); rows_ = arows; cols_ = acols; @@ -1070,7 +1070,7 @@ void cv::GlTexture::create(int arows, int acols, Format aformat, bool autoReleas #endif } -void cv::GlTexture::release() +void cv::ogl::Texture2D::release() { #ifdef HAVE_OPENGL if (*impl_.refcount == 1) @@ -1082,7 +1082,7 @@ void cv::GlTexture::release() #endif } -void cv::GlTexture::setAutoRelease(bool flag) +void cv::ogl::Texture2D::setAutoRelease(bool flag) { #ifndef HAVE_OPENGL (void) flag; @@ -1092,7 +1092,7 @@ void cv::GlTexture::setAutoRelease(bool flag) #endif } -void cv::GlTexture::copyFrom(InputArray arr, bool autoRelease) +void cv::ogl::Texture2D::copyFrom(InputArray arr, bool autoRelease) { #ifndef HAVE_OPENGL (void) arr; @@ -1125,10 +1125,10 @@ void cv::GlTexture::copyFrom(InputArray arr, bool autoRelease) { case _InputArray::OPENGL_BUFFER: { - GlBuffer buf = arr.getGlBuffer(); - buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER); + ogl::Buffer buf = arr.getOGlBuffer(); + buf.bind(ogl::Buffer::PIXEL_UNPACK_BUFFER); impl_->copyFrom(asize.width, asize.height, srcFormats[cn], gl_types[depth], 0); - GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); + ogl::Buffer::unbind(ogl::Buffer::PIXEL_UNPACK_BUFFER); break; } @@ -1138,10 +1138,10 @@ void cv::GlTexture::copyFrom(InputArray arr, bool autoRelease) throw_nocuda(); #else GpuMat dmat = arr.getGpuMat(); - GlBuffer buf(dmat, GlBuffer::PIXEL_UNPACK_BUFFER); - buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER); + ogl::Buffer buf(dmat, ogl::Buffer::PIXEL_UNPACK_BUFFER); + buf.bind(ogl::Buffer::PIXEL_UNPACK_BUFFER); impl_->copyFrom(asize.width, asize.height, srcFormats[cn], gl_types[depth], 0); - GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); + ogl::Buffer::unbind(ogl::Buffer::PIXEL_UNPACK_BUFFER); #endif break; @@ -1151,14 +1151,14 @@ void cv::GlTexture::copyFrom(InputArray arr, bool autoRelease) { Mat mat = arr.getMat(); CV_Assert( mat.isContinuous() ); - GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); + ogl::Buffer::unbind(ogl::Buffer::PIXEL_UNPACK_BUFFER); impl_->copyFrom(asize.width, asize.height, srcFormats[cn], gl_types[depth], mat.data); } } #endif } -void cv::GlTexture::copyTo(OutputArray arr, int ddepth, bool autoRelease) const +void cv::ogl::Texture2D::copyTo(OutputArray arr, int ddepth, bool autoRelease) const { #ifndef HAVE_OPENGL (void) arr; @@ -1175,11 +1175,11 @@ void cv::GlTexture::copyTo(OutputArray arr, int ddepth, bool autoRelease) const { case _InputArray::OPENGL_BUFFER: { - GlBuffer& buf = arr.getGlBufferRef(); - buf.create(rows_, cols_, CV_MAKE_TYPE(ddepth, cn), GlBuffer::PIXEL_PACK_BUFFER, autoRelease); - buf.bind(GlBuffer::PIXEL_PACK_BUFFER); + ogl::Buffer& buf = arr.getOGlBufferRef(); + buf.create(rows_, cols_, CV_MAKE_TYPE(ddepth, cn), ogl::Buffer::PIXEL_PACK_BUFFER, autoRelease); + buf.bind(ogl::Buffer::PIXEL_PACK_BUFFER); impl_->copyTo(dstFormat, gl_types[ddepth], 0); - GlBuffer::unbind(GlBuffer::PIXEL_PACK_BUFFER); + ogl::Buffer::unbind(ogl::Buffer::PIXEL_PACK_BUFFER); break; } @@ -1188,10 +1188,10 @@ void cv::GlTexture::copyTo(OutputArray arr, int ddepth, bool autoRelease) const #if !defined HAVE_CUDA || defined(CUDA_DISABLER) throw_nocuda(); #else - GlBuffer buf(rows_, cols_, CV_MAKE_TYPE(ddepth, cn), GlBuffer::PIXEL_PACK_BUFFER); - buf.bind(GlBuffer::PIXEL_PACK_BUFFER); + ogl::Buffer buf(rows_, cols_, CV_MAKE_TYPE(ddepth, cn), ogl::Buffer::PIXEL_PACK_BUFFER); + buf.bind(ogl::Buffer::PIXEL_PACK_BUFFER); impl_->copyTo(dstFormat, gl_types[ddepth], 0); - GlBuffer::unbind(GlBuffer::PIXEL_PACK_BUFFER); + ogl::Buffer::unbind(ogl::Buffer::PIXEL_PACK_BUFFER); buf.copyTo(arr); #endif @@ -1203,14 +1203,14 @@ void cv::GlTexture::copyTo(OutputArray arr, int ddepth, bool autoRelease) const arr.create(rows_, cols_, CV_MAKE_TYPE(ddepth, cn)); Mat mat = arr.getMat(); CV_Assert( mat.isContinuous() ); - GlBuffer::unbind(GlBuffer::PIXEL_PACK_BUFFER); + ogl::Buffer::unbind(ogl::Buffer::PIXEL_PACK_BUFFER); impl_->copyTo(dstFormat, gl_types[ddepth], mat.data); } } #endif } -void cv::GlTexture::bind() const +void cv::ogl::Texture2D::bind() const { #ifndef HAVE_OPENGL throw_nogl(); @@ -1219,7 +1219,7 @@ void cv::GlTexture::bind() const #endif } -unsigned int cv::GlTexture::texId() const +unsigned int cv::ogl::Texture2D::texId() const { #ifndef HAVE_OPENGL throw_nogl(); @@ -1229,19 +1229,19 @@ unsigned int cv::GlTexture::texId() const #endif } -template <> void cv::Ptr::delete_obj() +template <> void cv::Ptr::delete_obj() { if (obj) delete obj; } //////////////////////////////////////////////////////////////////////// -// GlArrays +// ogl::Arrays -cv::GlArrays::GlArrays() : size_(0) +cv::ogl::Arrays::Arrays() : size_(0) { } -void cv::GlArrays::setVertexArray(InputArray vertex) +void cv::ogl::Arrays::setVertexArray(InputArray vertex) { const int cn = vertex.channels(); const int depth = vertex.depth(); @@ -1250,37 +1250,37 @@ void cv::GlArrays::setVertexArray(InputArray vertex) CV_Assert( depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F ); if (vertex.kind() == _InputArray::OPENGL_BUFFER) - vertex_ = vertex.getGlBuffer(); + vertex_ = vertex.getOGlBuffer(); else vertex_.copyFrom(vertex); size_ = vertex_.size().area(); } -void cv::GlArrays::resetVertexArray() +void cv::ogl::Arrays::resetVertexArray() { vertex_.release(); size_ = 0; } -void cv::GlArrays::setColorArray(InputArray color) +void cv::ogl::Arrays::setColorArray(InputArray color) { const int cn = color.channels(); CV_Assert( cn == 3 || cn == 4 ); if (color.kind() == _InputArray::OPENGL_BUFFER) - color_ = color.getGlBuffer(); + color_ = color.getOGlBuffer(); else color_.copyFrom(color); } -void cv::GlArrays::resetColorArray() +void cv::ogl::Arrays::resetColorArray() { color_.release(); } -void cv::GlArrays::setNormalArray(InputArray normal) +void cv::ogl::Arrays::setNormalArray(InputArray normal) { const int cn = normal.channels(); const int depth = normal.depth(); @@ -1289,17 +1289,17 @@ void cv::GlArrays::setNormalArray(InputArray normal) CV_Assert( depth == CV_8S || depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F ); if (normal.kind() == _InputArray::OPENGL_BUFFER) - normal_ = normal.getGlBuffer(); + normal_ = normal.getOGlBuffer(); else normal_.copyFrom(normal); } -void cv::GlArrays::resetNormalArray() +void cv::ogl::Arrays::resetNormalArray() { normal_.release(); } -void cv::GlArrays::setTexCoordArray(InputArray texCoord) +void cv::ogl::Arrays::setTexCoordArray(InputArray texCoord) { const int cn = texCoord.channels(); const int depth = texCoord.depth(); @@ -1308,17 +1308,17 @@ void cv::GlArrays::setTexCoordArray(InputArray texCoord) CV_Assert( depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F ); if (texCoord.kind() == _InputArray::OPENGL_BUFFER) - texCoord_ = texCoord.getGlBuffer(); + texCoord_ = texCoord.getOGlBuffer(); else texCoord_.copyFrom(texCoord); } -void cv::GlArrays::resetTexCoordArray() +void cv::ogl::Arrays::resetTexCoordArray() { texCoord_.release(); } -void cv::GlArrays::release() +void cv::ogl::Arrays::release() { resetVertexArray(); resetColorArray(); @@ -1326,7 +1326,7 @@ void cv::GlArrays::release() resetTexCoordArray(); } -void cv::GlArrays::setAutoRelease(bool flag) +void cv::ogl::Arrays::setAutoRelease(bool flag) { vertex_.setAutoRelease(flag); color_.setAutoRelease(flag); @@ -1334,7 +1334,7 @@ void cv::GlArrays::setAutoRelease(bool flag) texCoord_.setAutoRelease(flag); } -void cv::GlArrays::bind() const +void cv::ogl::Arrays::bind() const { #ifndef HAVE_OPENGL throw_nogl(); @@ -1353,7 +1353,7 @@ void cv::GlArrays::bind() const gl::EnableClientState(gl::TEXTURE_COORD_ARRAY); CV_CheckGlError(); - texCoord_.bind(GlBuffer::ARRAY_BUFFER); + texCoord_.bind(ogl::Buffer::ARRAY_BUFFER); gl::TexCoordPointer(texCoord_.channels(), gl_types[texCoord_.depth()], 0, 0); CV_CheckGlError(); @@ -1369,7 +1369,7 @@ void cv::GlArrays::bind() const gl::EnableClientState(gl::NORMAL_ARRAY); CV_CheckGlError(); - normal_.bind(GlBuffer::ARRAY_BUFFER); + normal_.bind(ogl::Buffer::ARRAY_BUFFER); gl::NormalPointer(gl_types[normal_.depth()], 0, 0); CV_CheckGlError(); @@ -1385,7 +1385,7 @@ void cv::GlArrays::bind() const gl::EnableClientState(gl::COLOR_ARRAY); CV_CheckGlError(); - color_.bind(GlBuffer::ARRAY_BUFFER); + color_.bind(ogl::Buffer::ARRAY_BUFFER); const int cn = color_.channels(); @@ -1403,20 +1403,20 @@ void cv::GlArrays::bind() const gl::EnableClientState(gl::VERTEX_ARRAY); CV_CheckGlError(); - vertex_.bind(GlBuffer::ARRAY_BUFFER); + vertex_.bind(ogl::Buffer::ARRAY_BUFFER); gl::VertexPointer(vertex_.channels(), gl_types[vertex_.depth()], 0, 0); CV_CheckGlError(); } - GlBuffer::unbind(GlBuffer::ARRAY_BUFFER); + ogl::Buffer::unbind(ogl::Buffer::ARRAY_BUFFER); #endif } //////////////////////////////////////////////////////////////////////// // Rendering -void cv::render(const GlTexture& tex, Rect_ wndRect, Rect_ texRect) +void cv::ogl::render(const ogl::Texture2D& tex, Rect_ wndRect, Rect_ texRect) { #ifndef HAVE_OPENGL (void) tex; @@ -1464,7 +1464,7 @@ void cv::render(const GlTexture& tex, Rect_ wndRect, Rect_ texRe texRect.x + texRect.width, texRect.y }; - GlBuffer::unbind(GlBuffer::ARRAY_BUFFER); + ogl::Buffer::unbind(ogl::Buffer::ARRAY_BUFFER); gl::EnableClientState(gl::TEXTURE_COORD_ARRAY); CV_CheckGlError(); @@ -1482,13 +1482,13 @@ void cv::render(const GlTexture& tex, Rect_ wndRect, Rect_ texRe gl::VertexPointer(3, gl::FLOAT, 0, vertex); CV_CheckGlError(); - gl::DrawArrays(cv::RenderMode::QUADS, 0, 4); + gl::DrawArrays(gl::QUADS, 0, 4); CV_CheckGlError(); } #endif } -void cv::render(const GlArrays& arr, int mode, Scalar color) +void cv::ogl::render(const ogl::Arrays& arr, int mode, Scalar color) { #ifndef HAVE_OPENGL (void) arr; @@ -1507,7 +1507,7 @@ void cv::render(const GlArrays& arr, int mode, Scalar color) #endif } -void cv::render(const GlArrays& arr, InputArray indices, int mode, Scalar color) +void cv::ogl::render(const ogl::Arrays& arr, InputArray indices, int mode, Scalar color) { #ifndef HAVE_OPENGL (void) arr; @@ -1528,7 +1528,7 @@ void cv::render(const GlArrays& arr, InputArray indices, int mode, Scalar color) { case _InputArray::OPENGL_BUFFER : { - GlBuffer buf = indices.getGlBuffer(); + ogl::Buffer buf = indices.getOGlBuffer(); const int depth = buf.depth(); @@ -1543,11 +1543,11 @@ void cv::render(const GlArrays& arr, InputArray indices, int mode, Scalar color) else type = gl::UNSIGNED_INT; - buf.bind(GlBuffer::ELEMENT_ARRAY_BUFFER); + buf.bind(ogl::Buffer::ELEMENT_ARRAY_BUFFER); gl::DrawElements(mode, buf.size().area(), type, 0); - GlBuffer::unbind(GlBuffer::ELEMENT_ARRAY_BUFFER); + ogl::Buffer::unbind(ogl::Buffer::ELEMENT_ARRAY_BUFFER); break; } @@ -1570,7 +1570,7 @@ void cv::render(const GlArrays& arr, InputArray indices, int mode, Scalar color) else type = gl::UNSIGNED_INT; - GlBuffer::unbind(GlBuffer::ELEMENT_ARRAY_BUFFER); + ogl::Buffer::unbind(ogl::Buffer::ELEMENT_ARRAY_BUFFER); gl::DrawElements(mode, mat.size().area(), type, mat.data); } diff --git a/modules/core/src/opengl_interop_deprecated.cpp b/modules/core/src/opengl_interop_deprecated.cpp new file mode 100644 index 0000000000..0670f57661 --- /dev/null +++ b/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::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::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 cv::GlFont::get(const std::string&, int, Weight, Style) +{ + CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it"); + return Ptr(); +} + +//////////////////////////////////////////////////////////////////////// +// Rendering + +void cv::render(const GlTexture&, Rect_, Rect_) +{ + 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&, 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; +} diff --git a/modules/gpu/test/test_opengl.cpp b/modules/gpu/test/test_opengl.cpp index cd266ee413..626851e30e 100644 --- a/modules/gpu/test/test_opengl.cpp +++ b/modules/gpu/test/test_opengl.cpp @@ -44,9 +44,9 @@ #if defined(HAVE_CUDA) && defined(HAVE_OPENGL) ///////////////////////////////////////////// -// GlBuffer +// Buffer -PARAM_TEST_CASE(GlBuffer, cv::Size, MatType) +PARAM_TEST_CASE(Buffer, cv::Size, MatType) { static void SetUpTestCase() { @@ -68,29 +68,29 @@ PARAM_TEST_CASE(GlBuffer, cv::Size, MatType) } }; -GPU_TEST_P(GlBuffer, Constructor1) +GPU_TEST_P(Buffer, Constructor1) { - cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf(size.height, size.width, type, cv::ogl::Buffer::ARRAY_BUFFER, true); EXPECT_EQ(size.height, buf.rows()); EXPECT_EQ(size.width, buf.cols()); EXPECT_EQ(type, buf.type()); } -GPU_TEST_P(GlBuffer, Constructor2) +GPU_TEST_P(Buffer, Constructor2) { - cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf(size, type, cv::ogl::Buffer::ARRAY_BUFFER, true); EXPECT_EQ(size.height, buf.rows()); EXPECT_EQ(size.width, buf.cols()); EXPECT_EQ(type, buf.type()); } -GPU_TEST_P(GlBuffer, ConstructorFromMat) +GPU_TEST_P(Buffer, ConstructorFromMat) { cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); cv::Mat bufData; buf.copyTo(bufData); @@ -98,12 +98,12 @@ GPU_TEST_P(GlBuffer, ConstructorFromMat) EXPECT_MAT_NEAR(gold, bufData, 0); } -GPU_TEST_P(GlBuffer, ConstructorFromGpuMat) +GPU_TEST_P(Buffer, ConstructorFromGpuMat) { cv::Mat gold = randomMat(size, type); cv::gpu::GpuMat d_gold(gold); - cv::GlBuffer buf(d_gold, cv::GlBuffer::ARRAY_BUFFER); + cv::ogl::Buffer buf(d_gold, cv::ogl::Buffer::ARRAY_BUFFER); cv::Mat bufData; buf.copyTo(bufData); @@ -111,11 +111,11 @@ GPU_TEST_P(GlBuffer, ConstructorFromGpuMat) EXPECT_MAT_NEAR(gold, bufData, 0); } -GPU_TEST_P(GlBuffer, ConstructorFromGlBuffer) +GPU_TEST_P(Buffer, ConstructorFromBuffer) { - cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf_gold(size, type, cv::ogl::Buffer::ARRAY_BUFFER, true); - cv::GlBuffer buf(buf_gold); + cv::ogl::Buffer buf(buf_gold); EXPECT_EQ(buf_gold.bufId(), buf.bufId()); EXPECT_EQ(buf_gold.rows(), buf.rows()); @@ -123,7 +123,7 @@ GPU_TEST_P(GlBuffer, ConstructorFromGlBuffer) EXPECT_EQ(buf_gold.type(), buf.type()); } -GPU_TEST_P(GlBuffer, ConstructorFromGlTexture) +GPU_TEST_P(Buffer, ConstructorFromTexture2D) { const int depth = CV_MAT_DEPTH(type); const int cn = CV_MAT_CN(type); @@ -132,9 +132,9 @@ GPU_TEST_P(GlBuffer, ConstructorFromGlTexture) return; cv::Mat gold = randomMat(size, type, 0, 1.0); - cv::GlTexture tex_gold(gold, true); + cv::ogl::Texture2D tex_gold(gold, true); - cv::GlBuffer buf(tex_gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true); + cv::ogl::Buffer buf(tex_gold, cv::ogl::Buffer::PIXEL_PACK_BUFFER, true); cv::Mat bufData; buf.copyTo(bufData); @@ -142,22 +142,22 @@ GPU_TEST_P(GlBuffer, ConstructorFromGlTexture) EXPECT_MAT_NEAR(gold, bufData, 1e-2); } -GPU_TEST_P(GlBuffer, Create) +GPU_TEST_P(Buffer, Create) { - cv::GlBuffer buf; - buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf; + buf.create(size.height, size.width, type, cv::ogl::Buffer::ARRAY_BUFFER, true); EXPECT_EQ(size.height, buf.rows()); EXPECT_EQ(size.width, buf.cols()); EXPECT_EQ(type, buf.type()); } -GPU_TEST_P(GlBuffer, CopyFromMat) +GPU_TEST_P(Buffer, CopyFromMat) { cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf; - buf.copyFrom(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf; + buf.copyFrom(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); cv::Mat bufData; buf.copyTo(bufData); @@ -165,13 +165,13 @@ GPU_TEST_P(GlBuffer, CopyFromMat) EXPECT_MAT_NEAR(gold, bufData, 0); } -GPU_TEST_P(GlBuffer, CopyFromGpuMat) +GPU_TEST_P(Buffer, CopyFromGpuMat) { cv::Mat gold = randomMat(size, type); cv::gpu::GpuMat d_gold(gold); - cv::GlBuffer buf; - buf.copyFrom(d_gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf; + buf.copyFrom(d_gold, cv::ogl::Buffer::ARRAY_BUFFER, true); cv::Mat bufData; buf.copyTo(bufData); @@ -179,13 +179,13 @@ GPU_TEST_P(GlBuffer, CopyFromGpuMat) EXPECT_MAT_NEAR(gold, bufData, 0); } -GPU_TEST_P(GlBuffer, CopyFromGlBuffer) +GPU_TEST_P(Buffer, CopyFromBuffer) { cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); - cv::GlBuffer buf; - buf.copyFrom(buf_gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf; + buf.copyFrom(buf_gold, cv::ogl::Buffer::ARRAY_BUFFER, true); EXPECT_NE(buf_gold.bufId(), buf.bufId()); @@ -195,7 +195,7 @@ GPU_TEST_P(GlBuffer, CopyFromGlBuffer) EXPECT_MAT_NEAR(gold, bufData, 0); } -GPU_TEST_P(GlBuffer, CopyFromGlTexture) +GPU_TEST_P(Buffer, CopyFromTexture2D) { const int depth = CV_MAT_DEPTH(type); const int cn = CV_MAT_CN(type); @@ -204,10 +204,10 @@ GPU_TEST_P(GlBuffer, CopyFromGlTexture) return; cv::Mat gold = randomMat(size, type, 0, 1.0); - cv::GlTexture tex_gold(gold, true); + cv::ogl::Texture2D tex_gold(gold, true); - cv::GlBuffer buf; - buf.copyFrom(tex_gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf; + buf.copyFrom(tex_gold, cv::ogl::Buffer::ARRAY_BUFFER, true); cv::Mat bufData; buf.copyTo(bufData); @@ -215,11 +215,11 @@ GPU_TEST_P(GlBuffer, CopyFromGlTexture) EXPECT_MAT_NEAR(gold, bufData, 1e-2); } -GPU_TEST_P(GlBuffer, CopyToGpuMat) +GPU_TEST_P(Buffer, CopyToGpuMat) { cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); cv::gpu::GpuMat dst; buf.copyTo(dst); @@ -227,14 +227,14 @@ GPU_TEST_P(GlBuffer, CopyToGpuMat) EXPECT_MAT_NEAR(gold, dst, 0); } -GPU_TEST_P(GlBuffer, CopyToGlBuffer) +GPU_TEST_P(Buffer, CopyToBuffer) { cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); - cv::GlBuffer dst; - buf.copyTo(dst, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer dst; + buf.copyTo(dst, cv::ogl::Buffer::ARRAY_BUFFER, true); EXPECT_NE(buf.bufId(), dst.bufId()); @@ -244,7 +244,7 @@ GPU_TEST_P(GlBuffer, CopyToGlBuffer) EXPECT_MAT_NEAR(gold, bufData, 0); } -GPU_TEST_P(GlBuffer, CopyToGlTexture) +GPU_TEST_P(Buffer, CopyToTexture2D) { const int depth = CV_MAT_DEPTH(type); const int cn = CV_MAT_CN(type); @@ -254,10 +254,10 @@ GPU_TEST_P(GlBuffer, CopyToGlTexture) cv::Mat gold = randomMat(size, type, 0, 1.0); - cv::GlBuffer buf(gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true); + cv::ogl::Buffer buf(gold, cv::ogl::Buffer::PIXEL_PACK_BUFFER, true); - cv::GlTexture tex; - buf.copyTo(tex, cv::GlBuffer::PIXEL_PACK_BUFFER, true); + cv::ogl::Texture2D tex; + buf.copyTo(tex, cv::ogl::Buffer::PIXEL_PACK_BUFFER, true); cv::Mat texData; tex.copyTo(texData); @@ -265,13 +265,13 @@ GPU_TEST_P(GlBuffer, CopyToGlTexture) EXPECT_MAT_NEAR(gold, texData, 1e-2); } -GPU_TEST_P(GlBuffer, Clone) +GPU_TEST_P(Buffer, Clone) { cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); - cv::GlBuffer dst = buf.clone(cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer dst = buf.clone(cv::ogl::Buffer::ARRAY_BUFFER, true); EXPECT_NE(buf.bufId(), dst.bufId()); @@ -281,26 +281,26 @@ GPU_TEST_P(GlBuffer, Clone) EXPECT_MAT_NEAR(gold, bufData, 0); } -GPU_TEST_P(GlBuffer, MapHostRead) +GPU_TEST_P(Buffer, MapHostRead) { cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); - cv::Mat dst = buf.mapHost(cv::GlBuffer::READ_ONLY); + cv::Mat dst = buf.mapHost(cv::ogl::Buffer::READ_ONLY); EXPECT_MAT_NEAR(gold, dst, 0); buf.unmapHost(); } -GPU_TEST_P(GlBuffer, MapHostWrite) +GPU_TEST_P(Buffer, MapHostWrite) { cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf(size, type, cv::ogl::Buffer::ARRAY_BUFFER, true); - cv::Mat dst = buf.mapHost(cv::GlBuffer::WRITE_ONLY); + cv::Mat dst = buf.mapHost(cv::ogl::Buffer::WRITE_ONLY); gold.copyTo(dst); buf.unmapHost(); dst.release(); @@ -311,11 +311,11 @@ GPU_TEST_P(GlBuffer, MapHostWrite) EXPECT_MAT_NEAR(gold, bufData, 0); } -GPU_TEST_P(GlBuffer, MapDevice) +GPU_TEST_P(Buffer, MapDevice) { cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::ogl::Buffer buf(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); cv::gpu::GpuMat dst = buf.mapDevice(); @@ -324,12 +324,12 @@ GPU_TEST_P(GlBuffer, MapDevice) buf.unmapDevice(); } -INSTANTIATE_TEST_CASE_P(OpenGL, GlBuffer, testing::Combine(DIFFERENT_SIZES, ALL_TYPES)); +INSTANTIATE_TEST_CASE_P(OpenGL, Buffer, testing::Combine(DIFFERENT_SIZES, ALL_TYPES)); ///////////////////////////////////////////// -// GlTexture +// Texture2D -PARAM_TEST_CASE(GlTexture, cv::Size, MatType) +PARAM_TEST_CASE(Texture2D, cv::Size, MatType) { static void SetUpTestCase() { @@ -345,7 +345,7 @@ PARAM_TEST_CASE(GlTexture, cv::Size, MatType) int type; int depth; int cn; - cv::GlTexture::Format format; + cv::ogl::Texture2D::Format format; virtual void SetUp() { @@ -354,33 +354,33 @@ PARAM_TEST_CASE(GlTexture, cv::Size, MatType) depth = CV_MAT_DEPTH(type); cn = CV_MAT_CN(type); - format = cn == 1 ? cv::GlTexture::DEPTH_COMPONENT : cn == 3 ? cv::GlTexture::RGB : cn == 4 ? cv::GlTexture::RGBA : cv::GlTexture::NONE; + format = cn == 1 ? cv::ogl::Texture2D::DEPTH_COMPONENT : cn == 3 ? cv::ogl::Texture2D::RGB : cn == 4 ? cv::ogl::Texture2D::RGBA : cv::ogl::Texture2D::NONE; } }; -GPU_TEST_P(GlTexture, Constructor1) +GPU_TEST_P(Texture2D, Constructor1) { - cv::GlTexture tex(size.height, size.width, format, true); + cv::ogl::Texture2D tex(size.height, size.width, format, true); EXPECT_EQ(size.height, tex.rows()); EXPECT_EQ(size.width, tex.cols()); EXPECT_EQ(format, tex.format()); } -GPU_TEST_P(GlTexture, Constructor2) +GPU_TEST_P(Texture2D, Constructor2) { - cv::GlTexture tex(size, format, true); + cv::ogl::Texture2D tex(size, format, true); EXPECT_EQ(size.height, tex.rows()); EXPECT_EQ(size.width, tex.cols()); EXPECT_EQ(format, tex.format()); } -GPU_TEST_P(GlTexture, ConstructorFromMat) +GPU_TEST_P(Texture2D, ConstructorFromMat) { cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); - cv::GlTexture tex(gold, true); + cv::ogl::Texture2D tex(gold, true); cv::Mat texData; tex.copyTo(texData, depth); @@ -388,12 +388,12 @@ GPU_TEST_P(GlTexture, ConstructorFromMat) EXPECT_MAT_NEAR(gold, texData, 1e-2); } -GPU_TEST_P(GlTexture, ConstructorFromGpuMat) +GPU_TEST_P(Texture2D, ConstructorFromGpuMat) { cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); cv::gpu::GpuMat d_gold(gold); - cv::GlTexture tex(d_gold, true); + cv::ogl::Texture2D tex(d_gold, true); cv::Mat texData; tex.copyTo(texData, depth); @@ -401,12 +401,12 @@ GPU_TEST_P(GlTexture, ConstructorFromGpuMat) EXPECT_MAT_NEAR(gold, texData, 1e-2); } -GPU_TEST_P(GlTexture, ConstructorFromGlBuffer) +GPU_TEST_P(Texture2D, ConstructorFromBuffer) { cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); - cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true); + cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::PIXEL_UNPACK_BUFFER, true); - cv::GlTexture tex(buf_gold, true); + cv::ogl::Texture2D tex(buf_gold, true); cv::Mat texData; tex.copyTo(texData, depth); @@ -414,10 +414,10 @@ GPU_TEST_P(GlTexture, ConstructorFromGlBuffer) EXPECT_MAT_NEAR(gold, texData, 1e-2); } -GPU_TEST_P(GlTexture, ConstructorFromGlTexture) +GPU_TEST_P(Texture2D, ConstructorFromTexture2D) { - cv::GlTexture tex_gold(size, format, true); - cv::GlTexture tex(tex_gold); + cv::ogl::Texture2D tex_gold(size, format, true); + cv::ogl::Texture2D tex(tex_gold); EXPECT_EQ(tex_gold.texId(), tex.texId()); EXPECT_EQ(tex_gold.rows(), tex.rows()); @@ -425,9 +425,9 @@ GPU_TEST_P(GlTexture, ConstructorFromGlTexture) EXPECT_EQ(tex_gold.format(), tex.format()); } -GPU_TEST_P(GlTexture, Create) +GPU_TEST_P(Texture2D, Create) { - cv::GlTexture tex; + cv::ogl::Texture2D tex; tex.create(size.height, size.width, format, true); EXPECT_EQ(size.height, tex.rows()); @@ -435,11 +435,11 @@ GPU_TEST_P(GlTexture, Create) EXPECT_EQ(format, tex.format()); } -GPU_TEST_P(GlTexture, CopyFromMat) +GPU_TEST_P(Texture2D, CopyFromMat) { cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); - cv::GlTexture tex; + cv::ogl::Texture2D tex; tex.copyFrom(gold, true); cv::Mat texData; @@ -448,12 +448,12 @@ GPU_TEST_P(GlTexture, CopyFromMat) EXPECT_MAT_NEAR(gold, texData, 1e-2); } -GPU_TEST_P(GlTexture, CopyFromGpuMat) +GPU_TEST_P(Texture2D, CopyFromGpuMat) { cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); cv::gpu::GpuMat d_gold(gold); - cv::GlTexture tex; + cv::ogl::Texture2D tex; tex.copyFrom(d_gold, true); cv::Mat texData; @@ -462,12 +462,12 @@ GPU_TEST_P(GlTexture, CopyFromGpuMat) EXPECT_MAT_NEAR(gold, texData, 1e-2); } -GPU_TEST_P(GlTexture, CopyFromGlBuffer) +GPU_TEST_P(Texture2D, CopyFromBuffer) { cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); - cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true); + cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::PIXEL_UNPACK_BUFFER, true); - cv::GlTexture tex; + cv::ogl::Texture2D tex; tex.copyFrom(buf_gold, true); cv::Mat texData; @@ -476,11 +476,11 @@ GPU_TEST_P(GlTexture, CopyFromGlBuffer) EXPECT_MAT_NEAR(gold, texData, 1e-2); } -GPU_TEST_P(GlTexture, CopyToGpuMat) +GPU_TEST_P(Texture2D, CopyToGpuMat) { cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); - cv::GlTexture tex(gold, true); + cv::ogl::Texture2D tex(gold, true); cv::gpu::GpuMat dst; tex.copyTo(dst, depth); @@ -488,13 +488,13 @@ GPU_TEST_P(GlTexture, CopyToGpuMat) EXPECT_MAT_NEAR(gold, dst, 1e-2); } -GPU_TEST_P(GlTexture, CopyToGlBuffer) +GPU_TEST_P(Texture2D, CopyToBuffer) { cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); - cv::GlTexture tex(gold, true); + cv::ogl::Texture2D tex(gold, true); - cv::GlBuffer dst; + cv::ogl::Buffer dst; tex.copyTo(dst, depth, true); cv::Mat bufData; @@ -503,6 +503,6 @@ GPU_TEST_P(GlTexture, CopyToGlBuffer) EXPECT_MAT_NEAR(gold, bufData, 1e-2); } -INSTANTIATE_TEST_CASE_P(OpenGL, GlTexture, testing::Combine(DIFFERENT_SIZES, testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4))); +INSTANTIATE_TEST_CASE_P(OpenGL, Texture2D, testing::Combine(DIFFERENT_SIZES, testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4))); #endif diff --git a/modules/highgui/include/opencv2/highgui/highgui.hpp b/modules/highgui/include/opencv2/highgui/highgui.hpp index 43cf13dc13..f6f2293042 100644 --- a/modules/highgui/include/opencv2/highgui/highgui.hpp +++ b/modules/highgui/include/opencv2/highgui/highgui.hpp @@ -125,13 +125,18 @@ CV_EXPORTS_W void setTrackbarPos(const string& trackbarname, const string& winna // OpenGL support -typedef void (CV_CDECL *OpenGlDrawCallback)(void* userdata); +typedef void (*OpenGlDrawCallback)(void* userdata); CV_EXPORTS void setOpenGlDrawCallback(const string& winname, OpenGlDrawCallback onOpenGlDraw, void* userdata = 0); 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 CV_EXPORTS CvFont fontQt(const string& nameFont, int pointSize=-1, diff --git a/modules/highgui/src/window.cpp b/modules/highgui/src/window.cpp index 05dee07e3f..b6086076c3 100644 --- a/modules/highgui/src/window.cpp +++ b/modules/highgui/src/window.cpp @@ -241,15 +241,15 @@ void cv::updateWindow(const string& windowName) #ifdef HAVE_OPENGL namespace { - std::map wndTexs; - std::map ownWndTexs; - std::map ownWndBufs; + std::map wndTexs; + std::map ownWndTexs; + std::map ownWndBufs; - void CV_CDECL glDrawTextureCallback(void* userdata) + void glDrawTextureCallback(void* userdata) { - cv::GlTexture* texObj = static_cast(userdata); + cv::ogl::Texture2D* texObj = static_cast(userdata); - cv::render(*texObj); + cv::ogl::render(*texObj); } } #endif // HAVE_OPENGL @@ -283,9 +283,9 @@ void cv::imshow( const string& winname, InputArray _img ) if (_img.kind() == _InputArray::OPENGL_TEXTURE) { - cv::GlTexture& tex = wndTexs[winname]; + cv::ogl::Texture2D& tex = wndTexs[winname]; - tex = _img.getGlTexture(); + tex = _img.getOGlTexture2D(); tex.setAutoRelease(false); @@ -293,11 +293,11 @@ void cv::imshow( const string& winname, InputArray _img ) } else { - cv::GlTexture& tex = ownWndTexs[winname]; + cv::ogl::Texture2D& tex = ownWndTexs[winname]; if (_img.kind() == _InputArray::GPU_MAT) { - cv::GlBuffer& buf = ownWndBufs[winname]; + cv::ogl::Buffer& buf = ownWndBufs[winname]; buf.copyFrom(_img); buf.setAutoRelease(false); @@ -319,6 +319,16 @@ void cv::imshow( const string& winname, InputArray _img ) #endif } +void cv::pointCloudShow(const string&, const GlCamera&, const GlArrays&) +{ + CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it"); +} + +void cv::pointCloudShow(const string&, const GlCamera&, InputArray, InputArray) +{ + CV_Error(CV_StsNotImplemented, "This function in deprecated, do not use it"); +} + // Without OpenGL #ifndef HAVE_OPENGL diff --git a/samples/gpu/opengl.cpp b/samples/gpu/opengl.cpp index 11243377d4..5b84a5bef5 100644 --- a/samples/gpu/opengl.cpp +++ b/samples/gpu/opengl.cpp @@ -37,39 +37,20 @@ const int win_height = 640; struct DrawData { - GlArrays arr; - GlTexture tex; - GlBuffer indices; + ogl::Arrays arr; + ogl::Texture2D tex; + ogl::Buffer indices; }; -void CV_CDECL draw(void* userdata); +void draw(void* userdata); -void CV_CDECL draw(void* userdata) +void draw(void* userdata) { - static double angle = 0.0; - DrawData* data = static_cast(userdata); - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - gluPerspective(45.0, (double)win_width / win_height, 0.1, 100.0); + glRotated(0.6, 0, 1, 0); - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); - gluLookAt(0, 0, 3, 0, 0, 0, 0, 1, 0); - glRotated(angle, 0, 1, 0); - - glEnable(GL_TEXTURE_2D); - data->tex.bind(); - - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTexEnvi(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_REPLACE); - - glDisable(GL_CULL_FACE); - - render(data->arr, data->indices, RenderMode::TRIANGLES); - - angle += 0.3; + ogl::render(data->arr, data->indices, ogl::TRIANGLES); } int main(int argc, char* argv[]) @@ -106,12 +87,28 @@ int main(int argc, char* argv[]) data.indices.copyFrom(indices); data.tex.copyFrom(img); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + gluPerspective(45.0, (double)win_width / win_height, 0.1, 100.0); + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + gluLookAt(0, 0, 3, 0, 0, 0, 0, 1, 0); + + glEnable(GL_TEXTURE_2D); + data.tex.bind(); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexEnvi(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_REPLACE); + + glDisable(GL_CULL_FACE); + setOpenGlDrawCallback("OpenGL", draw, &data); for (;;) { updateWindow("OpenGL"); - int key = waitKey(10); + int key = waitKey(40); if ((key & 0xff) == 27) break; } @@ -122,4 +119,4 @@ int main(int argc, char* argv[]) return 0; } -#endif \ No newline at end of file +#endif From 21f95a3b11eb15ebfd89966fc1729e11df11c017 Mon Sep 17 00:00:00 2001 From: Vladislav Vinogradov Date: Thu, 21 Feb 2013 12:31:04 +0400 Subject: [PATCH 11/24] restored source compatibility --- modules/core/include/opencv2/core/internal.hpp | 14 +++++++++++++- .../core/include/opencv2/core/opengl_interop.hpp | 9 +-------- 2 files changed, 14 insertions(+), 9 deletions(-) diff --git a/modules/core/include/opencv2/core/internal.hpp b/modules/core/include/opencv2/core/internal.hpp index 8423f5afb2..5335fa01f8 100644 --- a/modules/core/include/opencv2/core/internal.hpp +++ b/modules/core/include/opencv2/core/internal.hpp @@ -752,7 +752,7 @@ typedef struct CvBigFuncTable #ifdef __cplusplus -// Deprecated +// < Deprecated class CV_EXPORTS CvOpenGlFuncTab { @@ -779,6 +779,18 @@ 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( (cv::ogl::checkError(__FILE__, __LINE__, __func__)) ) +#else + #define CV_CheckGlError() CV_DbgAssert( (cv::ogl::checkError(__FILE__, __LINE__)) ) +#endif + #endif //__cplusplus #endif // __OPENCV_CORE_INTERNAL_HPP__ diff --git a/modules/core/include/opencv2/core/opengl_interop.hpp b/modules/core/include/opencv2/core/opengl_interop.hpp index 04d8b8cf2e..178a949886 100644 --- a/modules/core/include/opencv2/core/opengl_interop.hpp +++ b/modules/core/include/opencv2/core/opengl_interop.hpp @@ -46,17 +46,10 @@ #ifdef __cplusplus #include "opencv2/core/core.hpp" +#include "opencv2/core/opengl_interop_deprecated.hpp" 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( (cv::gl::checkError(__FILE__, __LINE__, __func__)) ) -#else - #define CV_CheckGlError() CV_DbgAssert( (cv::gl::checkError(__FILE__, __LINE__)) ) -#endif - /////////////////// OpenGL Objects /////////////////// //! Smart pointer for OpenGL buffer memory with reference counting. From 9f39c8eaa194e59fb47c623a9c27cc51a0072896 Mon Sep 17 00:00:00 2001 From: Alexander Smorkalov Date: Thu, 21 Feb 2013 14:42:28 +0400 Subject: [PATCH 12/24] OpenCV 2.4.4 preparation Manager verison incremented; Additional constatnt for library intialization added; Documents updated. --- android/service/doc/BaseLoaderCallback.rst | 2 +- android/service/doc/JavaHelper.rst | 4 +++ android/service/engine/AndroidManifest.xml | 4 +-- android/service/readme.txt | 28 +++++++++---------- .../src/java/android+OpenCVLoader.java | 5 ++++ 5 files changed, 26 insertions(+), 17 deletions(-) diff --git a/android/service/doc/BaseLoaderCallback.rst b/android/service/doc/BaseLoaderCallback.rst index 3258004c59..71915c449d 100644 --- a/android/service/doc/BaseLoaderCallback.rst +++ b/android/service/doc/BaseLoaderCallback.rst @@ -48,7 +48,7 @@ See the "15-puzzle" OpenCV sample for details. super.onResume(); Log.i(TAG, "Trying to load OpenCV library"); - if (!OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_3, this, mOpenCVCallBack)) + if (!OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_4, this, mOpenCVCallBack)) { Log.e(TAG, "Cannot connect to OpenCV Manager"); } diff --git a/android/service/doc/JavaHelper.rst b/android/service/doc/JavaHelper.rst index 9a128db0ab..34798c267e 100644 --- a/android/service/doc/JavaHelper.rst +++ b/android/service/doc/JavaHelper.rst @@ -47,3 +47,7 @@ OpenCV version constants .. data:: OPENCV_VERSION_2_4_3 OpenCV Library version 2.4.3 + +.. data:: OPENCV_VERSION_2_4_4 + + OpenCV Library version 2.4.4 diff --git a/android/service/engine/AndroidManifest.xml b/android/service/engine/AndroidManifest.xml index 4af9652027..f4f0eb94fa 100644 --- a/android/service/engine/AndroidManifest.xml +++ b/android/service/engine/AndroidManifest.xml @@ -1,8 +1,8 @@ + android:versionCode="26@ANDROID_PLATFORM_VERSION_CODE@" + android:versionName="2.6" > diff --git a/android/service/readme.txt b/android/service/readme.txt index 7da05853ae..df17c18245 100644 --- a/android/service/readme.txt +++ b/android/service/readme.txt @@ -14,20 +14,20 @@ manually using adb tool: .. code-block:: sh - adb install OpenCV-2.4.3-android-sdk/apk/OpenCV_2.4.3.2_Manager_2.4_.apk + adb install OpenCV-2.4.4-android-sdk/apk/OpenCV_2.4.4_Manager_2.6_.apk Use the table below to determine proper OpenCV Manager package for your device: -+------------------------------+--------------+-----------------------------------------------------+ -| Hardware Platform | Android ver. | Package name | -+==============================+==============+=====================================================+ -| armeabi-v7a (ARMv7-A + NEON) | >= 2.3 | OpenCV_2.4.3.2_Manager_2.4_armv7a-neon.apk | -+------------------------------+--------------+-----------------------------------------------------+ -| armeabi-v7a (ARMv7-A + NEON) | = 2.2 | OpenCV_2.4.3.2_Manager_2.4_armv7a-neon-android8.apk | -+------------------------------+--------------+-----------------------------------------------------+ -| armeabi (ARMv5, ARMv6) | >= 2.3 | OpenCV_2.4.3.2_Manager_2.4_armeabi.apk | -+------------------------------+--------------+-----------------------------------------------------+ -| Intel x86 | >= 2.3 | OpenCV_2.4.3.2_Manager_2.4_x86.apk | -+------------------------------+--------------+-----------------------------------------------------+ -| MIPS | >= 2.3 | OpenCV_2.4.3.2_Manager_2.4_mips.apk | -+------------------------------+--------------+-----------------------------------------------------+ ++------------------------------+--------------+---------------------------------------------------+ +| Hardware Platform | Android ver. | Package name | ++==============================+==============+===================================================+ +| armeabi-v7a (ARMv7-A + NEON) | >= 2.3 | OpenCV_2.4.4_Manager_2.6_armv7a-neon.apk | ++------------------------------+--------------+---------------------------------------------------+ +| armeabi-v7a (ARMv7-A + NEON) | = 2.2 | OpenCV_2.4.4_Manager_2.6_armv7a-neon-android8.apk | ++------------------------------+--------------+---------------------------------------------------+ +| armeabi (ARMv5, ARMv6) | >= 2.3 | OpenCV_2.4.4_Manager_2.6_armeabi.apk | ++------------------------------+--------------+---------------------------------------------------+ +| Intel x86 | >= 2.3 | OpenCV_2.4.4_Manager_2.6_x86.apk | ++------------------------------+--------------+---------------------------------------------------+ +| MIPS | >= 2.3 | OpenCV_2.4.4_Manager_2.6_mips.apk | ++------------------------------+--------------+---------------------------------------------------+ diff --git a/modules/java/generator/src/java/android+OpenCVLoader.java b/modules/java/generator/src/java/android+OpenCVLoader.java index 4c3655c12c..70e94944dd 100644 --- a/modules/java/generator/src/java/android+OpenCVLoader.java +++ b/modules/java/generator/src/java/android+OpenCVLoader.java @@ -17,6 +17,11 @@ public class OpenCVLoader */ public static final String OPENCV_VERSION_2_4_3 = "2.4.3"; + /** + * OpenCV Library version 2.4.4. + */ + public static final String OPENCV_VERSION_2_4_4 = "2.4.4"; + /** * Loads and initializes OpenCV library from current application package. Roughly, it's an analog of system.loadLibrary("opencv_java"). * @return Returns true is initialization of OpenCV was successful. From 8b1f88c40f273ed5ce5accd4ca813a1d95e60ecb Mon Sep 17 00:00:00 2001 From: Vladislav Vinogradov Date: Thu, 21 Feb 2013 16:12:33 +0400 Subject: [PATCH 13/24] updated gpu module API --- modules/core/src/gpumat.cpp | 16 +- .../doc/feature_detection_and_description.rst | 150 +++++++++--------- modules/gpu/doc/object_detection.rst | 4 +- modules/gpu/include/opencv2/gpu/gpu.hpp | 94 ++++------- modules/gpu/perf/perf_features2d.cpp | 9 +- modules/gpu/src/cascadeclassifier.cpp | 9 ++ modules/gpu/src/hough.cpp | 8 +- modules/gpu/src/imgproc.cpp | 39 ++--- modules/gpu/src/pyrlk.cpp | 35 +++- modules/gpu/test/test_features2d.cpp | 24 +-- modules/gpu/test/test_gpumat.cpp | 34 ++++ modules/stitching/src/matchers.cpp | 2 +- samples/gpu/{morfology.cpp => morphology.cpp} | 0 samples/gpu/performance/tests.cpp | 2 +- samples/gpu/surf_keypoint_matcher.cpp | 4 +- 15 files changed, 221 insertions(+), 209 deletions(-) rename samples/gpu/{morfology.cpp => morphology.cpp} (100%) diff --git a/modules/core/src/gpumat.cpp b/modules/core/src/gpumat.cpp index 269e11b635..53e118ad71 100644 --- a/modules/core/src/gpumat.cpp +++ b/modules/core/src/gpumat.cpp @@ -361,13 +361,13 @@ size_t cv::gpu::DeviceInfo::sharedMemPerBlock() const return deviceProps.get(device_id_)->sharedMemPerBlock; } -void cv::gpu::DeviceInfo::queryMemory(size_t& totalMemory, size_t& freeMemory) const +void cv::gpu::DeviceInfo::queryMemory(size_t& _totalMemory, size_t& _freeMemory) const { int prevDeviceID = getDevice(); if (prevDeviceID != device_id_) setDevice(device_id_); - cudaSafeCall( cudaMemGetInfo(&freeMemory, &totalMemory) ); + cudaSafeCall( cudaMemGetInfo(&_freeMemory, &_totalMemory) ); if (prevDeviceID != device_id_) setDevice(prevDeviceID); @@ -375,16 +375,16 @@ void cv::gpu::DeviceInfo::queryMemory(size_t& totalMemory, size_t& freeMemory) c size_t cv::gpu::DeviceInfo::freeMemory() const { - size_t totalMemory, freeMemory; - queryMemory(totalMemory, freeMemory); - return freeMemory; + size_t _totalMemory, _freeMemory; + queryMemory(_totalMemory, _freeMemory); + return _freeMemory; } size_t cv::gpu::DeviceInfo::totalMemory() const { - size_t totalMemory, freeMemory; - queryMemory(totalMemory, freeMemory); - return totalMemory; + size_t _totalMemory, _freeMemory; + queryMemory(_totalMemory, _freeMemory); + return _totalMemory; } bool cv::gpu::DeviceInfo::supports(FeatureSet feature_set) const diff --git a/modules/gpu/doc/feature_detection_and_description.rst b/modules/gpu/doc/feature_detection_and_description.rst index aafc35a50d..4129ba8f09 100644 --- a/modules/gpu/doc/feature_detection_and_description.rst +++ b/modules/gpu/doc/feature_detection_and_description.rst @@ -370,16 +370,16 @@ Releases inner buffer memory. -gpu::BruteForceMatcher_GPU_base -------------------------------- -.. ocv:class:: gpu::BruteForceMatcher_GPU_base +gpu::BFMatcher_GPU +-------------------------- +.. ocv:class:: gpu::BFMatcher_GPU Brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest descriptor in the second set by trying each one. This descriptor matcher supports masking permissible matches between descriptor sets. :: - class BruteForceMatcher_GPU_base + class BFMatcher_GPU { public: - explicit BruteForceMatcher_GPU_base(int norm = cv::NORM_L2); + explicit BFMatcher_GPU(int norm = cv::NORM_L2); // Add descriptors to train descriptor collection. void add(const std::vector& descCollection); @@ -478,67 +478,67 @@ Brute-force descriptor matcher. For each descriptor in the first set, this match }; -The class ``BruteForceMatcher_GPU_base`` has an interface similar to the class :ocv:class:`DescriptorMatcher`. It has two groups of ``match`` methods: for matching descriptors of one image with another image or with an image set. Also, all functions have an alternative to save results either to the GPU memory or to the CPU memory. +The class ``BFMatcher_GPU`` has an interface similar to the class :ocv:class:`DescriptorMatcher`. It has two groups of ``match`` methods: for matching descriptors of one image with another image or with an image set. Also, all functions have an alternative to save results either to the GPU memory or to the CPU memory. .. seealso:: :ocv:class:`DescriptorMatcher`, :ocv:class:`BFMatcher` -gpu::BruteForceMatcher_GPU_base::match --------------------------------------- +gpu::BFMatcher_GPU::match +------------------------------------- Finds the best match for each descriptor from a query set with train descriptors. -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::match(const GpuMat& query, const GpuMat& train, std::vector& matches, const GpuMat& mask = GpuMat()) +.. ocv:function:: void gpu::BFMatcher_GPU::match(const GpuMat& query, const GpuMat& train, std::vector& matches, const GpuMat& mask = GpuMat()) -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::matchSingle(const GpuMat& query, const GpuMat& train, GpuMat& trainIdx, GpuMat& distance, const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null()) +.. ocv:function:: void gpu::BFMatcher_GPU::matchSingle(const GpuMat& query, const GpuMat& train, GpuMat& trainIdx, GpuMat& distance, const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null()) -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::match(const GpuMat& query, std::vector& matches, const std::vector& masks = std::vector()) +.. ocv:function:: void gpu::BFMatcher_GPU::match(const GpuMat& query, std::vector& matches, const std::vector& masks = std::vector()) -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::matchCollection( const GpuMat& query, const GpuMat& trainCollection, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, const GpuMat& masks=GpuMat(), Stream& stream=Stream::Null() ) +.. ocv:function:: void gpu::BFMatcher_GPU::matchCollection( const GpuMat& query, const GpuMat& trainCollection, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, const GpuMat& masks=GpuMat(), Stream& stream=Stream::Null() ) .. seealso:: :ocv:func:`DescriptorMatcher::match` -gpu::BruteForceMatcher_GPU_base::makeGpuCollection --------------------------------------------------- -Performs a GPU collection of train descriptors and masks in a suitable format for the :ocv:func:`gpu::BruteForceMatcher_GPU_base::matchCollection` function. +gpu::BFMatcher_GPU::makeGpuCollection +------------------------------------------------- +Performs a GPU collection of train descriptors and masks in a suitable format for the :ocv:func:`gpu::BFMatcher_GPU::matchCollection` function. -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection, const vector& masks = std::vector()) +.. ocv:function:: void gpu::BFMatcher_GPU::makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection, const vector& masks = std::vector()) -gpu::BruteForceMatcher_GPU_base::matchDownload ----------------------------------------------- -Downloads matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU_base::matchSingle` or :ocv:func:`gpu::BruteForceMatcher_GPU_base::matchCollection` to vector with :ocv:class:`DMatch`. - -.. ocv:function:: static void gpu::BruteForceMatcher_GPU_base::matchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector&matches) - -.. ocv:function:: static void gpu::BruteForceMatcher_GPU_base::matchDownload( const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, std::vector& matches ) - - - -gpu::BruteForceMatcher_GPU_base::matchConvert +gpu::BFMatcher_GPU::matchDownload --------------------------------------------- -Converts matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU_base::matchSingle` or :ocv:func:`gpu::BruteForceMatcher_GPU_base::matchCollection` to vector with :ocv:class:`DMatch`. +Downloads matrices obtained via :ocv:func:`gpu::BFMatcher_GPU::matchSingle` or :ocv:func:`gpu::BFMatcher_GPU::matchCollection` to vector with :ocv:class:`DMatch`. -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::matchConvert(const Mat& trainIdx, const Mat& distance, std::vector&matches) +.. ocv:function:: static void gpu::BFMatcher_GPU::matchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector&matches) -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::matchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector&matches) +.. ocv:function:: static void gpu::BFMatcher_GPU::matchDownload( const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, std::vector& matches ) -gpu::BruteForceMatcher_GPU_base::knnMatch ------------------------------------------ +gpu::BFMatcher_GPU::matchConvert +--------------------------------------------- +Converts matrices obtained via :ocv:func:`gpu::BFMatcher_GPU::matchSingle` or :ocv:func:`gpu::BFMatcher_GPU::matchCollection` to vector with :ocv:class:`DMatch`. + +.. ocv:function:: void gpu::BFMatcher_GPU::matchConvert(const Mat& trainIdx, const Mat& distance, std::vector&matches) + +.. ocv:function:: void gpu::BFMatcher_GPU::matchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector&matches) + + + +gpu::BFMatcher_GPU::knnMatch +---------------------------------------- Finds the ``k`` best matches for each descriptor from a query set with train descriptors. -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatch(const GpuMat& query, const GpuMat& train, std::vector< std::vector >&matches, int k, const GpuMat& mask = GpuMat(), bool compactResult = false) +.. ocv:function:: void gpu::BFMatcher_GPU::knnMatch(const GpuMat& query, const GpuMat& train, std::vector< std::vector >&matches, int k, const GpuMat& mask = GpuMat(), bool compactResult = false) -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatchSingle(const GpuMat& query, const GpuMat& train, GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k, const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null()) +.. ocv:function:: void gpu::BFMatcher_GPU::knnMatchSingle(const GpuMat& query, const GpuMat& train, GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k, const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null()) -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatch(const GpuMat& query, std::vector< std::vector >&matches, int k, const std::vector&masks = std::vector(), bool compactResult = false ) +.. ocv:function:: void gpu::BFMatcher_GPU::knnMatch(const GpuMat& query, std::vector< std::vector >&matches, int k, const std::vector&masks = std::vector(), bool compactResult = false ) -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatch2Collection(const GpuMat& query, const GpuMat& trainCollection, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, const GpuMat& maskCollection = GpuMat(), Stream& stream = Stream::Null()) +.. ocv:function:: void gpu::BFMatcher_GPU::knnMatch2Collection(const GpuMat& query, const GpuMat& trainCollection, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, const GpuMat& maskCollection = GpuMat(), Stream& stream = Stream::Null()) :param query: Query set of descriptors. @@ -560,41 +560,41 @@ The third variant of the method stores the results in GPU memory. -gpu::BruteForceMatcher_GPU_base::knnMatchDownload -------------------------------------------------- -Downloads matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU_base::knnMatchSingle` or :ocv:func:`gpu::BruteForceMatcher_GPU_base::knnMatch2Collection` to vector with :ocv:class:`DMatch`. - -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector< std::vector >&matches, bool compactResult = false) - -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatch2Download(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, std::vector< std::vector >& matches, bool compactResult = false) - -If ``compactResult`` is ``true`` , the ``matches`` vector does not contain matches for fully masked-out query descriptors. - - - -gpu::BruteForceMatcher_GPU_base::knnMatchConvert +gpu::BFMatcher_GPU::knnMatchDownload ------------------------------------------------ -Converts matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU_base::knnMatchSingle` or :ocv:func:`gpu::BruteForceMatcher_GPU_base::knnMatch2Collection` to CPU vector with :ocv:class:`DMatch`. +Downloads matrices obtained via :ocv:func:`gpu::BFMatcher_GPU::knnMatchSingle` or :ocv:func:`gpu::BFMatcher_GPU::knnMatch2Collection` to vector with :ocv:class:`DMatch`. -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatchConvert(const Mat& trainIdx, const Mat& distance, std::vector< std::vector >&matches, bool compactResult = false) +.. ocv:function:: void gpu::BFMatcher_GPU::knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector< std::vector >&matches, bool compactResult = false) -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatch2Convert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector< std::vector >& matches, bool compactResult = false) +.. ocv:function:: void gpu::BFMatcher_GPU::knnMatch2Download(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, std::vector< std::vector >& matches, bool compactResult = false) If ``compactResult`` is ``true`` , the ``matches`` vector does not contain matches for fully masked-out query descriptors. -gpu::BruteForceMatcher_GPU_base::radiusMatch --------------------------------------------- +gpu::BFMatcher_GPU::knnMatchConvert +------------------------------------------------ +Converts matrices obtained via :ocv:func:`gpu::BFMatcher_GPU::knnMatchSingle` or :ocv:func:`gpu::BFMatcher_GPU::knnMatch2Collection` to CPU vector with :ocv:class:`DMatch`. + +.. ocv:function:: void gpu::BFMatcher_GPU::knnMatchConvert(const Mat& trainIdx, const Mat& distance, std::vector< std::vector >&matches, bool compactResult = false) + +.. ocv:function:: void gpu::BFMatcher_GPU::knnMatch2Convert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector< std::vector >& matches, bool compactResult = false) + +If ``compactResult`` is ``true`` , the ``matches`` vector does not contain matches for fully masked-out query descriptors. + + + +gpu::BFMatcher_GPU::radiusMatch +------------------------------------------- For each query descriptor, finds the best matches with a distance less than a given threshold. -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatch(const GpuMat& query, const GpuMat& train, std::vector< std::vector >&matches, float maxDistance, const GpuMat& mask = GpuMat(), bool compactResult = false) +.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatch(const GpuMat& query, const GpuMat& train, std::vector< std::vector >&matches, float maxDistance, const GpuMat& mask = GpuMat(), bool compactResult = false) -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatchSingle(const GpuMat& query, const GpuMat& train, GpuMat& trainIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance, const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null()) +.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatchSingle(const GpuMat& query, const GpuMat& train, GpuMat& trainIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance, const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null()) -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatch(const GpuMat& query, std::vector< std::vector >&matches, float maxDistance, const std::vector& masks = std::vector(), bool compactResult = false) +.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatch(const GpuMat& query, std::vector< std::vector >&matches, float maxDistance, const std::vector& masks = std::vector(), bool compactResult = false) -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatchCollection(const GpuMat& query, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance, const std::vector& masks = std::vector(), Stream& stream = Stream::Null()) +.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatchCollection(const GpuMat& query, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance, const std::vector& masks = std::vector(), Stream& stream = Stream::Null()) :param query: Query set of descriptors. @@ -618,26 +618,26 @@ The third variant of the method stores the results in GPU memory and does not st -gpu::BruteForceMatcher_GPU_base::radiusMatchDownload ----------------------------------------------------- -Downloads matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU_base::radiusMatchSingle` or :ocv:func:`gpu::BruteForceMatcher_GPU_base::radiusMatchCollection` to vector with :ocv:class:`DMatch`. - -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, const GpuMat& nMatches, std::vector< std::vector >&matches, bool compactResult = false) - -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, const GpuMat& nMatches, std::vector< std::vector >& matches, bool compactResult = false) - -If ``compactResult`` is ``true`` , the ``matches`` vector does not contain matches for fully masked-out query descriptors. - - - - -gpu::BruteForceMatcher_GPU_base::radiusMatchConvert +gpu::BFMatcher_GPU::radiusMatchDownload --------------------------------------------------- -Converts matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU_base::radiusMatchSingle` or :ocv:func:`gpu::BruteForceMatcher_GPU_base::radiusMatchCollection` to vector with :ocv:class:`DMatch`. +Downloads matrices obtained via :ocv:func:`gpu::BFMatcher_GPU::radiusMatchSingle` or :ocv:func:`gpu::BFMatcher_GPU::radiusMatchCollection` to vector with :ocv:class:`DMatch`. -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatchConvert(const Mat& trainIdx, const Mat& distance, const Mat& nMatches, std::vector< std::vector >&matches, bool compactResult = false) +.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, const GpuMat& nMatches, std::vector< std::vector >&matches, bool compactResult = false) -.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, const Mat& nMatches, std::vector< std::vector >& matches, bool compactResult = false) +.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, const GpuMat& nMatches, std::vector< std::vector >& matches, bool compactResult = false) + +If ``compactResult`` is ``true`` , the ``matches`` vector does not contain matches for fully masked-out query descriptors. + + + + +gpu::BFMatcher_GPU::radiusMatchConvert +--------------------------------------------------- +Converts matrices obtained via :ocv:func:`gpu::BFMatcher_GPU::radiusMatchSingle` or :ocv:func:`gpu::BFMatcher_GPU::radiusMatchCollection` to vector with :ocv:class:`DMatch`. + +.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatchConvert(const Mat& trainIdx, const Mat& distance, const Mat& nMatches, std::vector< std::vector >&matches, bool compactResult = false) + +.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, const Mat& nMatches, std::vector< std::vector >& matches, bool compactResult = false) If ``compactResult`` is ``true`` , the ``matches`` vector does not contain matches for fully masked-out query descriptors. diff --git a/modules/gpu/doc/object_detection.rst b/modules/gpu/doc/object_detection.rst index 20e301300e..133660236a 100644 --- a/modules/gpu/doc/object_detection.rst +++ b/modules/gpu/doc/object_detection.rst @@ -271,7 +271,9 @@ gpu::CascadeClassifier_GPU::detectMultiScale ------------------------------------------------ Detects objects of different sizes in the input image. -.. ocv:function:: int gpu::CascadeClassifier_GPU::detectMultiScale( const GpuMat& image, GpuMat& objectsBuf, double scaleFactor=1.1, int minNeighbors=4, Size minSize=Size() ) +.. ocv:function:: int gpu::CascadeClassifier_GPU::detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size()) + +.. ocv:function:: int gpu::CascadeClassifier_GPU::detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, Size maxObjectSize, Size minSize = Size(), double scaleFactor = 1.1, int minNeighbors = 4) :param image: Matrix of type ``CV_8U`` containing an image where objects should be detected. diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp index 7cc57e49af..afbe067a3e 100644 --- a/modules/gpu/include/opencv2/gpu/gpu.hpp +++ b/modules/gpu/include/opencv2/gpu/gpu.hpp @@ -804,31 +804,24 @@ private: GpuMat lab, l, ab; }; +struct CV_EXPORTS CannyBuf +{ + void create(const Size& image_size, int apperture_size = 3); + void release(); -struct CV_EXPORTS CannyBuf; + GpuMat dx, dy; + GpuMat mag; + GpuMat map; + GpuMat st1, st2; + GpuMat unused; + Ptr filterDX, filterDY; +}; CV_EXPORTS void Canny(const GpuMat& image, GpuMat& edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false); CV_EXPORTS void Canny(const GpuMat& image, CannyBuf& buf, GpuMat& edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false); CV_EXPORTS void Canny(const GpuMat& dx, const GpuMat& dy, GpuMat& edges, double low_thresh, double high_thresh, bool L2gradient = false); CV_EXPORTS void Canny(const GpuMat& dx, const GpuMat& dy, CannyBuf& buf, GpuMat& edges, double low_thresh, double high_thresh, bool L2gradient = false); -struct CV_EXPORTS CannyBuf -{ - CannyBuf() {} - explicit CannyBuf(const Size& image_size, int apperture_size = 3) {create(image_size, apperture_size);} - CannyBuf(const GpuMat& dx_, const GpuMat& dy_); - - void create(const Size& image_size, int apperture_size = 3); - - void release(); - - GpuMat dx, dy; - GpuMat dx_buf, dy_buf; - GpuMat edgeBuf; - GpuMat trackBuf1, trackBuf2; - Ptr filterDX, filterDY; -}; - class CV_EXPORTS ImagePyramid { public: @@ -1504,6 +1497,12 @@ public: explicit BruteForceMatcher_GPU(Hamming /*d*/) : BruteForceMatcher_GPU_base(HammingDist) {} }; +class CV_EXPORTS BFMatcher_GPU : public BruteForceMatcher_GPU_base +{ +public: + explicit BFMatcher_GPU(int norm = NORM_L2) : BruteForceMatcher_GPU_base(norm == NORM_L1 ? L1Dist : norm == NORM_L2 ? L2Dist : HammingDist) {} +}; + ////////////////////////////////// CascadeClassifier_GPU ////////////////////////////////////////// // The cascade classifier class for object detection: supports old haar and new lbp xlm formats and nvbin for haar cascades olny. class CV_EXPORTS CascadeClassifier_GPU @@ -1518,7 +1517,8 @@ public: void release(); /* returns number of detected objects */ - int detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, double scaleFactor = 1.1, int minNeighbors = 4, Size minSize = Size()); + int detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, double scaleFactor = 1.2, int minNeighbors = 4, Size minSize = Size()); + int detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, Size maxObjectSize, Size minSize = Size(), double scaleFactor = 1.1, int minNeighbors = 4); bool findLargestObject; bool visualizeInPlace; @@ -1526,7 +1526,6 @@ public: Size getClassifierSize() const; private: - struct CascadeClassifierImpl; CascadeClassifierImpl* impl; struct HaarCascade; @@ -1858,64 +1857,33 @@ inline GoodFeaturesToTrackDetector_GPU::GoodFeaturesToTrackDetector_GPU(int maxC class CV_EXPORTS PyrLKOpticalFlow { public: - PyrLKOpticalFlow() - { - winSize = Size(21, 21); - maxLevel = 3; - iters = 30; - derivLambda = 0.5; - useInitialFlow = false; - minEigThreshold = 1e-4f; - getMinEigenVals = false; - isDeviceArch11_ = !DeviceInfo().supports(FEATURE_SET_COMPUTE_12); - } + PyrLKOpticalFlow(); void sparse(const GpuMat& prevImg, const GpuMat& nextImg, const GpuMat& prevPts, GpuMat& nextPts, GpuMat& status, GpuMat* err = 0); void dense(const GpuMat& prevImg, const GpuMat& nextImg, GpuMat& u, GpuMat& v, GpuMat* err = 0); + void releaseMemory(); + Size winSize; int maxLevel; int iters; - double derivLambda; + double derivLambda; //unused bool useInitialFlow; - float minEigThreshold; - bool getMinEigenVals; - - void releaseMemory() - { - dx_calcBuf_.release(); - dy_calcBuf_.release(); - - prevPyr_.clear(); - nextPyr_.clear(); - - dx_buf_.release(); - dy_buf_.release(); - - uPyr_.clear(); - vPyr_.clear(); - } + float minEigThreshold; //unused + bool getMinEigenVals; //unused private: - void calcSharrDeriv(const GpuMat& src, GpuMat& dx, GpuMat& dy); - - void buildImagePyramid(const GpuMat& img0, vector& pyr, bool withBorder); - - GpuMat dx_calcBuf_; - GpuMat dy_calcBuf_; - + GpuMat uPyr_[2]; vector prevPyr_; vector nextPyr_; + GpuMat vPyr_[2]; + vector unused1; + vector unused2; + bool unused3; - GpuMat dx_buf_; - GpuMat dy_buf_; - - vector uPyr_; - vector vPyr_; - - bool isDeviceArch11_; + GpuMat buf_; }; diff --git a/modules/gpu/perf/perf_features2d.cpp b/modules/gpu/perf/perf_features2d.cpp index 7c966af302..a93cef9b33 100644 --- a/modules/gpu/perf/perf_features2d.cpp +++ b/modules/gpu/perf/perf_features2d.cpp @@ -161,8 +161,7 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(Values(64, 128, 256), Val if (PERF_RUN_GPU()) { - cv::gpu::BruteForceMatcher_GPU_base d_matcher( - cv::gpu::BruteForceMatcher_GPU_base::DistType((normType -2) / 2)); + cv::gpu::BFMatcher_GPU d_matcher(normType); cv::gpu::GpuMat d_query(query); cv::gpu::GpuMat d_train(train); @@ -221,8 +220,7 @@ PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine( if (PERF_RUN_GPU()) { - cv::gpu::BruteForceMatcher_GPU_base d_matcher( - cv::gpu::BruteForceMatcher_GPU_base::DistType((normType -2) / 2)); + cv::gpu::BFMatcher_GPU d_matcher(normType); cv::gpu::GpuMat d_query(query); cv::gpu::GpuMat d_train(train); @@ -275,8 +273,7 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(Values(64, 128, 256 if (PERF_RUN_GPU()) { - cv::gpu::BruteForceMatcher_GPU_base d_matcher( - cv::gpu::BruteForceMatcher_GPU_base::DistType((normType -2) / 2)); + cv::gpu::BFMatcher_GPU d_matcher(normType); cv::gpu::GpuMat d_query(query); cv::gpu::GpuMat d_train(train); diff --git a/modules/gpu/src/cascadeclassifier.cpp b/modules/gpu/src/cascadeclassifier.cpp index cfaa753114..3603933979 100644 --- a/modules/gpu/src/cascadeclassifier.cpp +++ b/modules/gpu/src/cascadeclassifier.cpp @@ -58,6 +58,7 @@ bool cv::gpu::CascadeClassifier_GPU::load(const string&) { throw_no Size cv::gpu::CascadeClassifier_GPU::getClassifierSize() const { throw_nogpu(); return Size();} void cv::gpu::CascadeClassifier_GPU::release() { throw_nogpu(); } int cv::gpu::CascadeClassifier_GPU::detectMultiScale( const GpuMat&, GpuMat&, double, int, Size) {throw_nogpu(); return -1;} +int cv::gpu::CascadeClassifier_GPU::detectMultiScale( const GpuMat&, GpuMat&, Size, Size, double, int) {throw_nogpu(); return -1;} #else @@ -682,6 +683,12 @@ int cv::gpu::CascadeClassifier_GPU::detectMultiScale( const GpuMat& image, GpuMa return impl->process(image, objectsBuf, (float)scaleFactor, minNeighbors, findLargestObject, visualizeInPlace, minSize, cv::Size()); } +int cv::gpu::CascadeClassifier_GPU::detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, Size maxObjectSize, Size minSize, double scaleFactor, int minNeighbors) +{ + CV_Assert( !this->empty()); + return impl->process(image, objectsBuf, (float)scaleFactor, minNeighbors, findLargestObject, visualizeInPlace, minSize, maxObjectSize); +} + bool cv::gpu::CascadeClassifier_GPU::load(const string& filename) { release(); @@ -771,6 +778,8 @@ NCVStatus loadFromXML(const std::string &filename, haar.bNeedsTiltedII = false; Ncv32u curMaxTreeDepth; + std::vector xmlFileCont; + std::vector h_TmpClassifierNotRootNodes; haarStages.resize(0); haarClassifierNodes.resize(0); diff --git a/modules/gpu/src/hough.cpp b/modules/gpu/src/hough.cpp index fecb717cd9..09cf01850e 100644 --- a/modules/gpu/src/hough.cpp +++ b/modules/gpu/src/hough.cpp @@ -121,9 +121,7 @@ void cv::gpu::HoughLines(const GpuMat& src, GpuMat& lines, HoughLinesBuf& buf, f buf.accum.setTo(Scalar::all(0)); DeviceInfo devInfo; - cudaDeviceProp prop; - cudaSafeCall(cudaGetDeviceProperties(&prop, devInfo.deviceID())); - linesAccum_gpu(srcPoints, pointsCount, buf.accum, rho, theta, prop.sharedMemPerBlock, devInfo.supports(FEATURE_SET_COMPUTE_20)); + linesAccum_gpu(srcPoints, pointsCount, buf.accum, rho, theta, devInfo.sharedMemPerBlock(), devInfo.supports(FEATURE_SET_COMPUTE_20)); ensureSizeIsEnough(2, maxLines, CV_32FC2, lines); @@ -196,9 +194,7 @@ void cv::gpu::HoughLinesP(const GpuMat& src, GpuMat& lines, HoughLinesBuf& buf, buf.accum.setTo(Scalar::all(0)); DeviceInfo devInfo; - cudaDeviceProp prop; - cudaSafeCall(cudaGetDeviceProperties(&prop, devInfo.deviceID())); - linesAccum_gpu(srcPoints, pointsCount, buf.accum, rho, theta, prop.sharedMemPerBlock, devInfo.supports(FEATURE_SET_COMPUTE_20)); + linesAccum_gpu(srcPoints, pointsCount, buf.accum, rho, theta, devInfo.sharedMemPerBlock(), devInfo.supports(FEATURE_SET_COMPUTE_20)); ensureSizeIsEnough(1, maxLines, CV_32SC4, lines); diff --git a/modules/gpu/src/imgproc.cpp b/modules/gpu/src/imgproc.cpp index 3e992b59c9..24f015ba7c 100644 --- a/modules/gpu/src/imgproc.cpp +++ b/modules/gpu/src/imgproc.cpp @@ -91,7 +91,6 @@ void cv::gpu::Canny(const GpuMat&, GpuMat&, double, double, int, bool) { throw_n void cv::gpu::Canny(const GpuMat&, CannyBuf&, GpuMat&, double, double, int, bool) { throw_nogpu(); } void cv::gpu::Canny(const GpuMat&, const GpuMat&, GpuMat&, double, double, bool) { throw_nogpu(); } void cv::gpu::Canny(const GpuMat&, const GpuMat&, CannyBuf&, GpuMat&, double, double, bool) { throw_nogpu(); } -cv::gpu::CannyBuf::CannyBuf(const GpuMat&, const GpuMat&) { throw_nogpu(); } void cv::gpu::CannyBuf::create(const Size&, int) { throw_nogpu(); } void cv::gpu::CannyBuf::release() { throw_nogpu(); } @@ -1429,12 +1428,6 @@ void cv::gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, ////////////////////////////////////////////////////////////////////////////// // Canny -cv::gpu::CannyBuf::CannyBuf(const GpuMat& dx_, const GpuMat& dy_) -{ - (void) dx_; - (void) dy_; -} - void cv::gpu::CannyBuf::create(const Size& image_size, int apperture_size) { if (apperture_size > 0) @@ -1449,22 +1442,21 @@ void cv::gpu::CannyBuf::create(const Size& image_size, int apperture_size) } } - ensureSizeIsEnough(image_size, CV_32FC1, edgeBuf); - ensureSizeIsEnough(image_size, CV_32SC1, dx_buf); + ensureSizeIsEnough(image_size, CV_32FC1, mag); + ensureSizeIsEnough(image_size, CV_32SC1, map); - ensureSizeIsEnough(1, image_size.area(), CV_16UC2, trackBuf1); - ensureSizeIsEnough(1, image_size.area(), CV_16UC2, trackBuf2); + ensureSizeIsEnough(1, image_size.area(), CV_16UC2, st1); + ensureSizeIsEnough(1, image_size.area(), CV_16UC2, st2); } void cv::gpu::CannyBuf::release() { dx.release(); dy.release(); - dx_buf.release(); - dy_buf.release(); - edgeBuf.release(); - trackBuf1.release(); - trackBuf2.release(); + mag.release(); + map.release(); + st1.release(); + st2.release(); } namespace canny @@ -1487,13 +1479,14 @@ namespace { using namespace canny; - calcMap(dx, dy, buf.edgeBuf, buf.dx_buf, low_thresh, high_thresh); + buf.map.setTo(Scalar::all(0)); + calcMap(dx, dy, buf.mag, buf.map, low_thresh, high_thresh); - edgesHysteresisLocal(buf.dx_buf, buf.trackBuf1.ptr()); + edgesHysteresisLocal(buf.map, buf.st1.ptr()); - edgesHysteresisGlobal(buf.dx_buf, buf.trackBuf1.ptr(), buf.trackBuf2.ptr()); + edgesHysteresisGlobal(buf.map, buf.st1.ptr(), buf.st2.ptr()); - getEdges(buf.dx_buf, dst); + getEdges(buf.map, dst); } } @@ -1525,14 +1518,14 @@ void cv::gpu::Canny(const GpuMat& src, CannyBuf& buf, GpuMat& dst, double low_th src.locateROI(wholeSize, ofs); GpuMat srcWhole(wholeSize, src.type(), src.datastart, src.step); - calcMagnitude(srcWhole, ofs.x, ofs.y, buf.dx, buf.dy, buf.edgeBuf, L2gradient); + calcMagnitude(srcWhole, ofs.x, ofs.y, buf.dx, buf.dy, buf.mag, L2gradient); } else { buf.filterDX->apply(src, buf.dx, Rect(0, 0, src.cols, src.rows)); buf.filterDY->apply(src, buf.dy, Rect(0, 0, src.cols, src.rows)); - calcMagnitude(buf.dx, buf.dy, buf.edgeBuf, L2gradient); + calcMagnitude(buf.dx, buf.dy, buf.mag, L2gradient); } CannyCaller(buf.dx, buf.dy, buf, dst, static_cast(low_thresh), static_cast(high_thresh)); @@ -1557,7 +1550,7 @@ void cv::gpu::Canny(const GpuMat& dx, const GpuMat& dy, CannyBuf& buf, GpuMat& d dst.create(dx.size(), CV_8U); buf.create(dx.size(), -1); - calcMagnitude(dx, dy, buf.edgeBuf, L2gradient); + calcMagnitude(dx, dy, buf.mag, L2gradient); CannyCaller(dx, dy, buf, dst, static_cast(low_thresh), static_cast(high_thresh)); } diff --git a/modules/gpu/src/pyrlk.cpp b/modules/gpu/src/pyrlk.cpp index d94341deea..49a6c5a88c 100644 --- a/modules/gpu/src/pyrlk.cpp +++ b/modules/gpu/src/pyrlk.cpp @@ -48,8 +48,10 @@ using namespace cv::gpu; #if !defined (HAVE_CUDA) || defined (CUDA_DISABLER) +cv::gpu::PyrLKOpticalFlow::PyrLKOpticalFlow() { throw_nogpu(); } void cv::gpu::PyrLKOpticalFlow::sparse(const GpuMat&, const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, GpuMat*) { throw_nogpu(); } void cv::gpu::PyrLKOpticalFlow::dense(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, GpuMat*) { throw_nogpu(); } +void cv::gpu::PyrLKOpticalFlow::releaseMemory() {} #else /* !defined (HAVE_CUDA) */ @@ -66,6 +68,14 @@ namespace pyrlk PtrStepSzf err, int2 winSize, cudaStream_t stream = 0); } +cv::gpu::PyrLKOpticalFlow::PyrLKOpticalFlow() +{ + winSize = Size(21, 21); + maxLevel = 3; + iters = 30; + useInitialFlow = false; +} + namespace { void calcPatchSize(cv::Size winSize, dim3& block, dim3& patch) @@ -137,11 +147,11 @@ void cv::gpu::PyrLKOpticalFlow::sparse(const GpuMat& prevImg, const GpuMat& next } else { - cvtColor(prevImg, dx_calcBuf_, COLOR_BGR2BGRA); - dx_calcBuf_.convertTo(prevPyr_[0], CV_32F); + cvtColor(prevImg, buf_, COLOR_BGR2BGRA); + buf_.convertTo(prevPyr_[0], CV_32F); - cvtColor(nextImg, dx_calcBuf_, COLOR_BGR2BGRA); - dx_calcBuf_.convertTo(nextPyr_[0], CV_32F); + cvtColor(nextImg, buf_, COLOR_BGR2BGRA); + buf_.convertTo(nextPyr_[0], CV_32F); } for (int level = 1; level <= maxLevel; ++level) @@ -193,9 +203,6 @@ void cv::gpu::PyrLKOpticalFlow::dense(const GpuMat& prevImg, const GpuMat& nextI pyrDown(nextPyr_[level - 1], nextPyr_[level]); } - uPyr_.resize(2); - vPyr_.resize(2); - ensureSizeIsEnough(prevImg.size(), CV_32FC1, uPyr_[0]); ensureSizeIsEnough(prevImg.size(), CV_32FC1, vPyr_[0]); ensureSizeIsEnough(prevImg.size(), CV_32FC1, uPyr_[1]); @@ -225,4 +232,18 @@ void cv::gpu::PyrLKOpticalFlow::dense(const GpuMat& prevImg, const GpuMat& nextI vPyr_[idx].copyTo(v); } +void cv::gpu::PyrLKOpticalFlow::releaseMemory() +{ + prevPyr_.clear(); + nextPyr_.clear(); + + buf_.release(); + + uPyr_[0].release(); + vPyr_[0].release(); + + uPyr_[1].release(); + vPyr_[1].release(); +} + #endif /* !defined (HAVE_CUDA) */ diff --git a/modules/gpu/test/test_features2d.cpp b/modules/gpu/test/test_features2d.cpp index 1fa4fe7255..3879ac0534 100644 --- a/modules/gpu/test/test_features2d.cpp +++ b/modules/gpu/test/test_features2d.cpp @@ -583,8 +583,7 @@ PARAM_TEST_CASE(BruteForceMatcher, cv::gpu::DeviceInfo, NormCode, DescriptorSize GPU_TEST_P(BruteForceMatcher, Match_Single) { - cv::gpu::BruteForceMatcher_GPU_base matcher( - cv::gpu::BruteForceMatcher_GPU_base::DistType((normCode -2) / 2)); + cv::gpu::BFMatcher_GPU matcher(normCode); cv::gpu::GpuMat mask; if (useMask) @@ -611,8 +610,7 @@ GPU_TEST_P(BruteForceMatcher, Match_Single) GPU_TEST_P(BruteForceMatcher, Match_Collection) { - cv::gpu::BruteForceMatcher_GPU_base matcher( - cv::gpu::BruteForceMatcher_GPU_base::DistType((normCode -2) / 2)); + cv::gpu::BFMatcher_GPU matcher(normCode); cv::gpu::GpuMat d_train(train); @@ -666,8 +664,7 @@ GPU_TEST_P(BruteForceMatcher, Match_Collection) GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Single) { - cv::gpu::BruteForceMatcher_GPU_base matcher( - cv::gpu::BruteForceMatcher_GPU_base::DistType((normCode -2) / 2)); + cv::gpu::BFMatcher_GPU matcher(normCode); const int knn = 2; @@ -706,8 +703,7 @@ GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Single) GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Single) { - cv::gpu::BruteForceMatcher_GPU_base matcher( - cv::gpu::BruteForceMatcher_GPU_base::DistType((normCode -2) / 2)); + cv::gpu::BFMatcher_GPU matcher(normCode); const int knn = 3; @@ -746,8 +742,7 @@ GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Single) GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Collection) { - cv::gpu::BruteForceMatcher_GPU_base matcher( - cv::gpu::BruteForceMatcher_GPU_base::DistType((normCode -2) / 2)); + cv::gpu::BFMatcher_GPU matcher(normCode); const int knn = 2; @@ -809,8 +804,7 @@ GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Collection) GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Collection) { - cv::gpu::BruteForceMatcher_GPU_base matcher( - cv::gpu::BruteForceMatcher_GPU_base::DistType((normCode -2) / 2)); + cv::gpu::BFMatcher_GPU matcher(normCode); const int knn = 3; @@ -872,8 +866,7 @@ GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Collection) GPU_TEST_P(BruteForceMatcher, RadiusMatch_Single) { - cv::gpu::BruteForceMatcher_GPU_base matcher( - cv::gpu::BruteForceMatcher_GPU_base::DistType((normCode -2) / 2)); + cv::gpu::BFMatcher_GPU matcher(normCode); const float radius = 1.f / countFactor; @@ -922,8 +915,7 @@ GPU_TEST_P(BruteForceMatcher, RadiusMatch_Single) GPU_TEST_P(BruteForceMatcher, RadiusMatch_Collection) { - cv::gpu::BruteForceMatcher_GPU_base matcher( - cv::gpu::BruteForceMatcher_GPU_base::DistType((normCode -2) / 2)); + cv::gpu::BFMatcher_GPU matcher(normCode); const int n = 3; const float radius = 1.f / countFactor * n; diff --git a/modules/gpu/test/test_gpumat.cpp b/modules/gpu/test/test_gpumat.cpp index fc57512e94..9ece87caa3 100644 --- a/modules/gpu/test/test_gpumat.cpp +++ b/modules/gpu/test/test_gpumat.cpp @@ -322,4 +322,38 @@ INSTANTIATE_TEST_CASE_P(GPU_GpuMat, ConvertTo, testing::Combine( ALL_DEPTH, WHOLE_SUBMAT)); +//////////////////////////////////////////////////////////////////////////////// +// ensureSizeIsEnough + +struct EnsureSizeIsEnough : testing::TestWithParam +{ + virtual void SetUp() + { + cv::gpu::DeviceInfo devInfo = GetParam(); + cv::gpu::setDevice(devInfo.deviceID()); + } +}; + +GPU_TEST_P(EnsureSizeIsEnough, BufferReuse) +{ + cv::gpu::GpuMat buffer(100, 100, CV_8U); + cv::gpu::GpuMat old = buffer; + + // don't reallocate memory + cv::gpu::ensureSizeIsEnough(10, 20, CV_8U, buffer); + EXPECT_EQ(10, buffer.rows); + EXPECT_EQ(20, buffer.cols); + EXPECT_EQ(CV_8UC1, buffer.type()); + EXPECT_EQ(reinterpret_cast(old.data), reinterpret_cast(buffer.data)); + + // don't reallocate memory + cv::gpu::ensureSizeIsEnough(20, 30, CV_8U, buffer); + EXPECT_EQ(20, buffer.rows); + EXPECT_EQ(30, buffer.cols); + EXPECT_EQ(CV_8UC1, buffer.type()); + EXPECT_EQ(reinterpret_cast(old.data), reinterpret_cast(buffer.data)); +} + +INSTANTIATE_TEST_CASE_P(GPU_GpuMat, EnsureSizeIsEnough, ALL_DEVICES); + #endif // HAVE_CUDA diff --git a/modules/stitching/src/matchers.cpp b/modules/stitching/src/matchers.cpp index 9abfd6b9d3..dc6b5fa4db 100644 --- a/modules/stitching/src/matchers.cpp +++ b/modules/stitching/src/matchers.cpp @@ -219,7 +219,7 @@ void GpuMatcher::match(const ImageFeatures &features1, const ImageFeatures &feat descriptors1_.upload(features1.descriptors); descriptors2_.upload(features2.descriptors); - BruteForceMatcher_GPU_base matcher(BruteForceMatcher_GPU_base::L2Dist); + BFMatcher_GPU matcher(NORM_L2); MatchesSet matches; // Find 1->2 matches diff --git a/samples/gpu/morfology.cpp b/samples/gpu/morphology.cpp similarity index 100% rename from samples/gpu/morfology.cpp rename to samples/gpu/morphology.cpp diff --git a/samples/gpu/performance/tests.cpp b/samples/gpu/performance/tests.cpp index bc46353e8e..b35102d861 100644 --- a/samples/gpu/performance/tests.cpp +++ b/samples/gpu/performance/tests.cpp @@ -364,7 +364,7 @@ TEST(BruteForceMatcher) // Init GPU matcher - gpu::BruteForceMatcher_GPU_base d_matcher(gpu::BruteForceMatcher_GPU_base::L2Dist); + gpu::BFMatcher_GPU d_matcher(NORM_L2); gpu::GpuMat d_query(query); gpu::GpuMat d_train(train); diff --git a/samples/gpu/surf_keypoint_matcher.cpp b/samples/gpu/surf_keypoint_matcher.cpp index 76a3e6d377..617cda52bd 100644 --- a/samples/gpu/surf_keypoint_matcher.cpp +++ b/samples/gpu/surf_keypoint_matcher.cpp @@ -57,7 +57,7 @@ int main(int argc, char* argv[]) cout << "FOUND " << keypoints2GPU.cols << " keypoints on second image" << endl; // matching descriptors - gpu::BruteForceMatcher_GPU_base matcher(gpu::BruteForceMatcher_GPU_base::L2Dist); + BFMatcher_GPU matcher(NORM_L2); GpuMat trainIdx, distance; matcher.matchSingle(descriptors1GPU, descriptors2GPU, trainIdx, distance); @@ -69,7 +69,7 @@ int main(int argc, char* argv[]) surf.downloadKeypoints(keypoints2GPU, keypoints2); surf.downloadDescriptors(descriptors1GPU, descriptors1); surf.downloadDescriptors(descriptors2GPU, descriptors2); - BruteForceMatcher_GPU_base::matchDownload(trainIdx, distance, matches); + BFMatcher_GPU::matchDownload(trainIdx, distance, matches); // drawing the results Mat img_matches; From 73ffd71a22ed49f7d522a234d21264e45878c04f Mon Sep 17 00:00:00 2001 From: Vladislav Vinogradov Date: Thu, 21 Feb 2013 17:06:53 +0400 Subject: [PATCH 14/24] Fixed documentation build --- .../doc/feature_detection_and_description.rst | 121 +++++++++--------- 1 file changed, 60 insertions(+), 61 deletions(-) diff --git a/modules/gpu/doc/feature_detection_and_description.rst b/modules/gpu/doc/feature_detection_and_description.rst index 4129ba8f09..ec75248040 100644 --- a/modules/gpu/doc/feature_detection_and_description.rst +++ b/modules/gpu/doc/feature_detection_and_description.rst @@ -370,16 +370,16 @@ Releases inner buffer memory. -gpu::BFMatcher_GPU --------------------------- -.. ocv:class:: gpu::BFMatcher_GPU +gpu::BruteForceMatcher_GPU_base +------------------------------- +.. ocv:class:: gpu::BruteForceMatcher_GPU_base Brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest descriptor in the second set by trying each one. This descriptor matcher supports masking permissible matches between descriptor sets. :: - class BFMatcher_GPU + class BruteForceMatcher_GPU_base { public: - explicit BFMatcher_GPU(int norm = cv::NORM_L2); + explicit BruteForceMatcher_GPU_base(int norm = cv::NORM_L2); // Add descriptors to train descriptor collection. void add(const std::vector& descCollection); @@ -478,67 +478,67 @@ Brute-force descriptor matcher. For each descriptor in the first set, this match }; -The class ``BFMatcher_GPU`` has an interface similar to the class :ocv:class:`DescriptorMatcher`. It has two groups of ``match`` methods: for matching descriptors of one image with another image or with an image set. Also, all functions have an alternative to save results either to the GPU memory or to the CPU memory. +The class ``BruteForceMatcher_GPU_base`` has an interface similar to the class :ocv:class:`DescriptorMatcher`. It has two groups of ``match`` methods: for matching descriptors of one image with another image or with an image set. Also, all functions have an alternative to save results either to the GPU memory or to the CPU memory. .. seealso:: :ocv:class:`DescriptorMatcher`, :ocv:class:`BFMatcher` -gpu::BFMatcher_GPU::match -------------------------------------- +gpu::BruteForceMatcher_GPU_base::match +-------------------------------------- Finds the best match for each descriptor from a query set with train descriptors. -.. ocv:function:: void gpu::BFMatcher_GPU::match(const GpuMat& query, const GpuMat& train, std::vector& matches, const GpuMat& mask = GpuMat()) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::match(const GpuMat& query, const GpuMat& train, std::vector& matches, const GpuMat& mask = GpuMat()) -.. ocv:function:: void gpu::BFMatcher_GPU::matchSingle(const GpuMat& query, const GpuMat& train, GpuMat& trainIdx, GpuMat& distance, const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null()) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::matchSingle(const GpuMat& query, const GpuMat& train, GpuMat& trainIdx, GpuMat& distance, const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null()) -.. ocv:function:: void gpu::BFMatcher_GPU::match(const GpuMat& query, std::vector& matches, const std::vector& masks = std::vector()) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::match(const GpuMat& query, std::vector& matches, const std::vector& masks = std::vector()) -.. ocv:function:: void gpu::BFMatcher_GPU::matchCollection( const GpuMat& query, const GpuMat& trainCollection, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, const GpuMat& masks=GpuMat(), Stream& stream=Stream::Null() ) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::matchCollection( const GpuMat& query, const GpuMat& trainCollection, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, const GpuMat& masks=GpuMat(), Stream& stream=Stream::Null() ) .. seealso:: :ocv:func:`DescriptorMatcher::match` -gpu::BFMatcher_GPU::makeGpuCollection -------------------------------------------------- -Performs a GPU collection of train descriptors and masks in a suitable format for the :ocv:func:`gpu::BFMatcher_GPU::matchCollection` function. +gpu::BruteForceMatcher_GPU_base::makeGpuCollection +-------------------------------------------------- +Performs a GPU collection of train descriptors and masks in a suitable format for the :ocv:func:`gpu::BruteForceMatcher_GPU_base::matchCollection` function. -.. ocv:function:: void gpu::BFMatcher_GPU::makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection, const vector& masks = std::vector()) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection, const vector& masks = std::vector()) -gpu::BFMatcher_GPU::matchDownload +gpu::BruteForceMatcher_GPU_base::matchDownload +---------------------------------------------- +Downloads matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU_base::matchSingle` or :ocv:func:`gpu::BruteForceMatcher_GPU_base::matchCollection` to vector with :ocv:class:`DMatch`. + +.. ocv:function:: static void gpu::BruteForceMatcher_GPU_base::matchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector&matches) + +.. ocv:function:: static void gpu::BruteForceMatcher_GPU_base::matchDownload( const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, std::vector& matches ) + + + +gpu::BruteForceMatcher_GPU_base::matchConvert --------------------------------------------- -Downloads matrices obtained via :ocv:func:`gpu::BFMatcher_GPU::matchSingle` or :ocv:func:`gpu::BFMatcher_GPU::matchCollection` to vector with :ocv:class:`DMatch`. +Converts matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU_base::matchSingle` or :ocv:func:`gpu::BruteForceMatcher_GPU_base::matchCollection` to vector with :ocv:class:`DMatch`. -.. ocv:function:: static void gpu::BFMatcher_GPU::matchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector&matches) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::matchConvert(const Mat& trainIdx, const Mat& distance, std::vector&matches) -.. ocv:function:: static void gpu::BFMatcher_GPU::matchDownload( const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, std::vector& matches ) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::matchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector&matches) -gpu::BFMatcher_GPU::matchConvert ---------------------------------------------- -Converts matrices obtained via :ocv:func:`gpu::BFMatcher_GPU::matchSingle` or :ocv:func:`gpu::BFMatcher_GPU::matchCollection` to vector with :ocv:class:`DMatch`. - -.. ocv:function:: void gpu::BFMatcher_GPU::matchConvert(const Mat& trainIdx, const Mat& distance, std::vector&matches) - -.. ocv:function:: void gpu::BFMatcher_GPU::matchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector&matches) - - - -gpu::BFMatcher_GPU::knnMatch ----------------------------------------- +gpu::BruteForceMatcher_GPU_base::knnMatch +----------------------------------------- Finds the ``k`` best matches for each descriptor from a query set with train descriptors. -.. ocv:function:: void gpu::BFMatcher_GPU::knnMatch(const GpuMat& query, const GpuMat& train, std::vector< std::vector >&matches, int k, const GpuMat& mask = GpuMat(), bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatch(const GpuMat& query, const GpuMat& train, std::vector< std::vector >&matches, int k, const GpuMat& mask = GpuMat(), bool compactResult = false) -.. ocv:function:: void gpu::BFMatcher_GPU::knnMatchSingle(const GpuMat& query, const GpuMat& train, GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k, const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null()) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatchSingle(const GpuMat& query, const GpuMat& train, GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k, const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null()) -.. ocv:function:: void gpu::BFMatcher_GPU::knnMatch(const GpuMat& query, std::vector< std::vector >&matches, int k, const std::vector&masks = std::vector(), bool compactResult = false ) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatch(const GpuMat& query, std::vector< std::vector >&matches, int k, const std::vector&masks = std::vector(), bool compactResult = false ) -.. ocv:function:: void gpu::BFMatcher_GPU::knnMatch2Collection(const GpuMat& query, const GpuMat& trainCollection, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, const GpuMat& maskCollection = GpuMat(), Stream& stream = Stream::Null()) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatch2Collection(const GpuMat& query, const GpuMat& trainCollection, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, const GpuMat& maskCollection = GpuMat(), Stream& stream = Stream::Null()) :param query: Query set of descriptors. @@ -560,41 +560,41 @@ The third variant of the method stores the results in GPU memory. -gpu::BFMatcher_GPU::knnMatchDownload ------------------------------------------------- -Downloads matrices obtained via :ocv:func:`gpu::BFMatcher_GPU::knnMatchSingle` or :ocv:func:`gpu::BFMatcher_GPU::knnMatch2Collection` to vector with :ocv:class:`DMatch`. +gpu::BruteForceMatcher_GPU_base::knnMatchDownload +------------------------------------------------- +Downloads matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU_base::knnMatchSingle` or :ocv:func:`gpu::BruteForceMatcher_GPU_base::knnMatch2Collection` to vector with :ocv:class:`DMatch`. -.. ocv:function:: void gpu::BFMatcher_GPU::knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector< std::vector >&matches, bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector< std::vector >&matches, bool compactResult = false) -.. ocv:function:: void gpu::BFMatcher_GPU::knnMatch2Download(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, std::vector< std::vector >& matches, bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatch2Download(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, std::vector< std::vector >& matches, bool compactResult = false) If ``compactResult`` is ``true`` , the ``matches`` vector does not contain matches for fully masked-out query descriptors. -gpu::BFMatcher_GPU::knnMatchConvert +gpu::BruteForceMatcher_GPU_base::knnMatchConvert ------------------------------------------------ -Converts matrices obtained via :ocv:func:`gpu::BFMatcher_GPU::knnMatchSingle` or :ocv:func:`gpu::BFMatcher_GPU::knnMatch2Collection` to CPU vector with :ocv:class:`DMatch`. +Converts matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU_base::knnMatchSingle` or :ocv:func:`gpu::BruteForceMatcher_GPU_base::knnMatch2Collection` to CPU vector with :ocv:class:`DMatch`. -.. ocv:function:: void gpu::BFMatcher_GPU::knnMatchConvert(const Mat& trainIdx, const Mat& distance, std::vector< std::vector >&matches, bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatchConvert(const Mat& trainIdx, const Mat& distance, std::vector< std::vector >&matches, bool compactResult = false) -.. ocv:function:: void gpu::BFMatcher_GPU::knnMatch2Convert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector< std::vector >& matches, bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::knnMatch2Convert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector< std::vector >& matches, bool compactResult = false) If ``compactResult`` is ``true`` , the ``matches`` vector does not contain matches for fully masked-out query descriptors. -gpu::BFMatcher_GPU::radiusMatch -------------------------------------------- +gpu::BruteForceMatcher_GPU_base::radiusMatch +-------------------------------------------- For each query descriptor, finds the best matches with a distance less than a given threshold. -.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatch(const GpuMat& query, const GpuMat& train, std::vector< std::vector >&matches, float maxDistance, const GpuMat& mask = GpuMat(), bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatch(const GpuMat& query, const GpuMat& train, std::vector< std::vector >&matches, float maxDistance, const GpuMat& mask = GpuMat(), bool compactResult = false) -.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatchSingle(const GpuMat& query, const GpuMat& train, GpuMat& trainIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance, const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null()) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatchSingle(const GpuMat& query, const GpuMat& train, GpuMat& trainIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance, const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null()) -.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatch(const GpuMat& query, std::vector< std::vector >&matches, float maxDistance, const std::vector& masks = std::vector(), bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatch(const GpuMat& query, std::vector< std::vector >&matches, float maxDistance, const std::vector& masks = std::vector(), bool compactResult = false) -.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatchCollection(const GpuMat& query, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance, const std::vector& masks = std::vector(), Stream& stream = Stream::Null()) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatchCollection(const GpuMat& query, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance, const std::vector& masks = std::vector(), Stream& stream = Stream::Null()) :param query: Query set of descriptors. @@ -618,26 +618,25 @@ The third variant of the method stores the results in GPU memory and does not st -gpu::BFMatcher_GPU::radiusMatchDownload ---------------------------------------------------- -Downloads matrices obtained via :ocv:func:`gpu::BFMatcher_GPU::radiusMatchSingle` or :ocv:func:`gpu::BFMatcher_GPU::radiusMatchCollection` to vector with :ocv:class:`DMatch`. +gpu::BruteForceMatcher_GPU_base::radiusMatchDownload +---------------------------------------------------- +Downloads matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU_base::radiusMatchSingle` or :ocv:func:`gpu::BruteForceMatcher_GPU_base::radiusMatchCollection` to vector with :ocv:class:`DMatch`. -.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, const GpuMat& nMatches, std::vector< std::vector >&matches, bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, const GpuMat& nMatches, std::vector< std::vector >&matches, bool compactResult = false) -.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, const GpuMat& nMatches, std::vector< std::vector >& matches, bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, const GpuMat& nMatches, std::vector< std::vector >& matches, bool compactResult = false) If ``compactResult`` is ``true`` , the ``matches`` vector does not contain matches for fully masked-out query descriptors. -gpu::BFMatcher_GPU::radiusMatchConvert +gpu::BruteForceMatcher_GPU_base::radiusMatchConvert --------------------------------------------------- -Converts matrices obtained via :ocv:func:`gpu::BFMatcher_GPU::radiusMatchSingle` or :ocv:func:`gpu::BFMatcher_GPU::radiusMatchCollection` to vector with :ocv:class:`DMatch`. +Converts matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU_base::radiusMatchSingle` or :ocv:func:`gpu::BruteForceMatcher_GPU_base::radiusMatchCollection` to vector with :ocv:class:`DMatch`. -.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatchConvert(const Mat& trainIdx, const Mat& distance, const Mat& nMatches, std::vector< std::vector >&matches, bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatchConvert(const Mat& trainIdx, const Mat& distance, const Mat& nMatches, std::vector< std::vector >&matches, bool compactResult = false) -.. ocv:function:: void gpu::BFMatcher_GPU::radiusMatchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, const Mat& nMatches, std::vector< std::vector >& matches, bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU_base::radiusMatchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, const Mat& nMatches, std::vector< std::vector >& matches, bool compactResult = false) If ``compactResult`` is ``true`` , the ``matches`` vector does not contain matches for fully masked-out query descriptors. - From e3803f9985af65978ab044e06cd2fd571ac23723 Mon Sep 17 00:00:00 2001 From: gferry Date: Wed, 20 Feb 2013 14:19:55 +0100 Subject: [PATCH 15/24] fix for OpenCV issue #2815 - libavcodec issue - some decoders alter AVCodecContext width/height values, in a wrong way - eg. in issue 2815, vp6f decoder changes these values, resulting in distorted / invalid frames - this patch forces default AVCodecContext values --- modules/highgui/src/cap_ffmpeg_impl.hpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/modules/highgui/src/cap_ffmpeg_impl.hpp b/modules/highgui/src/cap_ffmpeg_impl.hpp index 0c9c950f02..e590cd2784 100644 --- a/modules/highgui/src/cap_ffmpeg_impl.hpp +++ b/modules/highgui/src/cap_ffmpeg_impl.hpp @@ -560,6 +560,10 @@ bool CvCapture_FFMPEG::open( const char* _filename ) if( AVMEDIA_TYPE_VIDEO == enc->codec_type && video_stream < 0) { + // backup encoder' width/height + int enc_width = enc->width; + int enc_height = enc->height; + AVCodec *codec = avcodec_find_decoder(enc->codec_id); if (!codec || #if LIBAVCODEC_VERSION_INT >= ((53<<16)+(8<<8)+0) @@ -570,6 +574,10 @@ bool CvCapture_FFMPEG::open( const char* _filename ) < 0) goto exit_func; + // checking width/height (since decoder can sometimes alter it, eg. vp6f) + if (enc_width && (enc->width != enc_width)) { enc->width = enc_width; } + if (enc_height && (enc->height != enc_height)) { enc->height = enc_height; } + video_stream = i; video_st = ic->streams[i]; picture = avcodec_alloc_frame(); From 995154d10d0fb6260f515f063029790a5f18191e Mon Sep 17 00:00:00 2001 From: Andrey Kamaev Date: Fri, 22 Feb 2013 00:14:58 +0400 Subject: [PATCH 16/24] Fix binary compatibility of gpu module --- modules/gpu/include/opencv2/gpu/gpu.hpp | 12 +++++++----- modules/gpu/src/imgproc.cpp | 3 +++ modules/gpu/src/pyrlk.cpp | 12 +++++++----- 3 files changed, 17 insertions(+), 10 deletions(-) diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp index afbe067a3e..a9481b2812 100644 --- a/modules/gpu/include/opencv2/gpu/gpu.hpp +++ b/modules/gpu/include/opencv2/gpu/gpu.hpp @@ -815,6 +815,10 @@ struct CV_EXPORTS CannyBuf GpuMat st1, st2; GpuMat unused; Ptr filterDX, filterDY; + + CannyBuf() {} + explicit CannyBuf(const Size& image_size, int apperture_size = 3) {create(image_size, apperture_size);} + CannyBuf(const GpuMat& dx_, const GpuMat& dy_); }; CV_EXPORTS void Canny(const GpuMat& image, GpuMat& edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false); @@ -1879,11 +1883,9 @@ private: vector prevPyr_; vector nextPyr_; GpuMat vPyr_[2]; - vector unused1; - vector unused2; - bool unused3; - - GpuMat buf_; + vector buf_; + vector unused; + bool isDeviceArch11_; }; diff --git a/modules/gpu/src/imgproc.cpp b/modules/gpu/src/imgproc.cpp index 24f015ba7c..3184717185 100644 --- a/modules/gpu/src/imgproc.cpp +++ b/modules/gpu/src/imgproc.cpp @@ -45,6 +45,9 @@ using namespace cv; using namespace cv::gpu; +/*stub for deprecated constructor*/ +cv::gpu::CannyBuf::CannyBuf(const GpuMat&, const GpuMat&) { } + #if !defined (HAVE_CUDA) || defined (CUDA_DISABLER) void cv::gpu::meanShiftFiltering(const GpuMat&, GpuMat&, int, int, TermCriteria, Stream&) { throw_nogpu(); } diff --git a/modules/gpu/src/pyrlk.cpp b/modules/gpu/src/pyrlk.cpp index 49a6c5a88c..148bcb5dd9 100644 --- a/modules/gpu/src/pyrlk.cpp +++ b/modules/gpu/src/pyrlk.cpp @@ -147,11 +147,13 @@ void cv::gpu::PyrLKOpticalFlow::sparse(const GpuMat& prevImg, const GpuMat& next } else { - cvtColor(prevImg, buf_, COLOR_BGR2BGRA); - buf_.convertTo(prevPyr_[0], CV_32F); + buf_.resize(1); - cvtColor(nextImg, buf_, COLOR_BGR2BGRA); - buf_.convertTo(nextPyr_[0], CV_32F); + cvtColor(prevImg, buf_[0], COLOR_BGR2BGRA); + buf_[0].convertTo(prevPyr_[0], CV_32F); + + cvtColor(nextImg, buf_[0], COLOR_BGR2BGRA); + buf_[0].convertTo(nextPyr_[0], CV_32F); } for (int level = 1; level <= maxLevel; ++level) @@ -237,7 +239,7 @@ void cv::gpu::PyrLKOpticalFlow::releaseMemory() prevPyr_.clear(); nextPyr_.clear(); - buf_.release(); + buf_.clear(); uPyr_[0].release(); vPyr_[0].release(); From c17e9ef7ba6b128c5bdfd3657cc018eee2391c9b Mon Sep 17 00:00:00 2001 From: Andrey Kamaev Date: Fri, 22 Feb 2013 00:30:27 +0400 Subject: [PATCH 17/24] Repair binary compatibility of ocl module --- modules/ocl/include/opencv2/ocl/ocl.hpp | 31 +++++++++++++------------ modules/ocl/src/arithm.cpp | 8 +++---- 2 files changed, 20 insertions(+), 19 deletions(-) diff --git a/modules/ocl/include/opencv2/ocl/ocl.hpp b/modules/ocl/include/opencv2/ocl/ocl.hpp index fcaff4e549..a60eb36302 100644 --- a/modules/ocl/include/opencv2/ocl/ocl.hpp +++ b/modules/ocl/include/opencv2/ocl/ocl.hpp @@ -102,7 +102,7 @@ namespace cv //this function enable ocl module to use customized cl_context and cl_command_queue //getDevice also need to be called before this function - CV_EXPORTS void setDeviceEx(Info &oclinfo, void *ctx, void *qu, int devnum = 0); + CV_EXPORTS void setDeviceEx(Info &oclinfo, void *ctx, void *qu, int devnum = 0); //////////////////////////////// Error handling //////////////////////// CV_EXPORTS void error(const char *error_string, const char *file, const int line, const char *func); @@ -126,21 +126,21 @@ namespace cv }; //! Calls a kernel, by string. Pass globalThreads = NULL, and cleanUp = true, to finally clean-up without executing. - CV_EXPORTS double openCLExecuteKernelInterop(Context *clCxt , + CV_EXPORTS double openCLExecuteKernelInterop(Context *clCxt , const char **source, string kernelName, size_t globalThreads[3], size_t localThreads[3], - std::vector< std::pair > &args, - int channels, int depth, const char *build_options, - bool finish = true, bool measureKernelTime = false, + std::vector< std::pair > &args, + int channels, int depth, const char *build_options, + bool finish = true, bool measureKernelTime = false, bool cleanUp = true); //! Calls a kernel, by file. Pass globalThreads = NULL, and cleanUp = true, to finally clean-up without executing. - CV_EXPORTS double openCLExecuteKernelInterop(Context *clCxt , + CV_EXPORTS double openCLExecuteKernelInterop(Context *clCxt , const char **fileName, const int numFiles, string kernelName, size_t globalThreads[3], size_t localThreads[3], - std::vector< std::pair > &args, - int channels, int depth, const char *build_options, - bool finish = true, bool measureKernelTime = false, + std::vector< std::pair > &args, + int channels, int depth, const char *build_options, + bool finish = true, bool measureKernelTime = false, bool cleanUp = true); class CV_EXPORTS oclMatExpr; @@ -487,21 +487,22 @@ namespace cv CV_EXPORTS void bitwise_xor(const oclMat &src1, const Scalar &s, oclMat &dst, const oclMat &mask = oclMat()); //! Logical operators - CV_EXPORTS oclMatExpr operator ~ (const oclMat &src); - CV_EXPORTS oclMatExpr operator | (const oclMat &src1, const oclMat &src2); - CV_EXPORTS oclMatExpr operator & (const oclMat &src1, const oclMat &src2); - CV_EXPORTS oclMatExpr operator ^ (const oclMat &src1, const oclMat &src2); + CV_EXPORTS oclMat operator ~ (const oclMat &); + CV_EXPORTS oclMat operator | (const oclMat &, const oclMat &); + CV_EXPORTS oclMat operator & (const oclMat &, const oclMat &); + CV_EXPORTS oclMat operator ^ (const oclMat &, const oclMat &); + //! Mathematics operators CV_EXPORTS oclMatExpr operator + (const oclMat &src1, const oclMat &src2); CV_EXPORTS oclMatExpr operator - (const oclMat &src1, const oclMat &src2); CV_EXPORTS oclMatExpr operator * (const oclMat &src1, const oclMat &src2); CV_EXPORTS oclMatExpr operator / (const oclMat &src1, const oclMat &src2); - + //! computes convolution of two images //! support only CV_32FC1 type CV_EXPORTS void convolve(const oclMat &image, const oclMat &temp1, oclMat &result); - + CV_EXPORTS void cvtColor(const oclMat &src, oclMat &dst, int code , int dcn = 0); //////////////////////////////// Filter Engine //////////////////////////////// diff --git a/modules/ocl/src/arithm.cpp b/modules/ocl/src/arithm.cpp index 099d07980d..c4eb0041d9 100644 --- a/modules/ocl/src/arithm.cpp +++ b/modules/ocl/src/arithm.cpp @@ -2125,22 +2125,22 @@ void cv::ocl::bitwise_xor(const oclMat &src1, const Scalar &src2, oclMat &dst, c bitwise_scalar( src1, src2, dst, mask, kernelName, &arithm_bitwise_xor_scalar); } -oclMatExpr cv::ocl::operator ~ (const oclMat &src) +oclMat cv::ocl::operator ~ (const oclMat &src) { return oclMatExpr(src, oclMat(), MAT_NOT); } -oclMatExpr cv::ocl::operator | (const oclMat &src1, const oclMat &src2) +oclMat cv::ocl::operator | (const oclMat &src1, const oclMat &src2) { return oclMatExpr(src1, src2, MAT_OR); } -oclMatExpr cv::ocl::operator & (const oclMat &src1, const oclMat &src2) +oclMat cv::ocl::operator & (const oclMat &src1, const oclMat &src2) { return oclMatExpr(src1, src2, MAT_AND); } -oclMatExpr cv::ocl::operator ^ (const oclMat &src1, const oclMat &src2) +oclMat cv::ocl::operator ^ (const oclMat &src1, const oclMat &src2) { return oclMatExpr(src1, src2, MAT_XOR); } From f4ef0c15985a26a559b3eaf2286a2da13cf999fd Mon Sep 17 00:00:00 2001 From: yao Date: Fri, 22 Feb 2013 10:13:20 +0800 Subject: [PATCH 18/24] fix meanShift mismatch on none-double GPUs --- modules/ocl/src/kernels/meanShift.cl | 19 +++++++------------ modules/ocl/test/test_imgproc.cpp | 15 +++++---------- 2 files changed, 12 insertions(+), 22 deletions(-) diff --git a/modules/ocl/src/kernels/meanShift.cl b/modules/ocl/src/kernels/meanShift.cl index bb68331c7b..4b5a08b352 100644 --- a/modules/ocl/src/kernels/meanShift.cl +++ b/modules/ocl/src/kernels/meanShift.cl @@ -12,11 +12,13 @@ // // Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved. // Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. +// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. // Third party copyrights are property of their respective owners. // // @Authors // Shengen Yan,yanshengen@gmail.com // Xu Pang, pangxu010@163.com +// Wenju He, wenju@multicorewareinc.com // // Redistribution and use in source and binary forms, with or without modification, // are permitted provided that the following conditions are met: @@ -43,12 +45,6 @@ // the use of this software, even if advised of the possibility of such damage. // //M*/ -#if defined (DOUBLE_SUPPORT) -#pragma OPENCL EXTENSION cl_khr_fp64:enable -typedef double F; -#else -typedef float F; -#endif short2 do_mean_shift(int x0, int y0, __global uchar4* out,int out_step, __global uchar4* in, int in_step, int dst_off, int src_off, @@ -184,12 +180,11 @@ short2 do_mean_shift(int x0, int y0, __global uchar4* out,int out_step, if( count == 0 ) break; - F icount = 1.0/count; - int x1 = convert_int_rtz(sx*icount); - int y1 = convert_int_rtz(sy*icount); - s.x = convert_int_rtz(s.x*icount); - s.y = convert_int_rtz(s.y*icount); - s.z = convert_int_rtz(s.z*icount); + int x1 = sx/count; + int y1 = sy/count; + s.x = s.x/count; + s.y = s.y/count; + s.z = s.z/count; int4 tmp = s - convert_int4(c); int norm2 = tmp.x * tmp.x + tmp.y * tmp.y + diff --git a/modules/ocl/test/test_imgproc.cpp b/modules/ocl/test/test_imgproc.cpp index 97174ecbd3..5bf08c80e1 100644 --- a/modules/ocl/test/test_imgproc.cpp +++ b/modules/ocl/test/test_imgproc.cpp @@ -183,12 +183,11 @@ COOR do_meanShift(int x0, int y0, uchar *sptr, uchar *dptr, int sstep, cv::Size if( count == 0 ) break; - double icount = 1.0 / count; - int x1 = cvFloor(sx * icount); - int y1 = cvFloor(sy * icount); - s0 = cvFloor(s0 * icount); - s1 = cvFloor(s1 * icount); - s2 = cvFloor(s2 * icount); + int x1 = sx / count; + int y1 = sy / count; + s0 = s0 / count; + s1 = s1 / count; + s2 = s2 / count; bool stopFlag = (x0 == x1 && y0 == y1) || (abs(x1 - x0) + abs(y1 - y0) + tab[s0 - c0 + 255] + tab[s1 - c1 + 255] + tab[s2 - c2 + 255] <= eps); @@ -1370,9 +1369,7 @@ TEST_P(meanShiftFiltering, Mat) gdst.download(cpu_gdst); char sss[1024]; - char warning[300] = "Warning: If the selected device doesn't support double, a deviation will exist.\nIf the accuracy is acceptable, please ignore it.\n"; sprintf(sss, "roicols=%d,roirows=%d,srcx=%d,srcy=%d,dstx=%d,dsty=%d\n", roicols, roirows, srcx, srcy, dstx, dsty); - strcat(sss, warning); EXPECT_MAT_NEAR(dst, cpu_gdst, 0.0, sss); } @@ -1398,9 +1395,7 @@ TEST_P(meanShiftProc, Mat) gdstCoor.download(cpu_gdstCoor); char sss[1024]; - char warning[300] = "Warning: If the selected device doesn't support double, a deviation will exist.\nIf the accuracy is acceptable, please ignore it.\n"; sprintf(sss, "roicols=%d,roirows=%d,srcx=%d,srcy=%d,dstx=%d,dsty=%d\n", roicols, roirows, srcx, srcy, dstx, dsty); - strcat(sss, warning); EXPECT_MAT_NEAR(dst, cpu_gdst, 0.0, sss); EXPECT_MAT_NEAR(dstCoor, cpu_gdstCoor, 0.0, sss); } From 2e3f4fdada7f9ad1df0a835034ab1627410ceaba Mon Sep 17 00:00:00 2001 From: yao Date: Fri, 22 Feb 2013 11:23:43 +0800 Subject: [PATCH 19/24] fix pyrLK's mismatch on Linux --- modules/ocl/src/mcwutil.cpp | 95 ++++++++++++++ modules/ocl/src/mcwutil.hpp | 6 + modules/ocl/src/pyrlk.cpp | 240 ++++-------------------------------- 3 files changed, 126 insertions(+), 215 deletions(-) diff --git a/modules/ocl/src/mcwutil.cpp b/modules/ocl/src/mcwutil.cpp index b6c99e1502..57ead2cec5 100644 --- a/modules/ocl/src/mcwutil.cpp +++ b/modules/ocl/src/mcwutil.cpp @@ -123,6 +123,101 @@ namespace cv openCLExecuteKernel_2(clCxt, source, kernelName, globalThreads, localThreads, args, channels, depth, build_options, finish_mode); } + + cl_mem bindTexture(const oclMat &mat) + { + cl_mem texture; + cl_image_format format; + int err; + int depth = mat.depth(); + int channels = mat.channels(); + + switch(depth) + { + case CV_8U: + format.image_channel_data_type = CL_UNSIGNED_INT8; + break; + case CV_32S: + format.image_channel_data_type = CL_UNSIGNED_INT32; + break; + case CV_32F: + format.image_channel_data_type = CL_FLOAT; + break; + default: + throw std::exception(); + break; + } + switch(channels) + { + case 1: + format.image_channel_order = CL_R; + break; + case 3: + format.image_channel_order = CL_RGB; + break; + case 4: + format.image_channel_order = CL_RGBA; + break; + default: + throw std::exception(); + break; + } +#if CL_VERSION_1_2 + cl_image_desc desc; + desc.image_type = CL_MEM_OBJECT_IMAGE2D; + desc.image_width = mat.cols; + desc.image_height = mat.rows; + desc.image_depth = 0; + desc.image_array_size = 1; + desc.image_row_pitch = 0; + desc.image_slice_pitch = 0; + desc.buffer = NULL; + desc.num_mip_levels = 0; + desc.num_samples = 0; + texture = clCreateImage(mat.clCxt->impl->clContext, CL_MEM_READ_WRITE, &format, &desc, NULL, &err); +#else + texture = clCreateImage2D( + mat.clCxt->impl->clContext, + CL_MEM_READ_WRITE, + &format, + mat.cols, + mat.rows, + 0, + NULL, + &err); +#endif + size_t origin[] = { 0, 0, 0 }; + size_t region[] = { mat.cols, mat.rows, 1 }; + + cl_mem devData; + if (mat.cols * mat.elemSize() != mat.step) + { + devData = clCreateBuffer(mat.clCxt->impl->clContext, CL_MEM_READ_ONLY, mat.cols * mat.rows + * mat.elemSize(), NULL, NULL); + const size_t regin[3] = {mat.cols * mat.elemSize(), mat.rows, 1}; + clEnqueueCopyBufferRect(mat.clCxt->impl->clCmdQueue, (cl_mem)mat.data, devData, origin, origin, + regin, mat.step, 0, mat.cols * mat.elemSize(), 0, 0, NULL, NULL); + } + else + { + devData = (cl_mem)mat.data; + } + + clEnqueueCopyBufferToImage(mat.clCxt->impl->clCmdQueue, devData, texture, 0, origin, region, 0, NULL, 0); + if ((mat.cols * mat.elemSize() != mat.step)) + { + clFinish(mat.clCxt->impl->clCmdQueue); + clReleaseMemObject(devData); + } + + openCLSafeCall(err); + return texture; + } + + void releaseTexture(cl_mem& texture) + { + openCLFree(texture); + } }//namespace ocl }//namespace cv diff --git a/modules/ocl/src/mcwutil.hpp b/modules/ocl/src/mcwutil.hpp index fe2b49ab51..8db61f1633 100644 --- a/modules/ocl/src/mcwutil.hpp +++ b/modules/ocl/src/mcwutil.hpp @@ -67,6 +67,12 @@ namespace cv void openCLExecuteKernel2(Context *clCxt , const char **source, string kernelName, size_t globalThreads[3], size_t localThreads[3], vector< pair > &args, int channels, int depth, char *build_options, FLUSH_MODE finish_mode = DISABLE); + // bind oclMat to OpenCL image textures + // note: + // 1. there is no memory management. User need to explicitly release the resource + // 2. for faster clamping, there is no buffer padding for the constructed texture + cl_mem bindTexture(const oclMat &mat); + void releaseTexture(cl_mem& texture); }//namespace ocl }//namespace cv diff --git a/modules/ocl/src/pyrlk.cpp b/modules/ocl/src/pyrlk.cpp index d14201de1c..87c536ec94 100644 --- a/modules/ocl/src/pyrlk.cpp +++ b/modules/ocl/src/pyrlk.cpp @@ -10,10 +10,15 @@ // 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. +// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. +// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. // Third party copyrights are property of their respective owners. // +// @Authors +// Dachuan Zhao, dachuan@multicorewareinc.com +// Yao Wang, yao@multicorewareinc.com +// Nathan, liujun@multicorewareinc.com +// // Redistribution and use in source and binary forms, with or without modification, // are permitted provided that the following conditions are met: // @@ -22,13 +27,13 @@ // // * 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 GpuMaterials provided with the distribution. +// and/or other oclMaterials 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 bpied warranties, including, but not limited to, the bpied +// 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 @@ -40,6 +45,7 @@ // //M*/ + #include "precomp.hpp" #include "mcwutil.hpp" using namespace std; @@ -568,197 +574,16 @@ static void pyrDown_cus(const oclMat &src, oclMat &dst) pyrdown_run_cus(src, dst); } - -//struct MultiplyScalar -//{ -// MultiplyScalar(double val_, double scale_) : val(val_), scale(scale_) {} -// double operator ()(double a) const -// { -// return (scale * a * val); -// } -// const double val; -// const double scale; -//}; -// -//void callF(const oclMat& src, oclMat& dst, MultiplyScalar op, int mask) -//{ -// Mat srcTemp; -// Mat dstTemp; -// src.download(srcTemp); -// dst.download(dstTemp); -// -// int i; -// int j; -// int k; -// for(i = 0; i < srcTemp.rows; i++) -// { -// for(j = 0; j < srcTemp.cols; j++) -// { -// for(k = 0; k < srcTemp.channels(); k++) -// { -// ((float*)dstTemp.data)[srcTemp.channels() * (i * srcTemp.rows + j) + k] = (float)op(((float*)srcTemp.data)[srcTemp.channels() * (i * srcTemp.rows + j) + k]); -// } -// } -// } -// -// dst = dstTemp; -//} -// -//static inline bool isAligned(const unsigned char* ptr, size_t size) -//{ -// return reinterpret_cast(ptr) % size == 0; -//} -// -//static inline bool isAligned(size_t step, size_t size) -//{ -// return step % size == 0; -//} -// -//void callT(const oclMat& src, oclMat& dst, MultiplyScalar op, int mask) -//{ -// if (!isAligned(src.data, 4 * sizeof(double)) || !isAligned(src.step, 4 * sizeof(double)) || -// !isAligned(dst.data, 4 * sizeof(double)) || !isAligned(dst.step, 4 * sizeof(double))) -// { -// callF(src, dst, op, mask); -// return; -// } -// -// Mat srcTemp; -// Mat dstTemp; -// src.download(srcTemp); -// dst.download(dstTemp); -// -// int x_shifted; -// -// int i; -// int j; -// for(i = 0; i < srcTemp.rows; i++) -// { -// const double* srcRow = (const double*)srcTemp.data + i * srcTemp.rows; -// double* dstRow = (double*)dstTemp.data + i * dstTemp.rows;; -// -// for(j = 0; j < srcTemp.cols; j++) -// { -// x_shifted = j * 4; -// -// if(x_shifted + 4 - 1 < srcTemp.cols) -// { -// dstRow[x_shifted ] = op(srcRow[x_shifted ]); -// dstRow[x_shifted + 1] = op(srcRow[x_shifted + 1]); -// dstRow[x_shifted + 2] = op(srcRow[x_shifted + 2]); -// dstRow[x_shifted + 3] = op(srcRow[x_shifted + 3]); -// } -// else -// { -// for (int real_x = x_shifted; real_x < srcTemp.cols; ++real_x) -// { -// ((float*)dstTemp.data)[i * srcTemp.rows + real_x] = op(((float*)srcTemp.data)[i * srcTemp.rows + real_x]); -// } -// } -// } -// } -//} -// -//void multiply(const oclMat& src1, double val, oclMat& dst, double scale = 1.0f); -//void multiply(const oclMat& src1, double val, oclMat& dst, double scale) -//{ -// MultiplyScalar op(val, scale); -// //if(src1.channels() == 1 && dst.channels() == 1) -// //{ -// // callT(src1, dst, op, 0); -// //} -// //else -// //{ -// callF(src1, dst, op, 0); -// //} -//} - -static cl_mem bindTexture(const oclMat &mat, int depth, int channels) -{ - cl_mem texture; - cl_image_format format; - int err; - if(depth == 0) - { - format.image_channel_data_type = CL_UNSIGNED_INT8; - } - else if(depth == 5) - { - format.image_channel_data_type = CL_FLOAT; - } - if(channels == 1) - { - format.image_channel_order = CL_R; - } - else if(channels == 3) - { - format.image_channel_order = CL_RGB; - } - else if(channels == 4) - { - format.image_channel_order = CL_RGBA; - } -#ifdef CL_VERSION_1_2 - cl_image_desc desc; - desc.image_type = CL_MEM_OBJECT_IMAGE2D; - desc.image_width = mat.step / mat.elemSize(); - desc.image_height = mat.rows; - desc.image_depth = 0; - desc.image_array_size = 1; - desc.image_row_pitch = 0; - desc.image_slice_pitch = 0; - desc.buffer = NULL; - desc.num_mip_levels = 0; - desc.num_samples = 0; - texture = clCreateImage(mat.clCxt->impl->clContext, CL_MEM_READ_WRITE, &format, &desc, NULL, &err); -#else - texture = clCreateImage2D( - mat.clCxt->impl->clContext, - CL_MEM_READ_WRITE, - &format, - mat.step / mat.elemSize(), - mat.rows, - 0, - NULL, - &err); -#endif - size_t origin[] = { 0, 0, 0 }; - size_t region[] = { mat.step / mat.elemSize(), mat.rows, 1 }; - clEnqueueCopyBufferToImage(mat.clCxt->impl->clCmdQueue, (cl_mem)mat.data, texture, 0, origin, region, 0, NULL, 0); - openCLSafeCall(err); - - return texture; -} - -static void releaseTexture(cl_mem texture) -{ - openCLFree(texture); -} - static void lkSparse_run(oclMat &I, oclMat &J, const oclMat &prevPts, oclMat &nextPts, oclMat &status, oclMat& err, bool /*GET_MIN_EIGENVALS*/, int ptcount, int level, /*dim3 block, */dim3 patch, Size winSize, int iters) { Context *clCxt = I.clCxt; - char platform[256] = {0}; - cl_platform_id pid; - clGetDeviceInfo(clCxt->impl->devices, CL_DEVICE_PLATFORM, sizeof(pid), &pid, NULL); - clGetPlatformInfo(pid, CL_PLATFORM_NAME, 256, platform, NULL); - std::string namestr = platform; - bool isImageSupported = true; - if(namestr.find("NVIDIA")!=string::npos || namestr.find("Intel")!=string::npos) - isImageSupported = false; - int elemCntPerRow = I.step / I.elemSize(); - string kernelName = "lkSparse"; - - - size_t localThreads[3] = { 8, isImageSupported?8:32, 1 }; - size_t globalThreads[3] = { 8 * ptcount, isImageSupported?8:32, 1}; - + size_t localThreads[3] = { 8, 8, 1 }; + size_t globalThreads[3] = { 8 * ptcount, 8, 1}; int cn = I.oclchannels(); - char calcErr; if (level == 0) { @@ -770,22 +595,11 @@ static void lkSparse_run(oclMat &I, oclMat &J, } vector > args; - cl_mem ITex; - cl_mem JTex; - if (isImageSupported) - { - ITex = bindTexture(I, I.depth(), cn); - JTex = bindTexture(J, J.depth(), cn); - } - else - { - ITex = (cl_mem)I.data; - JTex = (cl_mem)J.data; - } + cl_mem ITex = bindTexture(I); + cl_mem JTex = bindTexture(J); args.push_back( make_pair( sizeof(cl_mem), (void *)&ITex )); args.push_back( make_pair( sizeof(cl_mem), (void *)&JTex )); - //cl_mem clmD = clCreateBuffer(clCxt, CL_MEM_READ_WRITE, ptcount * sizeof(float), NULL, NULL); args.push_back( make_pair( sizeof(cl_mem), (void *)&prevPts.data )); args.push_back( make_pair( sizeof(cl_int), (void *)&prevPts.step )); args.push_back( make_pair( sizeof(cl_mem), (void *)&nextPts.data )); @@ -795,10 +609,6 @@ static void lkSparse_run(oclMat &I, oclMat &J, args.push_back( make_pair( sizeof(cl_int), (void *)&level )); args.push_back( make_pair( sizeof(cl_int), (void *)&I.rows )); args.push_back( make_pair( sizeof(cl_int), (void *)&I.cols )); - if (!isImageSupported) - { - args.push_back( make_pair( sizeof(cl_int), (void *)&elemCntPerRow ) ); - } args.push_back( make_pair( sizeof(cl_int), (void *)&patch.x )); args.push_back( make_pair( sizeof(cl_int), (void *)&patch.y )); args.push_back( make_pair( sizeof(cl_int), (void *)&cn )); @@ -806,18 +616,20 @@ static void lkSparse_run(oclMat &I, oclMat &J, args.push_back( make_pair( sizeof(cl_int), (void *)&winSize.height )); args.push_back( make_pair( sizeof(cl_int), (void *)&iters )); args.push_back( make_pair( sizeof(cl_char), (void *)&calcErr )); - //args.push_back( make_pair( sizeof(cl_char), (void *)&GET_MIN_EIGENVALS )); - if (isImageSupported) + try { openCLExecuteKernel2(clCxt, &pyrlk, kernelName, globalThreads, localThreads, args, I.oclchannels(), I.depth(), CLFLUSH); - + } + catch(Exception&) + { + printf("Warning: The image2d_t is not supported by the device. Using alternative method!\n"); releaseTexture(ITex); releaseTexture(JTex); - } - else - { - //printf("Warning: The image2d_t is not supported by the device. Using alternative method!\n"); + ITex = (cl_mem)I.data; + JTex = (cl_mem)J.data; + localThreads[1] = globalThreads[1] = 32; + args.insert( args.begin()+11, make_pair( sizeof(cl_int), (void *)&elemCntPerRow ) ); openCLExecuteKernel2(clCxt, &pyrlk_no_image, kernelName, globalThreads, localThreads, args, I.oclchannels(), I.depth(), CLFLUSH); } } @@ -927,8 +739,6 @@ static void lkDense_run(oclMat &I, oclMat &J, oclMat &u, oclMat &v, size_t localThreads[3] = { 16, 16, 1 }; size_t globalThreads[3] = { I.cols, I.rows, 1}; - int cn = I.oclchannels(); - bool calcErr; if (err) { @@ -944,8 +754,8 @@ static void lkDense_run(oclMat &I, oclMat &J, oclMat &u, oclMat &v, if (isImageSupported) { - ITex = bindTexture(I, I.depth(), cn); - JTex = bindTexture(J, J.depth(), cn); + ITex = bindTexture(I); + JTex = bindTexture(J); } else { From 3316d0bfb2a00193886c784f60ce151a50ba6309 Mon Sep 17 00:00:00 2001 From: yao Date: Fri, 22 Feb 2013 15:05:49 +0800 Subject: [PATCH 20/24] Fix the compiling errors of gemm on Linux --- modules/ocl/perf/perf_gemm.cpp | 2 +- modules/ocl/test/test_gemm.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/ocl/perf/perf_gemm.cpp b/modules/ocl/perf/perf_gemm.cpp index 7801c140be..c3dcab34fe 100644 --- a/modules/ocl/perf/perf_gemm.cpp +++ b/modules/ocl/perf/perf_gemm.cpp @@ -109,5 +109,5 @@ TEST_P(Gemm, Performance) INSTANTIATE_TEST_CASE_P(ocl_gemm, Gemm, testing::Combine( testing::Values(CV_32FC1, CV_32FC2/* , CV_64FC1, CV_64FC2*/), testing::Values(cv::Size(512, 512), cv::Size(1024, 1024)), - testing::Values(0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_1_T + cv::GEMM_2_T))); + testing::Values(0, (int)cv::GEMM_1_T, (int)cv::GEMM_2_T, (int)(cv::GEMM_1_T + cv::GEMM_2_T)))); #endif \ No newline at end of file diff --git a/modules/ocl/test/test_gemm.cpp b/modules/ocl/test/test_gemm.cpp index 4ec3337b2c..c26a8481f2 100644 --- a/modules/ocl/test/test_gemm.cpp +++ b/modules/ocl/test/test_gemm.cpp @@ -81,5 +81,5 @@ TEST_P(Gemm, Accuracy) INSTANTIATE_TEST_CASE_P(ocl_gemm, Gemm, testing::Combine( testing::Values(CV_32FC1, CV_32FC2/*, CV_64FC1, CV_64FC2*/), testing::Values(cv::Size(20, 20), cv::Size(300, 300)), - testing::Values(0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_1_T + cv::GEMM_2_T))); + testing::Values(0, (int)cv::GEMM_1_T, (int)cv::GEMM_2_T, (int)(cv::GEMM_1_T + cv::GEMM_2_T)))); #endif From 7810254198d53a90b16f0b2e958e884367b543ec Mon Sep 17 00:00:00 2001 From: yao Date: Fri, 22 Feb 2013 15:48:31 +0800 Subject: [PATCH 21/24] Fix ocl::equalizeHist mismatch --- modules/ocl/src/imgproc.cpp | 8 +++++--- modules/ocl/src/kernels/imgproc_histogram.cl | 13 +++++++++---- 2 files changed, 14 insertions(+), 7 deletions(-) diff --git a/modules/ocl/src/imgproc.cpp b/modules/ocl/src/imgproc.cpp index a93f86ecb9..f7d0c43948 100644 --- a/modules/ocl/src/imgproc.cpp +++ b/modules/ocl/src/imgproc.cpp @@ -12,6 +12,7 @@ // // Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved. // Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. +// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. // Third party copyrights are property of their respective owners. // // @Authors @@ -23,6 +24,7 @@ // Zhang Ying, zhangying913@gmail.com // Xu Pang, pangxu010@163.com // Wu Zailong, bullet@yeah.net +// Wenju He, wenju@multicorewareinc.com // // Redistribution and use in source and binary forms, with or without modification, // are permitted provided that the following conditions are met: @@ -1524,7 +1526,7 @@ namespace cv mat_dst.create(mat_src.rows, mat_src.cols, CV_8UC1); oclMat mat_hist(1, 256, CV_32SC1); - //mat_hist.setTo(0); + calcHist(mat_src, mat_hist); Context *clCxt = mat_src.clCxt; @@ -1533,10 +1535,10 @@ namespace cv size_t globalThreads[3] = { 256, 1, 1}; oclMat lut(1, 256, CV_8UC1); vector > args; - float scale = 255.f / (mat_src.rows * mat_src.cols); + int total = mat_src.rows * mat_src.cols; args.push_back( make_pair( sizeof(cl_mem), (void *)&lut.data)); args.push_back( make_pair( sizeof(cl_mem), (void *)&mat_hist.data)); - args.push_back( make_pair( sizeof(cl_float), (void *)&scale)); + args.push_back( make_pair( sizeof(int), (void *)&total)); openCLExecuteKernel(clCxt, &imgproc_histogram, kernelName, globalThreads, localThreads, args, -1, -1); LUT(mat_src, lut, mat_dst); } diff --git a/modules/ocl/src/kernels/imgproc_histogram.cl b/modules/ocl/src/kernels/imgproc_histogram.cl index 11db9b5138..01e333fbc1 100644 --- a/modules/ocl/src/kernels/imgproc_histogram.cl +++ b/modules/ocl/src/kernels/imgproc_histogram.cl @@ -3,12 +3,14 @@ // // Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved. // Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. +// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. // Third party copyrights are property of their respective owners. // // @Authors // Niko Li, newlife20080214@gmail.com // Jia Haipeng, jiahaipeng95@gmail.com // Xu Pang, pangxu010@163.com +// Wenju He, wenju@multicorewareinc.com // Redistribution and use in source and binary forms, with or without modification, // are permitted provided that the following conditions are met: // @@ -189,24 +191,27 @@ __kernel __attribute__((reqd_work_group_size(256,1,1)))void merge_hist(__global __kernel __attribute__((reqd_work_group_size(256,1,1)))void calLUT( __global uchar * dst, __constant int * hist, - float scale) + int total) { int lid = get_local_id(0); - __local int sumhist[HISTOGRAM256_BIN_COUNT]; - //__local uchar lut[HISTOGRAM256_BIN_COUNT+1]; + __local int sumhist[HISTOGRAM256_BIN_COUNT+1]; sumhist[lid]=hist[lid]; barrier(CLK_LOCAL_MEM_FENCE); if(lid==0) { int sum = 0; - for(int i=0;i Date: Fri, 22 Feb 2013 11:57:42 +0400 Subject: [PATCH 22/24] Bug #2821 Installation of OpenCV modules breaks build on MIPS Android fixed. Native camera libs for MIPS installation fixed. --- cmake/OpenCVGenAndroidMK.cmake | 2 +- cmake/templates/OpenCV.mk.in | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/cmake/OpenCVGenAndroidMK.cmake b/cmake/OpenCVGenAndroidMK.cmake index 5b11afc17b..ba67f41891 100644 --- a/cmake/OpenCVGenAndroidMK.cmake +++ b/cmake/OpenCVGenAndroidMK.cmake @@ -20,7 +20,7 @@ if(ANDROID) endif() # setup lists of camera libs - foreach(abi ARMEABI ARMEABI_V7A X86) + foreach(abi ARMEABI ARMEABI_V7A X86 MIPS) ANDROID_GET_ABI_RAWNAME(${abi} ndkabi) if(BUILD_ANDROID_CAMERA_WRAPPER) if(ndkabi STREQUAL ANDROID_NDK_ABI_NAME) diff --git a/cmake/templates/OpenCV.mk.in b/cmake/templates/OpenCV.mk.in index 943d7cb672..8c1b855380 100644 --- a/cmake/templates/OpenCV.mk.in +++ b/cmake/templates/OpenCV.mk.in @@ -57,6 +57,9 @@ ifeq (${OPENCV_CAMERA_MODULES},on) ifeq ($(TARGET_ARCH_ABI),x86) OPENCV_CAMERA_MODULES:=@OPENCV_CAMERA_LIBS_X86_CONFIGCMAKE@ endif + ifeq ($(TARGET_ARCH_ABI),mips) + OPENCV_CAMERA_MODULES:=@OPENCV_CAMERA_LIBS_MIPS_CONFIGCMAKE@ + endif else OPENCV_CAMERA_MODULES:= endif From 1a488c05429904697e8bca1548700b983d668e2e Mon Sep 17 00:00:00 2001 From: yao Date: Fri, 22 Feb 2013 18:33:16 +0800 Subject: [PATCH 23/24] fix the warning on Linux when OpenCL 1.2 not supported --- modules/ocl/src/mcwutil.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/modules/ocl/src/mcwutil.cpp b/modules/ocl/src/mcwutil.cpp index 57ead2cec5..dfbf7b1bbb 100644 --- a/modules/ocl/src/mcwutil.cpp +++ b/modules/ocl/src/mcwutil.cpp @@ -46,6 +46,9 @@ #include "mcwutil.hpp" #if defined (HAVE_OPENCL) +#ifndef CL_VERSION_1_2 +#define CL_VERSION_1_2 0 +#endif using namespace std; From e6dd4e840d53b20b677706fc55cbdacd59e148cd Mon Sep 17 00:00:00 2001 From: OpenCV Buildbot Date: Fri, 22 Feb 2013 16:56:01 +0400 Subject: [PATCH 24/24] Update FFMPEG wrapper binaries --- 3rdparty/ffmpeg/opencv_ffmpeg.dll | Bin 9162979 -> 9162979 bytes 3rdparty/ffmpeg/opencv_ffmpeg_64.dll | Bin 9220252 -> 9220252 bytes 2 files changed, 0 insertions(+), 0 deletions(-) diff --git a/3rdparty/ffmpeg/opencv_ffmpeg.dll b/3rdparty/ffmpeg/opencv_ffmpeg.dll index 1641c8a516d74b2e9fdea86ff9c806a9695e7f43..a3fede52c781512b665b076ff378d6c06830d1b4 100644 GIT binary patch delta 326409 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 IXOunjf9yTSQUCw| delta 326328 zcmZs@2VBqF|2Y1Bp4WPpC{!wKZw-Z#QHWB>2-zzmglmtGJu2ia;)SPi?LDp)j=jlV z*TuE3SvJ?YR{!UDzq{k}|NcB4dcDqhp7}h_eV(uP!{uA#hx9*Zs`T!o`z&)4mK-W18y7JuWW8KTm)#9TT-g1f~Q{B#*1BW(!1I?LT`PTO$~Obx4zk?9qiII+ww3$ zuV_0H67>VNW!cq<`c0}TKD$^Bxa+fuEr3aSkX;xw&Fx~>3&tmz$Cw6X)i&kBkHW&d zSd*QB{?XGYp5|CnYF4aC7V!QT42I0ZX(I_HTVPt2Y|8(%LDbq$?GDshGbcJ`UP-MN zdMi74v87Fvi&+jZ4>D%Qnu101-kvFjL>e_JYjOgk9+UMZC0vR%GiIJni`)w7$CLCy zC91Y~UpB=crVRdGSQvVkYCCrB(&<>w9P{L>G^!Y9N#)`+ZR*Xx7iw8#Ra5@(lA=EC zXjT^^t;RBYR=iz)T|L;|-R4Tq;+D=m_2%~eP){FeA8IUkPTS5NZqWDJyTT{^ntd}^ zs{1+k!EU{YLpOM=Z*`~(t@Sq!z2KMJb|s&K?cy>ihTq4SD)lsDonO0`&Fx+K8Ndp? zrBgZAO4$ZO`sWX+FU>K=i1c=Zl2m80kDmHWr%EtFKj_p13Uck7Zvl+e^UIWjhPiew zw`I7k7r5799$tE&hYuXp8+*)#r}|xwR`ed`S*v~vJ3>cHfVq_^yx;<%L~Pniv7D0p z26_(8lT9;N&%ybkoq(17U)WRut8S<7@T|mquj!9GO*PjQOEH*Z9P`8(Sx{28Rd=dz zA(R>gdhIMlZ*!ETR6S0#w!HqS*YolVf6-F3mZdZovAeres!zp;L5?FXn@fMJ7XYcl z#3-vR%>rmpdr>S^Okd^|?H}~4urM-TBHUEYJWSn2{w{!v|1cN|uG3kVqZ~vzQa5^U zhF3cGPJnH??BfH6bU&ZQa9tnbGX?hPUwjsozSov0D8bY!Yk`F<+)eo&x$Au20kiFz z`?Ki`Kxe&|-x%ut$S(ns^icl}ut%Tn@58h_eT)A%I*>{M6Fgtz7ET3#NUemF`jsXR+DgdQ$v_n8{fT<<>6Vt+P05*VbSmlax*pu3HG zx9!j0r9TYtf!ewf=ntFpih-V8ZvXGO{4CBT3sMX@Ez@7P&>3vJU3qaGC&W*knn&AO3(+@<3&B3dzT+5_uyjG%7_bT8I|ie^c4zpq~oJRnsu zr0BCMbT{rV>|qGK_57i}HPE@(ia-BuG)MOc>IcR2X+eJWtK$EAs`KiVH7&fukAt5U)KeHUWxRFiCNHBYw>YY*-8pTb(g zd;LII0G!pIgw?c+lj~l!G{AB_q*`T|rFX67Z}ZcK9)`?Y_8FQURm}^c^{v(XZC#7% zUMqTZHBWduySl&a>G#%l*R6HS^+c*1SyXvQRC?*ls4B3iYOSKrq5#&+{Qjr4 z^GyAIHE%tthQCc#QOyWFq`J4BQ^UVh1l43EnPegcZ`yHw=%4!O8r7V>yz60z_%ZBe z5y)16p6I2+BT3LV4-bI0`l#>#R_UF-D%_tb@AUKG{v=aA5F}Ukj0hl%$J5_reNaRI z3xBIGjPPgnZ}npl{_sS9PLKn-W6c1Vqes%;zIspkTTh=^Gl03i(f8CW#~fPfcWXw$ z1>LJwIoP1b)T+UTw9qfra${|*kDAtpr}e=s4;uPnt+H^&@^`c4?`+H8;g-K0EPv}* z{`y+}s^TwumM8`mb48Yg?Ru?96J+aMBYm{KiQNqa#_xJ`q^DY6yzkX7M|v@zME!hZ zIryf(jWlW3n^FCxucD2%UA#}Syo(X)nAF~)=7}B^>7~Yq*ZJa=c{bB8)hVa_)s$+! z{blKTRlIMuyu%i~PF<5WP1KaK)}-iD>n?!Nx^L887^L5c>d#n2ZbEc>8RGRdaUovL zjRYGRv-+8gf*u7cuDoey$O<-P<>lKX=pW*qihlJ66Y)2TkB42k7++1IlRV$34GXNS zmv20c7QD5wFLR64uQm=N9b`;s0B`i>3BE8=Pfe%{i|O4>KbT--elhx~gg|I!sjzEe zgd4h3lL`Q$Y;#}hIao|TP4C_$1lsF!npCz8tk>OOzbnR65U+bT@q$)*R1-HF&1h|S zC)c5A7K4`h!bD%Vq#sBOrGt2#xDi_Di<+C@yneX(08(|8Te!khyYpF4Z)njPF3)c11($X2maPJlt`jj628fs~6q`zAp>&9y?QCemswN?6^Q&Fg7q{#L zAN8*-gWhM^d_x*V4Oa%RRgzb5rocIQ>;*IVxFuqR-Af7=$Bi0iGy!d1|I1) zt-ZsKh5y?$SM0s0=|)j+nb>HVSX2v1PooO-OxKfJmn+tr8Wr>^6vlu)u(cC3$X(sq zlQElyxhL9sNX#}&f7D?;bkS#Y)V(&w(oPag!4T(Nvb8D8&LkL>h0s9XMF+FPk5;K~8Q}vjbV#cV z`}NSY8jzv?lole^m=?l(o%C}Ac)Rjj8Zf(U`j3&(usAnrlp|2%)}y_Hc)9MvZVb!r z3}W}eG@wwT)3=apKAd%O*cr=72AlHhl*?TF&T6mMFHEcjzvkLbatFrN=>h4rNuQ;p*JP1pbC;)A24nadF?eb_yK`6oeHo{kIRaKZn~NNCh3>6M!_F?!Za7>Q~BKl{RdcR zlT5(iEJss*u0Cqo4<_g9qs)UDF#V<3A5Q5`(<{(=qo#WU5KU*-Br)=Hb`tUUU)i;R z>(yuMgRlC#84bxIsy#D}h5yiZ&GaKL;m*u&guk0P!OZVLu5s2u#;QNjPw6vYO>Wyc zl_jF#DLArth~C4H9%q2(le2dj&|#J0nCmnDGeDm1wy-@M$W2{XLxSksO^a&)vw5vQ zUNRKs=VhHTS30k_4%G z|8*mn%jMiB>ka|L=dRgcC$UOnb9ekQ1mK$Pzs1Zdjn;Q;X$TK7FLYVlm;`yf5P)GYojY&kB(=%kf?5*;|RMEFexBZMX zb^25?uHa4jD~rZ^OjYTxVdUX#OT8HD3RPvt*gY?2)>lzevpgyNu(tsGv`chfCh9DZ zYsd3apB810~b=#G!0`=ftbn`7(*V7>nS&M26n54>B6 zB>s}SJt03=x%WFT&u#ks`>WKntpXjmwV17=zT^)RtFTEw{>N-0&$bUL!CHOtgIxGi zulX<-PU^iL?xG<)AC)7+s@@}Hr8nxg9z~HY=Kk0R2I_Sl2QcRudT%NW)u%m9gHgKl z#K--{t!{?Q!qhU^G44X|8N~LBl-XE4>PaV3_)DI6vXHgYH*jN4qyun8)(mKi&{0-`1DE^JI}1_2}o0ke7SyU3Gx_dhz!G zLNL8w%E~OzufMOT<`bb6_d^6T%-3IiFuC5Ob1&HQh19`x z>jDz2_P`K5=;Jr?)B`^4fI+!;KD7YYmK*X{J0SBr>&q@ye0*;7*X9iN>iYLag!#MQ zGs%hR@#81*N-q590=c=B3d>6oe+?2;LQ#u#Ss#ix>j_m6=?}R|R-JiJROZLjVnuXv z?j%w9F*`wqM{qhZCM4q+32L*d({Qf@vtT(U$j}-Z;|iH-OJw1F8EV00bXTB1ld{mP zKm-eziYFC#3=?saO0DE6_)LWga08t*s3uKX&>cfHaKRJ}%EBC+s6iKIHyIyj5DLGe zqY-MrX-qIepgd)8Hv@)@vnhi)Mo?Id`G`jFw5gHV&7$%h5i}^x%4XuPMu>#lSki_@ zJd71>z`NAa46$#=0*T@af(5+#U>6&RfL6GGz$`2S_t`)=jKudg(2NBx#yDH3579W? z7V4G>JxiTqO)jLK+|!Q-AIr&3^)nPK!UwkSPU^R)yB;zj9PRDE3*Pa{cHqk(4_lOg zKQVH;5zV7(B1cVR{0`0-SWIr=a znqYFtJe^uXP~Z(rwudT^iF52B%f$Z zq!T!czNH`m#^JzH;16vOOF=Bj4&q|+h7&2$l~rGO_@{)2Kdq~%&N^nFQG)=Ywgc6s za+}gX2Hq2lcY>;wl9Q}`+x~CgXPy4;TjxK0uk!Uy5W^q}UzVYzjlvigNQD&K?E;k@ zew##HUZz%}on(E=FIx&fxj+T^b;%wEivYt2S19Yzn;I2-w1&dy6bD(1S?WOCoxceO zQxm70iG=U}A7~6NcZJf>8+W?GT6lw<+#m^b-0KFbVGr+G76t;5%q4d^<1YBj9sC<@ z981hZCz9HS2*%xFZIOTz#3QIKo1o%doJSQ$t5c$su$WJ7>4zmzU0EEH5Z>6)1N@v8 z{Xcr-;ye!sasD{w-@*RwRjD}M_JGPT80|bEh&VCa6QW=hj`SqbiRPO;VT=r)F|Zue zgaY2991H@dQwbKFpR~`&p}DQ`g;-u-0#{aR)IYHG0!DUP=#|V{2NElOACy(!VYhei z_d)itmv%3+Jo5>iCOYq~)HFW|BmH48QOp*9qOE0k#~-@T0Y(PEQD{CdkU(4bkU&sW zSb${GR)o=fO=T!n90ua{+9W+fU!hMV#M>ONX4QlHad0GbD0w-|ve>-Tj@E@X$J>!G z06JjfIzYPbsX(Jm`=#u`?v3d=;;!2)$(+lfSw&; zC@jL+9pQAzXs7>O;1TSX1n=P-CU=6qFaghZf*Q>IJXbqI3$VFb+PY2xcOg+}8;3u4 zfsODxZ_pK7SPA!%mcgXdB%;g&9Gt{laB?>Y6ExTj*4m!6w{|~fkGG;oUJc~iyORKh zE%>SjZS*%DkOKAXVH_Wr3RM-KJztXz=EhO>Th0s5lupYo>(r6YUc$j6%FDO)$KxYO z2)^OpM?!#XuYI8AG4APyEfLFxyy`d-`84&(@pOilFlz!FgJrzQL?9!7C$39}>$LC* z8DI<04b7R*4))-qOy~?7FlI88hYb8_GU59;W=$r++yGZkhNd-769&xnjUS@|z<$nQ z`(1~#tS)pVA|hd$eOTGuKs0wal^6sBgWM0X^37IWaS9AppebKE9jZuR#w#-+7%pJp zOz?oN=#fJh=*ioP2c+SwS%lEA;<#}Z1hT3N@Y*b>L^?>B4P&7Xrq71P%=0T=nhkZ} z3)<_n+;vz@hq+^|>X~+d6 z#DB$W^J#)KOj!UGDlh(BVA5ie&bGW-%&;kzR||5-&?^ZG3PQScEEtFf7eGHaia`sZ zE_n043n2sGJHA;2UM%uDmi!s+RsQydhKw~i79?9E<}S-xe;-uPqbPiCs9|+~9RwCh z#9u(K#nidPHH=yet6&U1UJTyQ5!EFyMe6c48MjHropALMaE4j9e+kqh`CqsMd`g^q zl`L${L?M#AuVSU85Lu?=)#M@pKZ4{vF}%1_$^XhHEd>T7EHjsZS7d{iV#^j|dF+*c zc0a`OYT11+%d2JgN%SgK*-AV~)g|B`%OI%4{TIoGg1Tgni^qW8M`eflb-d(%$LoN61+-u_WIcJHvz?_O4R(wswhs2AXt0%{#xhv(aO+?`MS}$r zl8P2L8^^DN<}e5^uOvqJhHu4#43$;jOT1Eb6;yDj^h_)v^>R^shln8F(L63Vv(P@nRh)z>TK$Qhd%=^i6}gwB$0}^Um&X2t zqxQlmW*USa_d+?6^KScy>r%1dJ|f{{oK6pSPeEw0rrPO;El%J-ZlUPfVob7b_Cc`o zmjT_a{)bgndkc^{5QF!Vm9Y$$?}zwOSMSi)N%~kKDr9DP55O<`!P{j8)n{jzmJtUC zaFF0P>ira}9Ds73zxKC;V>~{_gh1+@qIQ3KI=gV_0pi8qxXVFs0H;~cJ26hhLn{Q29hJd%Tp55r5xqZ&ctEfCyBklN%IyC!jJbor0B5LdTL-NF@A&9$LdVTyzqAN*ao)EodRECE)p!5a1Hl!-5uP zD_TShRamYbJ+OElY+%(+;+{NGsDrTLDQN3>%J9z)7jLlca4yb21@GAKyZG}_xFGg+ z241sWw=wBBtaobrU5FdY9)s6f_h?#+w&x(*apyMzS@Ae+4S`73Ou~)lATFpj6?YS( z8q$xOI(9ymV~z?YE+j|DGEN=Q&-z+=4VFC*GyKw5CyTaOZ>aVEHqH`S*4nr;zjz*o z1AB9n$6o|@FuJa^;L;I8FF{$He2J{GIk@K%)MdtN_~jC$FfwJ5FT-EVcR40qfvM!6 zJibDDh77u2p$Ad_;9tQ7R^qf@VSr=Rr6eFjgca{-I{38$31Q!*Xm=Glx}I1f)?l$Y z_tNV>s^u3x;VQTRp={A_#P8kk-fv{`U*Q9Bgp4*j8$e#_UFT8wjZDo4^!C$ zx=P99JB=(tBAerNG1h~E+t}KUA@t)f?U*jZH$Jf>^I-6UFD=c6gKdq@Rtm1%nR_|0 ztqjidOJ&$kmc_cV5x{B<#auV`0p8>Kvg|AiXw8Sav)=(0W1=T34wf$I2vdnY*SO%*qqq9Hr zWAX&7#gRpOs^VEIjDXHo+w98^BVXil zY#LzsAXd}ye0;JYqK5s<4x|pV<1I$UO&l6T_%Go5gP0NAde^66xOEsJ;}GTVkp|-3 zV0MYj#4QzBTl-~|e+6bK$^yt2 zma4EOkbupruwyVEox)fMs}Y6qVXPf19*xVxSQ)ao_k_`4S=>~Wc>rw0dezu2QlWoU zqv8ZCQ=MIbw)m_%TMFIzv>I$Xqb`v(**5rruWPbSqy(GPVwtSOYksvBb7t@npGOiw z)P2cI*I_mQ$GJyc)3cXnJD%X0hy~I-(&7r38E%%bcB# zHzEX**Pyt_cXR)xChxHK6rea(QI}Q)I zZBJGRtXNH6tT*dngt2_kAf^EwX4+uZlKHsv^Mje2$`ofT7(u5y3lr1WGGY0pv1u@v zj~U4}7~v%PPhuwLx$B5V$jK}?MVSyqURUI6OrFI0lVH0zi3x`)Af1IfPFPDVoAfTQ zn1gW^F~0{>(^&;*ic8a(zvgF4MC*PJkL;GqVtzWSMAEEG1`86dSOyzSRCXwXjbVx} zMrN|W(vzt<-FnbJvh^*N(N!Fo$vQF@Bfpl(1}MyN8P+$m)zBYbn3*5c$I{b@0KArB zt?49XK4UT!DcmqsJT~AKdf28f5zec9#ymTmHJv%x%wONjVq_=b_vvf{#NoPZmc{%R zW7rHj-Ce)NtMnvJ__Txtu?knY zX(?L;l5FV4&n_d(!Ab7Fl96ZJmrq*FT1q5pudQRxSnwk}x}L2gp6I)Qt%aMs^hPQ{ zC)~e@#20Pl7ZT7bu<TNN%auLLQe-!~LtTaE)83pWlbl;dvzZ4u2!nP6F1*NY!YLefiPpZ5=hB10&-nHV zE6e0|yu`08S%$GV=sFGF5*J=)t)Mf$zRrBS-4|K6a&@n*!Q9p{{Uk(O%X%|pojEQ_ zs1ma7(8$|*kU7Mm&wli?ntESp2T z(tXxlg^qmo6Lv?TV;uB?9fEBb@{)N&4mN+u#!$TJ!b>ItD^VM-zGCq#)XY6zGcq*B z@=I^np8#YAy(1QQ&;NSI=1QzYHqZIUf*DEZ1E1+wZg8i+s6SDV+ZWaahVoHg*mzO= z@|7K7p|kM7H};rSSc$8?vtS4JoUVr5eA~W*1p_`77WT|RpSHGMyzo1#Awpa=3K@6r zJhZE@4$b6%Sz;1Rt!06cn7OvnHRe8Y?gQyM3!9GnKuYVp{%3JA_8E?p;6>LG-ee~W zB^cX|WVjvWUlf6LqLA$U|9~3^FyX9k5xBET;EaF32?9(rCg3b4d9sQ><2ELFuo6Gx zC3?bZd_~n1W-2bxV;csG$82mY9z(H@c(lSSNowFRkZfvNjtD{sL)W68S!)`cRC*!4 zlB8$M=!Z9DsSo?M978n8jkIgBBE_+V)}mHnT316szwg*wlU(o*Me=9iMUYcj1bP0= z3W-q(a&4Jq2(71p^eKX@7Le2;h%6u(MG#FRNGU5su(c+|!B(85No6S*`im$vwU+Lp zy^)smVu^KyV{ou2PO}y@w<$E{k-x0#cx$9F1Bx2%#%eZFI;)z2du^nuuo++5NR5RW zvz7jk2z?$Uq+I4co?j^;k)kR)7Jqe+Zo^BywWPEY$XxANTB;6P`Qp+NskJ4z#Zel| zyi<53Cy6e6X5+pxQan6E$wf+o=6sBcWGf`w6gTN-M%OYX4=I#FGHpDha?p#9@{lM# z_#4`JNjYLjFDXfemHbONG1E)jT3*U_d{c!Y#|adCB>FMOg$M!|!<+j_)n$t3Ppu%0 zCP5|#Nr7+=D+Nh4Ma(dWw$+R;36el%k(>GQP>GE2xfmWM{Y637DpjRfEU-PktSY(U z-KtV?!Oc|gqgbS4HHpmnJ-ljlX{XGjmi&25sf@%tUvjw)nN5NnqNGN}%7zN^&dRgT z$ii*w$uD#0FUx#ml#~xN)|`4$oK1W_nc+msjqyP}X#m{j&10k-3HI>^^`%#gxySM= z4JAsa*uv{HmdXQj^~aP1=?8Q5<0(y~T_Ennnn|g`XJ{q`vMP1>{$^4=3SMGiD`^6W zjR~!#$;|CHG`5j4Da1OXjZ}>V*5D`FNDCOu;9c5Fe*kRa(H*6cGR)@tx)4%WWGQ^x zRr-m_9h0T?5?R+uisU0SPl`kV?Y20)r&OJJ*W{afN=`BhEYDB$ktP8df(`mf4ak$h zS^Xs)*75QKq%@gOzGMiEHVlnJr8Ug6B5oZjwHG!{s^kvBNEs&8XZAmE;4o=$IXf4k z$g`9UDn#V`ELv2gq>oh4A zM)Im7rS-tazlo>zpC-WtH25tGrh0;U`+Viv}(gs;Q^Q?;@|91>n zDOD!wZ?}?|qXXAhN+*end56`+#gN2jt&tita$xSPlPWUjNocp87=et|^%AAA9>AOp z(lrVU_1Z}1LY+6#ysYYdzV{btH&DgUEz&@Z*(Z z37TTR;ltgu{L|dDM^XTeVTHXUi&yc6dnIyD$^YF?r$YCI2c$6Jcps1kv+|el^Z{ug zMff5PO2b&4i@5cmbO8qN@rNW8fsL@bV{m4&giC7 zR6XiA?LQ0CPD>M5Kr;VwTB7d-()pRQG&_@z@Mq_wnLw&x)CJnyXk2qaN@lJ}Xme3| zOP>GNi&6n&#(n(B6{(XAvzgE1ZcAo?s>^q!RHn_r_oK7ik_N#(DfrvJ+Fi`!0LT2f~$+kRbV~uT}&p?>6e1-O2}*A6)!9ypJj~A zg=bu^Ah!jFZt<4Rme$m{C4LE#Tal^VELir3;W$D(R^U>4Fu(5nRIp4= z$v6HsL@vi@*G^&b@Y2icb|E=riZu_T^d-xs$34CzOiqDP9v?{r(WejDv2!hfjEFku zR88&%!+2UXxd(&8{7wxy76eO0$X(zppA;c?m0&MEtSuk1*-(w}K#GaNn33{Uy5dc$ zBQFtgu&;Gxa!a0LKosG80k(>gBOI1iA>weM&;#`d{g_W7g9jn6d!_W90Ji4x7cu{x)a2cct{)43jU0#KvjA;kJuQ>6?idv-``O&=W*s-+@2(aUZ^xOj)OA`Bu)^O!i=3y}rvTP0 z0tWv*uEm=!)eS@9XxwMX)^RKS-PK(X-%%VNM@PO8*T%_X$uB8iUmiim{^I&_Ir1=% z)R#>*9lMH-v8ERIHeN2HS+-fdE84{qO_c14q4czQ(Z$-PwWW<}D~8U)QSq`#P!m0D z#ul|`XKi8GR68sn5DV*q_6=x|5=BiqTAGw_7K0RYwho+R?Pl50aU9!#MqFA1>TGRp z+0Lk|)scm4bQCFB2=c3l24UbHA3v!7QjDU)ff!05+7ACQ^DG40x@be3gtY+|*u6X%?k6aNZ zW8*$@S>_pmz5B?OrHGncvF@-KCq?9iT*e)J_u#&wc4X>BV;X2>nbPS44Zy~)hmmLYEy7v^(`O5rU zmYho&TR35+d{{{B9NH4A^9{GoqNBge-Dk@S7_0FY@;UM^6#7b;D{p6kCDC=B>`R_m z?RkWWIoN(4Er{ap^W>VW%qP4qfMgBKlk-^6M}7?DMJlWFEAP5QUZTJfUbs^J%(M?r zIveuk4E|${e2Vg4F>jsxSU5)OWlu7h&#jje9Irm^Y$#YJgqFK$pP-R^cA5uokS|KE zZ|@Ok6V>I#xZ4;kSJAHYAS=Ofv)ll3c&E*ztXSQzn*=K3|b3Mzr*LcfI@<*VC-Ut+ z$^eboHR8U3N@fWP6RxYFEOu)f(V3#7vF0`|S#b?4&L*+55NbzxmvF_65jT#ismx(@ zYM?_ceXYt?Bl%T|yoJd{Lj|ChgTCpVW zQA{mCIYJpfb($zknSB($*F>RA-l}!@-e$@KnhI+*S8Bm7T2^>LgisTbP^(80^fKlGXB|4@hCT@nic)2ZHkWV^<^?P^0K2CQDl->ZyyY6 zulTy0rTXkvrUqGW@~7V+(=*o8PC)Nt|Mp5gE3v~=r8))HXH8X1lufitJT~L4skExD z2w6&Fy76n0rG%3QIyp<}L066ZMV4|)W=;?J=^08BpsS%WIm&cWRjYE8(u`I6%JlBrdr#^Lqa*(nk;x{VGTvtEnWRbwNg^aaGV50D-{8Hn0ZBl|5Y~#V3mHFU$>aMj} z-TyXA$|vXR&K9K|xU{`vh0mc_P3KMqGQf~03O4!_)evan_Sdj zw`ef`KMkH^ot=t{+m&I~nJ)|Yvj4#M;2?tcTvi01Ea2<@1D{d^cp?Cs{sS0L1Sk}M zt^WbEE&`kvfF1t<)E-oKEZ$&O4#3AtyWX zq++H!&C@59LC&Qs{hw}fZa0g~sBax3W4}D5x^2x3)}y>>hlv{%M?9RT9CoogX{}8B z@A-%4kL2@DDLnyZVBu-Snfz(zGbF;8{V^PWme{o)Uwu|NA&G19i%JJpW(Ci?NRpRD ztVgHIN;F*|wY{wLg)?~UvQm?kZqExZEA<(~^ZHkbU4_l~n{tBuy|8OaNAk{RUQ@zZ zd5)*ADLG_db-1o{gF$%Ux-#1J(a}!g0xyJ^(E3e9Kdat5hs|#gr&D&<4H7|3@cj+N za@p~_lET7|;N;(xhRkCJzx+EX3d(*ceoN^= zsFiNG<&M$@T5|O+2^SJjZub?Pl{=1G?vqrf(BB_Q9`oJA&;6lzlPuYYuO29!$zE;p zP!Tt4qaP|gS+NcH@S$R|DL<3AmNaNKIy_SPmA*8ili_(ibE+vZyFLg;w$H|ykCad{ zxsE(iTv@60c>9rZlT}}byB{lsFqiLsqL7(qGIQH}r92anwPy;2rZ`rAPMCYkzdcvB z043vZda2wKSz)h~22QnWlONm4)Rk@tEZ=wt6K^UOyi#s6|0O){wNf0I%Tj*rjS>JN z8S*V5kX-P0q`sSCvv;(dWjOJjQq!q*`2QVfIluHy>BEHb{XoY<(d!S&E28jGIOCJz z;yNmfy2P8zZM{XF1l*tnSX|w1c<7T-hOXhRf1>dpq0MJ{&={WyhqEy0v*IBxe?BYu zj4<5&E6MO4c={_H0|h<45e4qWDc_Xc@C%RnuGCiF4k87$IeL0%JAKR#V7@=dSo!UkyI6L(rUGCj1PFbZ)?t!E1)q@mZi*Qg|(@nxm z2i1kBYMq0c&)mE7*(KF|Ky=fzv^ts$vNNUCI99R@mUL7*&`I@kRL8JzXME@ZJPb&yC*nCYgrB4gu`oBEv$zXxU2Z1QLZxvNjy<_)5* z8K&bTSqeso94kB1f%n4wIKT&asOuP9MOSaN8r_*R^Hu{WYM$n;`U(fgTg_&23#{Oy z272GIp_5MULGmJ7&ip1!Hp03&y(?7+%Iz5u64qqO@#RXCBC1J%ZqLgG<@&OH%J2C0FPpP>sz2B}lX1UeC<#xw8sSRz=h=v=Y^ z@oKz_nKF;fX-0FrCAM%Fn+K~)NeaCUR$Z#M{XrJ$XGrz>J6Y!ZA-aqs?AIYc=oJFl zXNq6upejLw?+BXT@&_)fs5-k9E9zVI@4kmKHZkg z3`)zts0?MvluGwga;RC(sbHQkp(hJ01_yKkzZ@Qh`$cm zPfgqv(Lx+}M|>Blwyv#+R&7n@dM@xrRDY;S<#$i(mD%y$;`KLr zP0wp5yt^})UPq-|^=5dfj{1~UYs&Z3RckYF;2)#aD2XnAYQ(8MWeV3XX{hcLc61{( zla-F)w;HK`FcuQU4>nQjk}Jx8G*cHy_H(^xmKX=~K#K&rj%!+~SM9fZimCI>eJz#m zF{_pOyTcg|(Xx+ufThyTlMiXFI)VLack2KnEY(l>yf$icajTKvR(;DPiiEUN%UL97 zdvyZ~E5kQ-P;JCj)y_`p7?YIPP` z8((%-%QM^B=-5RaAtZPg^*&7C{ky6$mdv|kHLm!_inI>Oo)P$J#HDWPMj$D?Z5y;9Uh#cNftj8|KX zHxm!0s7+bbXe`lFrQgoMYCY9vupf)}B<`hfMNhRAs~d$0WUt(7gd+$dAkA*1Mbb#7NB!do6uZSHEROz=YJaN}R z6=5lFI*9lSy6{(n)jf2@%GV85yED2Vu^X-i!ww!XT+IXuNFN%Z4rcBOR!LJ^C!F|_ zWH85?8l)c%5PR75PtoFPuKlN&AfWUADOxx>>z`tXfR4gn)6{N|ht)@_RY`929Z6U% z^_fo}sk%twOO7$>I4RK3iTjNes>IC?caKxU7}(>>aq2UmE4A_JbrMc?eA`6z7-Io1 zad?LM7-sRLOtl7mPyHO{PF9bSi`Z@o38-YOJypF;eCnD-iU;QL_-X1W8T#VU8T8rA zIrN#S)Z!;_&yx%VZ78U4NT{oV1bRz987s0ODqOZugoQO6c;k&~PleUG!*jQ)k0fZ# z=kHLBAVlU)VpFFZ{P&$|XAN3o_yN_MY?Jl})Jjabj9CYWTpaJ>23 z3Mm+HkV=%Xe~{WbUBZzERbS?F8y6o`L&?d$cu;jFUH{~u8bJX{??W`eOy2a6N^z(5 zn08pb&E!73%@LKdZfl?AEshDQ%frbh)E3ONgWo)%j$p)OEl#O@Cc_$lcLI=P873bK&h$(;D-8piUK#AfdGU7ba8K8SBGRJ|EprvD1sF>xn{ zk|v_Jak5rjAb6~-wPVHn_;p!R$TXdbcNHy)J{9v)wTZxj7vKs_YcJ%Lrmc6Z{eNI4OEt&gKATQcQq%qvUVJ5Ad zonxYvck-f)U2&C3^YQN*Aq_rqpJjD+$gA&Ik{CU&zKgx(;VwW~oh_<+8@@1UKY98$ zwaiK%S(@ml3dr%OO5eGe>sbO7#hT*K^4fVyA&>UcwlkZS_`y%BMd~HgUkef8dVj5% zO|70umb-zWxYu8+SSF=06=}hp=$U>(B({mQQkt~C)|v%2#?}E^C(=Q=0a`=h3V@Qw9Cb|{2+sle4u0bi!n7=Tfn3r+`gh#72poWR?;3)K2Jbp z&4=zC8&#&&P{d?(2o*DMafs$lDJFYEG+&W$5Tebc_|(u)?Hz^HdsfjdLLRRkrj?WE zV}%aYwHmBeAJnUB;n0wutFA4Uh)es_)Z9JKys;QeJ+krxZzv*KBvQD@2#|%|8OvAI z)TYx9aA9a|tvp?|wymvQA*Z22B$ZBJVx(4%#6W7K_MR5>Qyp5#YMfq&$T$Pf*U_%B zpk%(Xu4V>X&nkp2GC`fIV0g3^Zn_;RB)#Px@G`v$*|(ma5naN^UloQJ&AkBUL~9G- z0RK zj>c($j1=U{I4zPK{h<0pho>;5zE)q2j!&XrL&I(LiA_A>`Q`dr0uzo&Lv0{qbz9@i z#@YvHz%vuHP4ofDTnuZfg~4RrtEtus=qGg69%x3M-93IVQKOty*#|4M&{`6%$FosclKNgY_er8~`ITT)}n;+)?~>&PNJ@k1+Z2xRi!t+gIN z%RS$Q$ngO#YD;vm3@^3S9*DHdb{hTaO!>>aVh1gk5qbWRqh6O1KZ>!Muj{Nm2gt@bU9|zs^9+}hwV^TvXwy=(6bk0v zP0`X>tzy`{r?!BU==YvlxXj8Ju|{8Q6(!T(?yHGk6L9RO-GeNA-%qRJpE!e9wVn8E zS$wyU-%Cz1OlaZ`bn6o5VxPHPIDWL~``Dzv=2G{mLW_)Zq%Bz&YMT=AD!wc41fG*_TTN2A47vgn}~CR|HkED3{KbF#25eRBzJb;>U6Cc z-9mmy*H9MQoT{~FuJ!Xf3W-}gFV-AIYZ4zS&L^vhz91`{M*8O}wl`}V$~JsTtqAdg zI_xvg|BLjHr|3Cd8%H^ni>DK@Zp16owP2#z!s*%)kV-=6lFae}v~ z_cF|$p=~bnmY@^A8oUjLVFkp3^kJ`K$Ib<}c#E0ZAz+oA>3d`?2HVUcd9V$0W@%d( zIPvJ&+Dj&G7UpU>WL+JetC0fl$NxZ00&8NJ_LWl3_=APo8n6=|{7$4F3NaY=I^dk2 zwIEi~h)3v2k)xMC6J@Q!hKsfBcHV0x%f0y(B5G9`+(pHMN&|%G;g`UR)hqa1~oyQl4>1=4;BcwnmtR)_FgMCCh z#ln8#{zo-0Qsup|!7(k7vR)P()A|8Cf)nY7!-WvvA&P=q>-8x5{By-W4SI+M^dbFS&6ARie!r`I zvSo&Sc%^`_<2(gVJ=1)cw30u6rk#}NmSy`ZEyeY>B^|{Thw)9p|9)RhA;;HREPZFr zhrOX?FrS5Z{!eYD*xq~1%;W|9*?WyVwk_E7leU)B=EqN3i@Ne?T3w7IgXg~= z)zJ_!)Mflp!Lm=OP$UL#TV5^Z#AVB?MM0g!DW5fuhU=)t95aS~n#lUINb~?C|KW^5$9WM(WWltWj^*o*9zQ<8BKE8))*WMd=7)V?@hHJ&b3 ztB+;vF{aeIxLh?l;snh|ag?9%C!=v)F>`M#)UF81Lu`x`?p}x6Y>i%IJzuspmZiAF zOIu?C^YZ4kiWx~^lF4spB%-7bU+j(TNY5A@jBV&Tpo@d?B$+{eC5?9Aw&A6fbVPcr zK-jN^6cr=YQo#s?I&O~cbp#`Ua1M@%IJ%G6i5&e<5rv=R8!*;rj9 z4wf;7!eX9S#`u_m+`PK0@c~d2!nLf?mw7l~WLcvRe8DbdjXjx`iFsv>z5hS9zB-_a zt?Qe!0hv4p1p%cS1qlVk4!~|v5xYB3>=q0}6ct_9ymsd`##Zzy_O-k7U}Cp^zdao9 z!}C5Le=uk7*)y|a^A2oNUoorypp zn;YzdgoZqWK#&kFR{m=Bvktl!3l2MfgwU4 zw>q`-r8{a$T_F7jCON!^)zUVH2VLVPQT(}HCa)}UHLi-#LAvEDKU4$?JIz?P*O!E+}dugFO<0^2ZFb`gC z6{Ca-+};o+V8btgUPR@OuB@PkW|bAn6ffQqtk?;T)9Kh^+{;yT3*vU97iF=69+k+x zoZ#!ey9L^vda8SJ{_d%5B}@rm<~B7hhoyn*VL72JtJ*@_Tu$&az`A}ZT1e(}zdV)& z{ygP{GJK883m2hiPpKfxXJzxquOgNZmY0eGLi|I^YF?Fvnl@Z=t1f)NYPGF_zIN57 z)WFcW({HTs$Rve=D5M;>%-45#GXVTKd#xqhfUG^dw(!M0u_eTxK7RGnN5K)GPrlHJ z+2xxn@IakWM;H%QR=BRLx~b3)g3!{Yf;;r@gH45C#wyc`rh*F#@}fe`(8Kmr zrI~OO3Ucvy!5QlIB`VVrAh3llv=pMPeOz1XIV%bSLfkk-M&ER_+M<<75GLCi2GZWP zz}TkR&9(vr=f_kV*7ok3U!qU57 zp|{ZOF2Vs!)WWXlB;2w0bQ9Y19gE^Ugsm`9o$evjU{xft? z+E1u}O_se{lL5kJYoMAT8Ss`!zR7|gi~2=%l7*kF@J_AHV9XUlgvJjMW-%Dh9EXEU zwxl7$h0pL`?LR_*EBOr?J4)zdh|^w-60RG3C%;d$0`R%m^8WIk4*6a2yX#%aJVw}L z+W9WgDq~WnrPUf*IaVlv$@^z4fNTrJj>CLx(N>HT4j~{?>pFo?6FmD;gz79vqGKt- zFNY;lF<210^zpw3JCUxX3az4#jdx~%c{;Yqb2_X!NeJl+y+=LcR z6}n+AtkVUU%vMsRX+lN5T{BIHVC5Fm`f0)pE{$Xe6Pec{I-DUK=ibB9g);^SN3Aji zYXfKFGX=N;eWx2Ufp@paFiSv|Ir8F{#Z+|`dI1lRS;AEV^!1uqLRF-qn3N@SWVT(_gZ_pSO_-o z5Wyt^!U*t&rNRm3|C~-N1NQ8o=;c6qbZxm%k`+BmY0HI9d}HwCa-kih^7<<<+-usz z6#|?mp3}!wLKb#y(^m^&tn?Gww^|5f;uCtj8k7RTDQiHsYEsKJLIF1uE^WZ>Q^>xHI_lZA~!D;9N+c5f8war5aWAq57%v`s<_rrxFdo3O-N zw91=>seCKo_!i+LKzH_5p%IgA(W9-x6;}Et?fXkef?r1HHemo47PkqNSm7IVdmA7D zCW~!CIKR0a7jV+;!Wd>fM7z6P7{OBzCGHer5I?whr{Eu2;%cH*?#{OmzhUgozGoeA zlf(3pJpl4Puznvk0NdK&-T+QHH_)4%LId^HUL6G*^Og^^dYXU;r59w_ErhFkFX45y z^FW`I{Sqii5gp11pXKgcgw79bfsj9yw{hle>iZ>d>f@yrXrLhHBc<-<;B|?#-C&8} zdV7SStoQ)!_#PqD29|(N2f%O_Qj>#1Dtv#g92Br$jd<2WLWDJD*Z8-vy=1RLi9EYz zblRkFNZo03Bk}*XzGo(Mcn0~qF7Bt*RMJ}5Q+AeJG0patz zbN`}K#{jxzH&E>yA;hpj8=M14o!cRg3yWCvR?X>zfW5#iTJTB18hHmO?6gpf*{r6z zr-e-CfvfNhOj|EpQ*v}O6Qn`-6`#iFO0FWmGho}j>B$*D{5LJ&tZ>lUiI!q+M++Zo z8OLGPL(&qe4X$Hus(m{z1R?i=H~C)@+A6(vgS6xuU=GssOMuNp&G)k4V{lllVQ$Yt z>4cuq7)WmpSVRd|gu5KzuL@(7vOE8M5*|KRh05^Dx+cU1n&;!Qh0;@9`e2^M9~r>s z46Az{)#b<7z^tPi8V^(NYk*PLd359&0DG+Fah>DG0h)0WLe(@a`zAy-&Ma>O(B_l% z9igo9v_23bPJf%3;_e8|n9XdOe@E~)b>w&I``PDPMB8g;?+9NQw(5`H2krr$9ze!| zy8i&uDdKY<2zjX7`cP=jiq|6Hk>KV!ECZcxWRqsc-4r>5aW=-g?NE!VJ_11nKYj%2 z)f0&_gxYX2RUZqUuJ7aWO;(@rbjsf$7CD~F>G0`#EX;x{t9HW-x&r%9jpsr+8~BNg zcr7ev6)Tcwo^YI%uRytZ5X!Kp|3-LZ7)uS`g6Y4f;co?379B}*-(oUW(($*TKiBE~ zTS#n6$o-w*$=sr;$~$2==*zBm00Hay^!%MLAFimA-b0Wiy7C^f1{`WX2-w|160T3e z8WuR0ay|)t`L@|-uwCHBXQ3R6n1kq6VUo?-tVAp7^GR@__Fse=kPVi7(Ph9lUqG3T zQqWg?)i#Ujd=*-`)}5`RZIDT8Y;V#AC?;)~u^S|eP{cCq|B6o_XVy1xrL$W4H!x`s z$I3s1P-L5IZDmI4lpjJO^UkC*KY%EY$@~K|QE3MK^%LmgID>Bd6#jx3o$*UZMOKX+ z4kFY~$WR9HPwrpA#FLDrYcH7i0QpJMv~xCMhAtl!5-Wi7%qt{DGSA8MPa(0ZVb|&? zJM0xhG#ABO8+cTB8Aae6+(%5J4|It*leovwYOX!bI4SQ+-u7Z~1KgGq=0z)iM=#U?xpLt*hOGfk(1MZ|Vo18@+Lr=x=w;~*k_&T6Fg%27mC6o<~*b0>TO zdyqyKafnBc!9b?g%rR;0x*Q%D<{S@ynhS)3rT|1sKdF{C#`Wt??jib~4Vv{2MQLCqe zQ!Tl!9%x|!;_^bQct`D0h=?rp;29C(Wv&?CvZ?%F`3!6q};L?ZqW)_S~;<@ zfd#bGjz^0Sj<7jdK^(((8CzBop-^q1%2mX29Br$J0Z>#HRuPX{r#DQ@4=M2PjbqE$|emrjIY+|puPkcM(b zvRK3VTX1WdE+I7bb+YKe8Ps54#|3TVU~#=389Efm@LAh2R4fGBbWz$rOzh5KXt)^0 z!#9Tmc;J9MTr6U6y7;w~zTbf4LEsL05<+uW0R1^a?8v;f5F06`6zX0i(aJnTOCKrL zVOWUEqs2kcGU|*GOZqJJ&DWx<)i7~!AC8s~`(eAqA6{o;F7Knw86zTiw61n_tO$Ai z8I>E4RccPB$BW}xm@_q+AWno8^6~_62;W1jpDNZWw$TTwqy0ZCMDOcp(u zp96iJEc!uq@SGyLGi5ndnIe{VUWvK+_v_re!oQQcj2cfA9ckGVaisLCaQ?^bo>5?$ z7_9cf6S*(BO&S?&D0{RVL78cQ)OoZ$O^k)L|4SMMx09TwilacBv!;sGSztZ7I#o#Kxfjiv`7`pFE6OnG_e|P_M0ZQg=Bqtni#=c7sCcC zo?yckQK=cCD>j9mWQgt9_l0_qRb51#r(?-S<(GlA52j5KFjS zH|nIoGb78d4d$Ek$>L#fmv!W6Qav-pQ1G{gnPLQnG%i#8!ac=if@&|P;L6x8|Cymk@U%oaO?yY-k2>bH)*%@*UB6=^lH0K*{Yb>?75ooVVEu@trn zcFhr+Fw-28=ZYJ6ajqD{+_UJ%T(L3#Here;YqLm{3;@(ce~3uuqY3jct&qF}=8GO~ z*Q~&~QvE*H(7T`Sov9xXVPoD;9p;P08M{uS=8IumTiZBatO30xZ$5_fiF_7dvEEV5 z1)`U5V@7K$!;!Q*bZ)K~48A>o0U%@o9b6zrcn0AfNbWz!?5xtZ>tD*)?$-k!uWVopD4%|fi%O1icXv(T697Xj9aOsDWgVnx_T`YZytuA>=?#2qa98`WGa1~KC| zZNOr20?(K7?oY82fp5ikwMj>pT; z#fKy<7h4*xQm5sj4~zapla`CS9IJe2#d{oUnHVnjJf)^9#1=3TuU#R&hR`u@rFarM zHeFVU1D#r&ZUrwXA-$!-^LQK^b&>->b$YQ%^mlgU_a-L;DM1EcZP(B8DRi2GRs)LN zPSS+cVjV+A?euE&0<4_;*NWG;MzvO~$r?w)4l-B89WBw6Pv}-5SGF=i^VDg;FWyyO6-Y!S;c zhg{mbMJ(>s8+K&Fk%=$)J4~q^xpWUCe!`!Db`dp#K5P-aDy+`Mi%b5W7r(Z=c)nQ& zmiovWUppPI;V<|csyodigJh$vqI;2jy5ZS0@f_S~(r%=EHrJssTSYfk+Dr?#Ldcp$ z+Ez?|Q@XkpG$V%!{U!R^JL4hC;2;&j6j}Z+pgW@0bM5UaeO z3hx(t8U|`3_XEh7^jKSX5ReP-s*^32fj&7pTP!B6>#6s#c(+XIuw4wcN3mcB+tJNz zd}ROJ!(uJ>%h!N6e9w+^J{ZyXtd=Q*S%nh2o4Onp2Sb>=aaimPqFVC^1U%T)j$nT7 zYIlx^cCb>Mpr?O>K0P4$C`j&CT7MK+&`W!GRIFuSPWLDz2ctbt^>e@jnp2M)u_5G0 zEeEgYuHDGNqCj~0a9k94D9+Clpg|9*!bvdfhT1r7UG1jb;A}6PBKRY< z=*nrxs{6=rMqI*N&(iWUVi)L#!ddhrn?lZte=_fbbmlCilDb;!f5b@!7MMs6&xxho zuI>XE;Vi6!K6|YkgKc-nGB94MCb0983+ z_Vu9PtDpy;sP0v-l3 z)}WOc*2lYIsLRdSt*rD6L(eZ~;;-4RKU{IM@=@w}SDeXN>0K;N4h7s3&skqNm`H~P z#kiKoAw7S57y#3TUG!Z!f!rR4Tj{KYTt#OEA---{tqpK|)PNB!K{H1nhE zsDka(%dd*gU94BxqN-#$ZPv z=9n)aqtbe9;TLhJ0Ya1GH{cZ9*1w7VO2{m{V{jkNALF#s-^Agd3PY&Y56Fv1A@V~E zdd&0wYbQ6EKu86Q}xNMTA}0DcBcYIsv8?YSZ)==QWYqZDMA zvAUlT9l{9+CaDec9;2NxNh1x4%`Q9_i=Ot_rIZMIZ+Tkp9?j6_~gGku`&oKV!VtQ$dr6lX6?UvGyMBZ|jrSw`a z?X#5b>!m}M(nVg18Ngq7T>qKOf9|INF4Afy7SW0olg!qpoAIrz_V7(8p5Lqcck1XN z`BRj;G=xRO(?)k`B^3K+9$10<^xZ>R#VRzV6`s;+KyZC8X%#5fJ1^-cOn+~^r2_`j ziw2-9F#{~ehuqN)`bw}y^ri=X(nZLNJN=~uLG_5^9n*W`5U06@N>zC%LhCRIp;9zH zOp0_a*Y4l0_lfzpF{HOJsR|1!^aX?@C%vW(AJ3Q1D7g7$#M)Ww`rpd$AAjYCLEoj) zrKQrKd0k6Os$L`vQ)v=tqSl!jXGNN6>8YK*hiBuXlwqf}X` zE`-%%Wu=zfC99ltjTLKAzLhQy9cx&?jso(4#9bAnFjoAHR;_~ck2NTdeHF&940CwNg zml$c9m=lUQg=7LVX{?lj==36SQV%Wy#7Xet!{%fy=|0qhueGET;0=G*mLd$TwU4y{ zyWH$tSDMYL+@nWzr4>P4YP5p6&}G+_18erQKJv?NPEeEXNg#4LF}3eCDU<{%pZ6Ms z9AVJ)B&RAJ8Wu`IYZw=gpuwTUe@mGtTK(r{H(oy1{NLMpIh<_jOQZOD)|Z+wm+Ew- zzBJgdRIA?r-Gej7n1&p;oT|{ZMiS4l-Jmfbu0&-z+F0^q)|KgbV`)AV;Ym%TM$EYq zU2P(@hofz|rjn;_sA(phL53CbPmr29n=e2z_-vaz3BAo<2odVHs{B8h^Po!thAjy__>0 zYzV9XAw+J@6(F5^X!c4F4Cx#Fy;ADK+%9RQS4rGco0_cwr8=Z#tdX{&cjL&ABROjE z>!qUxFp=ULr7Z4YvJsy_Hl~eIGp}-^xm{$i2N&b`&cU|M9HzT=#ByW4B37VXD5cO^W656Wg(X zu>Wqyy|$FOT?%EPH|Y?r+$z0YDuq1>_Z`wLY!QClA(gZSz4hNMb>%yayTK=IFKM~E zB^+5?_=0wOuQZ&)Ld*S9eJ&F0mufSsbJ{C@h__?P*#xenM5i~lfmRQZ(BAx>+z&~; z9BuROlr3;)2rW1y^(dNlMt`Q@ov%G<;UUSB%4JKn9o7H6kDdQ)JUR39|2)ZhlKo++ z6Dxk2k`GJ15MBN_EY*X_?$Ke;5t!1Bp!Yp!=@DrXwugfL1}z7A{w)o}W;;77HD-mn zQT$P``#Uu9s5F?fePJ zhZ(+T?@viN20-4vGdkqiot4g5GnajIle}zX7^?>UTIZHW3REqn42DXfR3xQ zGf(=%c(^>M>M_faA3Lbc8<3!1+VnS42RrD4uRlxec+VSt#XyzeH1Mm`xYX2PKxtP< zZgBzDcc^^DyfEP3nTNpZ+GrbI(KXA5v!E z^Fe%F`O#BNVJ8IT2m(U5ocjgl2A@D+26QtaOezl0xkJh*C!`f zjsLqoT(r_Y>%MWk3v*Ek896Auh92QInHMeXN8)#GZO|ZYg68hSH|WSusdb34KpV!} z`~&kVRO*Od=6C2Kcy8`~UgPLzen@qHNt@yA^7R*Zohf)uJ$Wg!%9!&?F3DXb4f0fJ zM+uJRritDL8Yjp_#WfFs;COVpcFG_Z123Y-OvYKaWNR&ZvdAC`u$DcTV-VG}mVH4v zdRfb@q&b24FS#PpW=Zx&UQ~PlPGdHB#4C_0*vQ3^t)5!g;E{_o!bWZ-PYlo>NnLDZ zMSq&)1=fS6B+wQ~_M(NhaPq7RbK`WAs zL!W7tgr_AhYAnkqxJQm6`!ZKgs;bB@D><1W9ArnB z^2QgDUBOZo@yin0%`d5RxrjV~Ik-?Q2dv0jt-FJK7zY8s)!hkiG8LtIxWew(%L%vt zp{e|`nbz^k3_6LE%VA9K>nyM5E8~Jexj9f37kMRA%||ZsDo(?T$*WjkVJcHxUI!X} zr#Naa(L`6&mNHQ(H?+mMFm9;5OC#J-8?BO$2Wr8CJW%_L`g`IMLrz|}Ais$hK9)y4 zy-}(|_CB~QBh5#C$~`iC911qc%}}gs8Bh`env;2MylTiAS!Q( z^f94w1?Wv{LgjO?G7k@vLz#aPtqqf_VbY$3$u%JZMuf{BSn(kg6d_-653T+$0g1s+ zj=dEvSBL7FYiao{LMF%QPt(aj8zQN-o?lr5sslXkCO@8 zytTAfHRaW|_7s3_wG%*dI7u^qrj_;OMuslhhx+nae6K1UZ782&iVw|dBp>6Mxf)|g zaL#EgFDSOA5%j70Q247Sq%~=ijv%ajcbPn@+(dR`zCP5t2@nE{-$agLE|us?6TEx9 z7SL1{@$PFB(F}MaT%)GV72wf|o9qs}mgYBu@ zuINQgvg;;qz$U`>ZgNXgCSotlFSdQ)IS|cWe^c@9azM>WrFD6rI5r~MaB~(J)3m^6X@tLRv^_1buxt$vHl50b_nA=Nk#;kqmc`rGO`y=$0 z6P)Ai609n2Q_wknNQOPGyvxXW-dir=;;7$rwA^&D-1M-c@IG>1?zGtlYjTA4^pQQS zAC^j>s{Q1mEI5?j^#L9yP}jb4dA|OAWgnN`w*SBH47R1b-g1yjuzvUdekjV8f5?f# z`pNzfn40&K6IfMG+T2g}VdbLfBFbRBA^l~X?x*$Yk47NTnFHkZtVCIQGe90+XoMT2 z3}kvuk}G(e31DPm=ZA*8}Bw)_mi5 zu>6iWrqRhE0M1ubW~dwmI?{8f+!KQI#i4RvR_Pnn7$%1bm8K;id`~e@qc2La!Z73N z&Nx%>75?Izv}~9hgwwa_^f1|l2}SA2FrBkX!)4vDGhB}Iki9^A_>K!iaE@1;Ey533 zUl|8vq8yGj9zeT?1NTEp(VgLPI4G@YgnST|%zsA6Rgut)>_^JgScnHT9VuT0$t^hw z&v1*;Xqk&ES))N-CTIso%X8sOqO}+caw5+4w+vp}Hl71LwoE6;EtvfpDxD&i;?D3X zSkD-mp8~w~b)~&2av99U>lEM^vLB_&!DD+B2R(`RLkRw0Kgbol<96sct~Rg7V4mmy zd*75gnD2L^Ex-8*H#shrEO5Vcf&0SP{QFXY`$Y=ecgw%ekSY3IDq#L7xl9BI-leG% zk$6{@dWN< z+%GTD%{4qyg-a8$extCxZ{v3X-!$*unJ!<1xJ{QbAQJ2$hv@(eI2iB?;&pLhE;8+$ z4zhWbo=le~1YUF2Kl+DX{(4@1*pl~Qp`~~XMXqs8&}Ph#5u@cHz%vw7v=w!kC5N*h z0Xxs2qIlOVxg3~_$85QxOJ^YgJ4v}6c=|$2W{+{0EC_X{DQPzFa|>n6hER}68)u^z z9q9IK`98So!7NBs6KUZbaK!D@cdk6$G20rexAR(Y4D(}hIo=KHEHV++9uAl!zcZM= zUvCMUA$(AESbRlQ=gD0P)p?IT=TXEP>!LVr5cq+-Z1Vw=NN+YDqD4cpUI3m33cf%N zh4?XS0bmbN^$X+-u0}7ENlm?i*IE)Tz?iU5Zoz5xB77L;V}5}b-6DA=m(Lc zNh{?E)=-Y$uaUn)e0#H24r5m1$!DFMf}N^W>rixlNLSa%rTO>Q%at8gK4@u`dlfsh zX*PcQp*{REcc;Yl0CwaNSTC1nQ4eVMdd!ve1A4w*u4FuVAMHP3Uli@l(?b*(NtIjXhX!&`Gp!o7@ztu4y|k)1Jm` z2l`f{<=a7d%0$z*?VvRQZ?WUa-|&{I<0{^Ilb~nB?M;TAvU8zOJ{D|Z?ZA_>XfrNi zUrURA`7I)O3wWpC7V~{Wo;&f9pLzK&Nz$7bEAS@QEp-F)AJY?dY^RK!c;gJqt>paX z)p+w>mb$_D&1>+wIQq_;ds%J`)o)=FRGXhlXmT&+F^Dc{@<=4nYP?G> zYj{GFcYy`O(%M~eCA;8(IxU`iTy`Ow-53}$%_R8j}tHay43YK=vy;O^K?nU-qo<8kuc0Ys1AuFIRJ`mNzb(3o^6!MxgcmZdpY2c?dd$yuqIdW0$K{ju^fSMkW*Ya(lBl2s0ti;Q|A?a7{M(#&} zGa1zQs5}tHmLo?YC3n<59|f9;pO3cGb@^hHw_A24m*etU7JQVB9G3%RYuw|X@$6*z zjCexEHUx;%NyyX4?{HEMU_q;C=Sleq$o`^JayM(Wz23GMd7cJofz9-^oMv6Aoux95 zSHesFjJ$#Q9io$Gpeo#``6O7M_*+7>YgG589ID*TEy7f!;Z^@eU{J z5$iPXa}d9{(dfLK4q4dsg6vi7b^^q4Bs}EPuAkuy+ZRq?G9RV*3vyu5>c@d~mfIEh z65vf~$gVAiFr^h8xB!w1Pri!~rLe)#?2-(3#yiyciaZ@|M{lplC75kIxnGqRaQ*bE zJd6c4qcYcIGat%zsK{^vzYZuJtS!7QBg$bnExCb3E47WX`Bm9Q4{m_?-_i=-1Puk* zZ+ja6xrPSch6s^NYj0yxYHOEoW9{H7J@zh&7ij%m@T+BX^Dbx<4kx>ZQe7%@PYz^0 zU#ZPKybs5H^4i1N-g`hD;K=R!a-h7h4sZvd9l04lsmTM`NgkPB5t~~nzd}mPuc)2- zoRS{M&a8YL>iGcubg4sAaW#C>);*AW+Av#$nmq;4jfT(EQ>?W8J0!D}8*|C&sf<*j zat+dQeh`AK}0xtz5ypY?lVpVDF3uy5E zOSKa(qr)BY z4Y*+^(%wK(&Z68m!1V#7zQv_JMc~4M%+%s7#AF*YjldO2K^F15*kI-tSSQ}fcg64J z^7o;B(UupO1z|otd52NFqtN&AP0$JH1G;SB#?WA7yXm z5=B!#LR0xnYd^}t;^|1te2jfAP6PRf_1!=pK7tXCA>U7OHopD%6V%d<)ZsHagy^2n zSY;d&^I1LxJ!a$=+0(gc7MRQeK6Lvl%J!xaB1551>Y*3MVG!nQOBv7U(qkv zUB1eT4NvLDSJ}riZx)^`&lzBWCpU-ZkFUo}+WJCv^4!ZC>8T3}G#X)P5Moz7)##Qu5u9;y|4XL^sTbpVh&i>4B2)xBOGQS-@hFw{E zi!TXqSuhuMpf8R}S#ZnnqKY32O4V8vRVErBEZuTaDnR6Pc2>%;LXKK}XQiH=kHSS6 z&Ri48p%|XZ(drgcQVf`vv>59h%^(EWuH9BWazNQUd1ZOI}KCn1I~9l{A+wEroH3zGz48o!nFh5$`2ONSKIHSJm)rnwSJhwzI4e?@oxC37hr23;4d>XH@zpO z2VPwn`vUpw zczVWKaU)3DG1J6Mm?ZF~5SVhpGh!t@ArF!<2P<=#Zx`)Uumbb^D2gbBSEbXyQpy>a zTdIXBC9UlbS4X%1&G%+gLmLsH^fxf;*4p#Z%6bDURGI#WR4TG!t?6>45{8pZZKIUd zzzFJCRte^aRaWt0Ra?^LvI;V*wWM=pl|O(OJI#=h z8&p>U0v6$RxlB(-T`6U%oByhO_kzl~bh*0X z%}VCd=js@@kW0mDC_aY9TICu_7EdvHAx0@vm`dq#^~PE@vfR zrDBi8+W)djZ-dN~eUKd+7=;w^u?miYsz>``mCAevKUS$`EE0<4iAM{7NTE=w9jCZ+ z%V8Wy$t{`~r!0neFsFi;PNKHL$+#8%4q11q*uohNVK~lo|)Th3(ivuO6KnkoU{1CyI7iG}2fm>e@@iYqI7m0mPcic2-2$?|b|c#?g*5*W0jJdkxIxB8*d z?4e7V!s-3plOkSn!UBt$E?*)nF_TS)(IgR&6O9BYrZsBG+4m4 zworWeZhH%*5pdEU-pkA}me#dYI)EL@30Qmh?pY ziI^hn?(}S}G-5W@Xisb91Z1_;Hp&Ce_u2y2^XN=l#f@2q)AP3AQ%}gQozj2>6{QyK zl=FrCPjPZ?O0CW1df02OQ*?W!8BeR2(OxMIbHbYTN;q>2r5o)r{ewy9fSG(tVI7nK zY6A}07NvSTZRmin_?4oQ9TZoiUH+}w9GWU3v1$jcPv50ND z)d^G3WNv3=2@fD!)>#S1M#RO=N^j&FtJ+0r19yqCw5Y4n2YWkGH)R>KkD^W8l!kDZ z`O!_8%Az8*wC+kx&N$BXP|mZ8g0{RTU_^2B<w0RBdMVNH-Yi5OeU-_;npJ%P z`^)HCU&V)6@7Fy0DPwJ+YyLS%X~QCZ(T_n&by&ixCM%^8elRc@?;nQqJCr^w@F&hX zQ>qlp`O(5Eea=EGclj%$u4YVJ!WSN+g+Jn8C5{K>4F>ZUaLPGvD66lKU_E8{{ z@KGD3L?G(5Kfk=7rK6Mu%xx1@84c+APHjh{DYnA+1=~;jf_)r*8AZ4G1&3AP!YXYf zk1>h|bK6K&aOF>q!CgGbFL;t)@Z=cf4t9qYj#bEj6WPXrTzji;TUezXS!%y&xbBSp z^9|;KCow9MHd5Cw?J0A-67BwI27n{kF9e1soi4=lb{30JZF)Q>{@Q6BKvH2lLS~ zMUMg3-Sb^q=N{CmOiEsNEKdJO(2Ku~9i^^2$GUk3)8$U~#hK%}T%u<|9LvOd> z0Ycn8A}t4Txsh24k4{*h1sFs^s4S(XB;CPiffwwK7BWW}k1ZLMHWNr~Gp*qt3bKE| zF@BzM35c>{zOoZiOX~$7aG#tM`87q`6FbGvy39j3no~^_~PqhlG6dY|glQLH;Nh~ad ztk)>%0NEL9lovdk=IFKHJvhsItj(#3J)2lTg$mGug=om zYU|f2wHZtb?>8u3=tR+t=;AnPxDhw?1ScF5*t0Q=37GOOGV;W~H)&D?VWMiNm7^mcg2t zo#H5ZixTVPmED5NKFIFzE8oEpe%3I|&)TBY;p@0X8Nr+?Qo>fqQ1Gqa3R<*)E^GxL zoTc`Ep_E1Q{!${x#&DMdq?<}p{NVQ$#k~uT{ibh${N6ObAWkN6JICzAZ^L^wBh_!C z1@)~_m6870(xg6QxmdsY=9fcxtry>$!h`kwVo}@Jd=<6$5s&xlwyd0?34T@?)BMiz zccC59$eFk2w`qeKD{02=xH`MLGb9kup%Rs8PU8$g!ZK10-CiQV84!zYzO^!il*CJ6o0C` zLmA0zp3t5hkTo9DwHg-c$G5h|jXYErsot(X2sS#YUFJ{!On&D>lb8G$u+JP^%0fgnip0%CNln&xHW@E3p z2f(!u^?3kO5RM~!lmpiB7hC)%pMTIn#Sz$9`5?LgPlJP)fo$!MgUWORT&@DM!Cc{a zm8~=Z`COT;^aL?B9aiF)O;2iZSn0`1oucf+_(CsweHeneu?N*ZqGTZU>c$ahU2u*1 z8}B^{S0K<&*wBwckVVSIqX0`JoIeT)&-plAJ*ou3R&Y#NU$SeL1gmb@hlFlvwG3Pw zW%=T0Lsb8_I9i`BA5#*6;Ndxnv%`tb|Mz~5mYAc!-S{J|J^_tpq;}zi($p4s?Eep_ zBAk)`0r}+~*yq4!Kr_xM)mc>@1c4$1g!7;zuo9dH7tN*)=dsFg);y2NKsw{|&|gGo z{^vpFAV^<;Y;u`WFMy5Z(8mi(c~<# zZaR4h-@?sHN*PaiaSN;R?fk}?)AL2eZ;P;?|0YI5>e|bo0^W% z09_vGqh!+J%gRQ;PW>xj4ri#(6~#|kxDb#CjT4ZFINd8sjG?b~?+W_I?3$A6b;Z-+ z?L0t#GElIlU-ms+F=(tcxUMwidyY$PD8bBo8=biUfbU8#Zh+Y$wE8Akr$b|^dK1DI zwp(vPPl^7EcHUG%gM`08xD*gB?!Z%#@bUlXizzSMz-G8;h^SHJmQvoe-2VJQ;KaYb z{nF00Zg=GOV8&60TaeGHZbi_BGQnim5OjxU1g)X)7gCd+k~6iujRk`H)orD?&x!_? z2JHC~&Zx3}mum>mXYh&?+Id@9VRNj0g8sA;^loMwQ%*BEvz#02k6EJ zh%?&n17*u=6!$>c=2)#ZU^6BNqpP2CNLNKeYm@R&DN(N0PENE3`|?{@Y@G}2egWcz z6${3_l)oG6$qSBj%ha1x;`@q9W9suz`RTkYhKsFfIb#;4$GO45+krpjo077&(afXBv@seS;nYpHWPoDrd;5h0&MQ<6rFt`|LZZ%B{;9NnD86ZezWq9 zRa!xRIt4saLW;~^-oi=`wgI~c;;a|Jkk3Gj;b8epxy=>t=MWiT zRpu9v$>&NJW>=M5Unl|0RFz_0pc;){fSTix7fKtqxJi(RV)TSb7DxRusNqC5c#>xQ z5+K6UjaGOCM!eakX`3M!G!YAds_;E!3prHYLhLG2n4t-W8@{!m2qEv#G zo%#jeen;!RD1(@F1bKdiLhC)8+J03kJI)%0p~vV7@?`wvb2pYYeT6>Jmh!%WfK(nv zg}(tzuTqO|$|PXo?Qc-hVRrwH&LXAccfe3#P{99&p#e1JJ1jVUq2%;KX~{MI9kImkoHspioU{IU$t7cHE z^GE`N+CY3VAit|HUotf$A}L*$jClyX`2%k8$<54NfM5SZ))bsTge{&8O#R2OQX6Hh zN(>hN$+mcR0-dl`&%ld^3aPWX~}lW*Ho%EzT1XJaB$e zY9|}$H8T~}6GFvSMXe`=cgycvP&d3sodv!+PgTPqd7M<$)$sNjXjH@O*LT4@)U0pX zTvJy%kxRv>CNO6=l1=I$2zp~pDpJ>UqWLDZD;)4)JXI6lG)}n}vPX!kpB% z)=ulM;r8KO&%g>Q;tZLwUHPL!s9bS18W1p`xZ0Q-?Tf2Xz?DzM)#|P`qtNrwA?bsI zka9Xj;6wpOzVh{aM$KH+ss^0K?5aM)0cB0Kv7YKozJpfSTW!MK^1addrnKH$<$7CWY`SMw(dQjJ_`3h|M)nj_UAI&DE`5J8slfm zB}kGy8El;xX+Nk8p(?Fpv(U1RK9T>p!Q*2-RW$A+Kn4F0}=685$n8% z&s*+lq%H-u7Z!cYkEe0rLLCsPSU0*HsBQ!8NejZr+tB$S)r&_M1p%^|(uisVt3FJ~ z(Yghz`wXmP1M(}Sb}G`XLklbO;2$lmGPy|#sDGAp>Bb3r9o-+3zC6EQ0+*y7ONaZGb7b-7Tk)CM4~nFYDB3}$Z+~cS+yV6^`4be z5ksNI)BW;lY1eUm#iZm|K8h`$3q%EB6ktphROh0rn*qmC-eYLIX-*1PX{;!*g4&p| zU9_PBKs=9bS5T`nmPcL{)hd|s_7&CohU(geifTo}*sf(crLj-9*<#5O7+;{mjgK>? zK!q2tC|#gJ2Qlw|E7E?Z9Mbp4jrmmuGk?H^O_3?;7>sDEX zOT+={T?I&_tBoI$P^>SLApw^WlYvkjd*9Cf;poY7S_{GN?oAUWraun}d zNk~~hE+}J{sB$Yj2Y-=PKri_JwNj&e6C1Py-5RBDU8l!H{`**!%D*2I^v77y22?5$ zaCC$kCaNJ2)JG<&2bf)bs@Pg>20Pr0)@lMa;Bj#!>o#gB(Y{{3ri%kT+hCQhQm-~@ zKNfwKZnRO|tJJ9r3tyVE4M=k#7{&|V#2XgZ?^$9kKb7%rCTy5(rSM#zbQ z_f&pOZ@osziQ)LCw`ql%@jq*WfBlI4^m zl{nUZMODf%n|z60-)=Ia22-HtQCNj3!PMC3IF2dl69PdxfJ57M9(-+;yO(BlRCD11 zFshTfub53R9?j2m_IH6NA-*-~3=}~eN@w*CFx3)W)OO{L8vpMgx9K$n2f0+QDLBX( z+JP==5Vkvl$lMi}oYLO?zr6FLUwbvamOAA<=!&2?V*kYA-mo~4KR$J+f%&(Ou5-poy^I4 zFZDEpj_}^N^_5!oR(pVZAL^|Jg0-7_tHW7ETk6~gH*;ueA9Xl-X46*PP!F|2t; zOM46jOXH#|)DT0Fv%qtZTF!3nON?%(6*crTI8*W5XZkEDXpJfVsc)zxnORstJfFNEDAoQunb zYx*t)0LX78{hX*~LmxaeN$tWyR%ii}A)Bz^W%OwZm=DCkG&RMYo;K&0$-P_jZApI4 zn#De8wUm6Os;8Z*n44Rrz{X=pLEchp)5K#i`Z#>8rqeWjni^ZUJF3gK_Z$1WdZ>0~nrbu@&YL49rSN>;P-{2=SVJE&)ahIhnK&JN zJ45y}RLzOE${hq8;7yL-Z_Y73btwJF02@Zru9<3Fp&CD$TbY~CmQ2-?9hyVuGu2qX z$@h3u9v%@7^1zQ`=Zb{I;P+}Cr!|gbxD?|qr^ooEjkM2+3Bl_+&Qu*);5`~TQ}u^F zuxKVkuPoX>Q;lb)dE_ulZR}S5E+z|5k-x(@lK1Q)kE}-bHqqEwY6J`*@Mct^{ets?u)Yuc0r!3iBWp9P?Zo=eZN)bfRX z%t1FDsBt9opjva(JB4ySVW3wicrK(y#GcIstGCJ`A5!C3)D7xM>KHrQk7(jJn_iK6 zsOZ@n`nQiI_e)E#;d6ja?x7=psQo>^UT7FLUdEoy0)`qH<(sA z>(HBr;JO{O@ejD%l}mXK0e=U{=aD)W-WajU5!MgV?6(Dg^vgU8JA3sH-YAZ$2Q@1xohkuh_$ zi=Wk_Himd@-Vb#&iwqK6KgW z&u3LO`q>3f!0O5`DNi&O#|Fql*%-z%(JJUB3+So^sm9XQ*qLZ;Zw$e<(G+`QS!?ds z=wKXaz*$9(Mv*ynaFRIJ7r3bbK)@-mIjE?X=wzJA4;gvvY^=rkmy2JhRasui3_w zI+n%3&=8rVFKi1_KY5lS0tLSQfjNs+m0mdFh9j*WORp9LXjV|7|@B-K> z`J9?>GE1`pZ_S~d1B@xyfvb>YbY+2zS|%Ai-3y^5Si>aV(3IK%c%R=1u3o}up9FYX zj^u(ySMZ0ANk%XCZia#n9D-Ezp9kt{Wd<6LdRf2!8c&2Y7j1NbMXOSess))`m|s0g3^KVgyLvP<$m9t@gMv)%kV19@nYtJ4P&eMH;N0_} z!FQsB$Zdffq-nH!Pu${j&JzHeQdj++^A7y$@Tm$md3l6bn&dA_&)-eD z@Fw=Psb8?E4b+=c!5H-1S`-m%D(ag&go~%cYvsQ?|G}OAwLERfE5tOEsl#Yqh^Z8e z6FDI!#!M-(@u2D9Uir8zOUYL+DJAkBD5{s-isYB-1FN^(Mx|@N+a~raZ9O>UOH_lwbM)IETzVJ>5`>X zgXC~ionoJB@K?V;WzM8iA2;tCL4*lS_Fgy^&W? zeyyOFte_6^Heajpv1EDYmtN?l4wl#5q5h>!uG}`oFRN&EX_I%0RK1DWH~)bldg+Cw z)I%@5x0Dj~(h|$!*VjucETt-XiIYaXqt(cxjH&k6Csomz6i!rl?KQnL&Qdz5mpBjL z_xABpOdI}ltA2x1dtO?um!d7DIeKZA<)f4JlJ01Umc#WDNBEqW9%x~e7KYj`dhI^T z6D{--M_m5y+Is1bgzrlu&92JeXJWlhL(GEbWlZF*(E zp7YQOrn0b1Y^q?YYyqo?N!E(hFfl`+ z^Ps!tdzyEQDa+bG+RmD$LGaHgNx^kY9l0}N9n%aJd0+FWYl_k%Y>qAa;tBeZCIpj`G0i11$b0P)IOd&yHNsr*P=jnH=FhBE-_$(1cIg%D6S>Al;Tj_ zJ-7|f7H^SKtiV7i?ykih3PFpz{NJ(@>R7|zW5i$|DXDVOF~gwm8fBsFm7w5GC;1c-b!_nV)nIG zA<_*0y0ywe0YF--zG6`he!jJ;93gtzsJ5~gJ3re-Wg%3g?t73H;hs$%%3?yAyk zLp*=lLuDjBum}18@hp0%z9J8z9(Y-Rz8YwrjCC(nb2cir z;08Ewp_i&q3d`6nX8)|pCFc3<3e^sUvFku$B6{Eb$F}<0p1MI0`2YhbFu#E1Sf#2E zTLQ&krD-};dGqn}zcSiek+xa|wYvL|F#M)M_>t3M?s^r@a{`=olj=)W?oY91lgg%G zx>Mrf7S$dNpo{a5sg^0pJLKC0)x6Op)PPoVT%K`D_aJrF3}Sx`zON{<9ee<>&> z5~U{sr87~Q_lG$WtHP+yc+?Z3-Z@qM2x*L1aYNNOGVaT=^@9|>%(cn(_%BNhrZ~N< zDE3(O9Kn2q`iW{iPFk7E_df^MfTOlvs8lMp!N$Lcmd$)ew5;LZDCD}#VG}zPvJ}pu z6U6RF83#g~7EvmBHD+d<*sqq)DuBM4rM9Nvm(McjmKGRg_&jvtn~kyu z3XFS3{D>C;6HT&HuKP{hpa`n1kHMwgTaB}s(k}pWxgr|-?0}iD=vA3=~FtqUB$FVZ} zm<3rRZ&WkhEw*AdpW0OJ$SlXjho|8zC}S96ap)rZm@k2^ z?;_@PeFy)rj|Y@bpF z8*1LrQnalGwCERjy{U2|LZ?iX-Aw&~UzsW=L!DY^np}$HgK6kI#BrL2j>r2=!);UF z^DWb4FV6qvkEY>Suoh3p2*WWF)8%s*O7aXjiQsxO_X|bH5VC*hJ5##$Ka{N-c zJ~Q3nN0!P*;k__-nLHQ^TI_Q9t&$ZP#C5CWnbK0RVwEf_pjzFsRyOHXm+|iNVG_$5 zXl^!QzfA1=FZ|hB`GHhRTwNz`CO4DW>*eCbGcKUzzSn3;p|tAZSQD5>u(pxy*8sANWJw&f1>fS9i%#eEwE>4_r>#Y?E6u>v6t+n|u=E ze$IBe5B2O0xej7OwB8}ZcGf{`-YLV6TRu!zww8Vo6?e;>7=6jTvYEvn;HUS>Rv@$9 z@5Rsnx_zJQB?Iz4c?s!T_Q~g2+&+G0zf8wp6gwa{mJmw*fc&>a%8f&~63UH3@;0W( z<+ToDCf(y54$JqYxuWh7`Aq~3`g8IuHH-L3+|HM46oMYQ#0$J9jvRX-XB8-VC9WZ|S1mhtvpn}y|gg2uEk!V7YpmUJ0GGq9<5H-%I;m@e_cb*!G1Y-aRD>a&L3|0Hb z0F`14gdxEg2vfIWg+}pPVd{I#Fj5=~SNB(@rM1QU7-^mjmJCotGWrE{IPnD)WHI{R z6|5~ESVaA`M>C`j)zFp1sARYClhmHbv;uNLfJ|z`@q0x@l1g0{VFp|B{<1n1p1%L< znr;Q;KiA+;GFe?(eRrV0(LeGLb1ViGN>C!Q^Zb#x+9Zz31=c*yM?Ei)o-Pp z!j+^Rq9U|pn%cwEjm4ET^#v2l$Pk+vs>2y`rt#g4)vaI%vouk6l$whvP1J=oSQh7X zR_hU<)gU%}tA2>EgM3j}^-c)~)OJ(1Vay!Q5A{%QrT6Kn-Up?1tzPO(=qB@eslN{< zq-KA0d+BR2xxcy)4E+520qP%VKOLwJgT+i#9HRb_vBHt!#xQkm5h|FX{*#f$X}Y?d zLh2%h%u*wwAkO`qtw!|6!@~4EMiMQ0KdQ^g5)N1SRgLI?PztY6?^RGl@Ac}k@Ub7f zUhSe-g1>B3ua_o@T%n!@7^--_iSAZiEcsoH__`-W(LdB1;N5gWoZhNlr9=eP;k(pF z=pA;e4K${AqkF+B>{h>!a8BzUHGs1X1mCNM7cX9ApL#ScI{Vc_=t1_YSJR=fbq=Z% zCFwiS=a71jLRu#>kEy#C0n_*EWz0+3A+D%ngIVEfLVrt*-KLH>ep_8!VyTtI-+!rL zD>%gq-Br()5V-HI+EH+xz4{t9nl<_A;;guepU78J?2d}})W1uJfpkyJ8My4357mf< zk6;=P)sw&`RDOg{jI{UPYCtn^6!}v%I5JG@7wQr$Wsdmc1)52V#22sBZ6#J_mRR>% zy@W|Po8_H4LYbI1`71K94}^{3^MjvBr0I138^44^7H(4Ub`&E&sZ$l$vNuVZD$+dh zS<8Ev8o?O!TebRO~uzusMJQ;hyJXK zvN!x$FJ;gAvwm>JVSo0Y^HR5hqOBWF#4(zAL!zj1L=YfWbXAz2s-`NS-ZiGW8UgB| zpPKQHio;LM4p1lj)EYY50C(Btr`89k^?vF=fcn`_9RW3L_lc;WBK`}ep^%I#h~^xt z`6C=Cw4sR_8+fthlnfE45;cbu82Ue2H8?k=hqz|b)W-HKyiUzfMmE1>O>0)>qlj{A zt|}mNzbv6?#ZL4PjZ-v;ymwrzO4W3uz{m;d8V9(YoODeV)07bt(ltM*DPC$-&0Gt! z8^qpkHM=9|TldvGle&w6{WQ-hT5h*Nn&vD)7RLu^;=x1}77vGN-iE{>1T5j*ON|@$ zp%C26D#g>6*?B7jw(8GgG?TE#Od6|+A@uWDP5-#2_tCl;T92SEoLH&6zxCaa{8l`3 zoCXM{d_HfSCN}l2yZ_wP-+}m2r>Ueft{mm>MD){6l#Cliok(BuH*tTQrXARq1-wq4 zhBE~d5Arm!QhF*rOx8TtkhHr^s zUaKjrV2bZ}!g|eQ*!)(n*UZNNueCvAVA3GbO=zx#lQ^+c^F^5SmH6SHX1|26o^1|m z?9fe5I;=TPN{S;ICn-pdXv(sro#NmT%?d^AuT8LFbT-#k;1EjUCMnPZ+zaw&@(Cw2 z3!t<~KB;*aj0HIEoaPc@*S|W4_ds0a^O|zO(n!(#iiSsk4|;i5bAnla68rNtkhE8d z3ima46ksoHk2U>R$+CR$W6k&Q$14A~=4+A<|JID4b@Pb^ptowt-X{ENSMDWfKZ7s-c z(?hffgal`UQ0@1$@-+z8Dnjt|O;p-_%o{IEvK9g-9EQ}|n+P`{VszRpc;tx2dTmW5 z_K#(;TKM&hMkp!Ns&L;;)No{ejJkX}v6_n>brci^%|n zBte^qgOO?_Xa@!}V@H0}tX&N>>Yya8n|8P)P#6FfE!0P1kVShmlp+kcaYx7)ZmkK+ z?)PrG6GoK>mmCubUM=DR?-aSI+D;_89Zu6u2eaHFU0aesm+82M^WW38hbi)Kh8CMy zeKEU&b|9n35S6q)O3YVHtgoz1S29H<{-C4?YHLF5mcG~a#JNtQ_mA44q2&CzMEh1r zZ@j$VjaO)G3h5_N?N{weI@;ppDs2XF39Gf43_e&L)@ny!3*nE}YKuuYkaC@NpOVF& z6Q?(79T6nd?$Fi_4w<*VRuHhV_4eTb@KyF}H?y#P{LX%DD$TG1+Vo(WDo3?0C4HTf z=*6Ra!AUfRaB)hzOaf^*qb-jyn0rQ>OK8qB+9lAXwEI)LkQ~*+&S{6acYj|iXyV8% zLD0a^sSjA3*P>+HlbzQ?iFh#w#Hc61SV*ul!AN&b`>TXtc;~eTBx$>FU(_O0-UGod z;|B;4bVXZDg2Z-38=+tszlu%QwK!lSc_rU@Lt9_kD57s_?}Sia=WFAL8^5RZN{dC# zJ#Cz__}B$_U4-!S1JF*yb^dQpgw_xr_>uNcNt!7d{f&XaVt(LfpK6B!x7qNSb_^@> zJ-_};yPo)o=US*9=JMmuwM7B&6_1{44yA}(6*EiZN z)VXglNroB$@wa|M& zn);xv!HP{4CqHPLV5HA<=>{@$$C)dDVu8dZ>1H#{1b$i4-Dj3Oet_xv(Lht^&fpMB z5gn|n>VL8jotq-Ngy?Wi!x+9kL^mIZsd}Nh1H|2i>8#Q+Q8`REG?-b3^3VC&SQa^y z-z==NOE*Mh5nT^P?7pl^Wxhdty{yX)eK`;vs*Dq#WSxSJPi0!&4(8~O7z?^Y7TjOl z)9S2BFf!^G-CtqSEAiT(>#L+yI7z1rp|S1MT~}cZYLKa$9YJ7&%DUsqP4q$H`SyT=NZ6Sr#VIwO=guU$vCgKl0|2WUI=4fS-T2z=V9zODuX zW6U=-)K!w2iH{9+{h72u^lhT6iGbo_e^XsG1uI*et6S(=#JbG2Xa}w5cQ$~V7>1-@ zN3focYoS|=VV|6|}hsmN=oQqZQ@a z>3&m^1l37bQrayX-{`JOhyhaQTir|wrtz%~=>89U@3-iB4Dv2I9J(SE=a0JT{4UYm zblnoW6~pTf`MtJ(lxA5wci-~Q9{CUZ1`KgGor@WZiKE?g11VB`P7mEX2ByDqZ{2={ zv_ll`M_&udv;n#zh^8YZ57gZVflFie5jvwZT1+3I!<23;c8t;0XVN(lHC}gyA!50B zI6*h1FwOP3_~=#m(z!Y(i+j$`%+VmQbfifMH zeP2+vEKn9hWn&7;GS&nNi&A0Fg2GLKG6R*hC@9+zC^J*p7h=-yIxL{`c;+9vxS}Jv zg3kf=4et?n=CKo?DyEhlcz3jbhJFH)k}3Z+3_Rf2*@1@9R0YI2?h$y-@jnErppT=A zZ*=+hR{{?>c1fVcKB_9XIPjd~mj$YR;qI-vuYvZNxK%eypd>7rtF1@(caoM0Xr zsK<-!(sl5kcBJdh(hu>?yLCQN{q5G}Q1q5Px)el-?XgGq7p4LpuJtZV!51)Vis|Q2;S3#MxWA9ul_v>VN6FhO)GU;`fKTF%m6gk980qH;c5V zx&%f`)^n^?;4UbEsP!BZ6_$t>x+KzaywD}mrustXWsW&w&kNnFP?j>4|M5Y$kXXBq zsD`9S39v#)SmG3Z_@fT7WoLatA#`h>a9bP={Yh6IA$=x%!fNS1099uR(M_%ybngmJ zxU7q%1?iKnDEa7oMtiuUf7ZpZq+Y!7XI(p%JW1^QtXsi|b7lHffY4e+QKfzW#gCdD ztoOkW;B>Hl4K~n`A^M6qy=Z@kK9||e+#ZU`t-MXBei}+&hw8HdzsL;J*CRl0nEn=g z7JG&3f2HGQOojAYm})q`R!Bb_sIOL$`l<8@BK2vcoGPq064z8%KM9?3v9SJ6l0u8< zO9RAvzleUJbW}`G>6J<-ai?nasm#`&@6+lHETq54*XnU1L)3TTe3X7LPR|q#cV#=;CcIq*9rQG!BB&aO2Yd~zlt3ey`3>dTk*iA$FdGHi$iad zq%-16rylI=UG7WP&w*fcCRx8og5A`u-_GJb@KPTAM0l3&^We3Q@cLeT4p6fTym|?) z?qX31eI2H1RK6xe%71LmIb4yZPlbZHWSYJlvz8U#rRkU9c+QvHn4w>kIIave{>O+s z092kI!3RG{!s&p25&TYu-VV60ToMlo^<+uh4l8I$eUgMwkR|aNh6emtNqvSczkbai zzn9v*Gq6sQ+?0_iVoK>DfmGnvOY4V_uEVE?0^&z8GE)zif&+Y98GU^cH_PZPP<1@w zq2=@ySlAY!x&{qbmA6SWjkF)%U=33ah3chlw(+8lLMlZ&DqD4TU*q zIa++5qsLx5i*NY?Z7%c5HT1KGen=ED1#UErT8&NvHEbV^Xu92Clo3bT zho5V#PxV#&w+U6I`Kf=JTKrT@qk`v%@l(106%orTHPKgv`|yM&=(~ktWfOfTiA5ae zG0iX!n)9q?dIQA5md*4jMejx7`F4yOK~I9ie|ptG9I1du?lHc)nZ6a+7fo~h0R_al zOS$@VCRG#a*81pp(jW}hL$9?%BoEPdkwU&IToduC#KNKa=@8<^qz~8QFA9Ir_=~|` zEdJu~7mvT9_$!9L;v#)`!iOAbi%2<|a92Sxz{!Mp5;)Y&rxG?{=jm}e;U*2T`hOeEXF>S<7@MygOhQTZc2q5nh0 z2P$cds7Bs|<&pF_!E<=OiwRzAQ7bMc6pP+4yWjz6T&PCArAyHWXGB~~I7;HgrG$pc zV%4W-2aWh_=zXtU2^<4Ea?2Wg!+^-*p3V)|6D%;-SG}HaRr-!wZlFghifcC#{*?5c ztK#5uzguqDA2@U#m}q5wBXRInLOZ|m^RI-b3g)TE6YnL|Vvez**S&-WVa)V{IPx?B z%sl+-U*guMMa`E9!=VloCtoLE@**nq+k`dPq(a^$l!qm(%DaS1q2S?6%+QA^yYjir z;DDWUFEb=!-GuIakl)y&G<+}J7m8p5)?t7eNdp5A7 zMfi=PhKU%9U5go(DrrEN3=L^)c1<$$R8g5AmV^z2#!iB;)h;BMHsB+N6|Hw}KR%?Tcl~oCK8^cOHQ#}#e`x$C0z*oqF z4Eq>c#m^7ILu}&4!G@UB`M*{Qy0p?f1q1SYVZ+tV-N9;JX=e83kN%$(=6@^X{BL<@ zTo_;Pf7ZMHt*@P*`7574*bp6W`kxKb{%z1LKm1p5alli)0T}t zd^Rc4@+QW`@-0d zeuy+?GW{@dA<{U`O4foj`RW!Z|#yn|R&A3VfT5f6_uV)cy;)ia= z-$F@c(bxF55==zaAmeTY8YqVuyTnROM9;ZKmrD9lELd(FNae+TH9EpciL%jHI@UR* zQBHT&$T3))h7B|ub#dxC=#t|6ZmrodbAZSjl zlST{f-RGnc{0gSlDPt9g#&=E`ud&dheE(^qiz3aOHg0C+H;dJ0j5saV(!BRI-;jU2^4j~og#d)tM#yp&#@YL9VPDF3`!k9xW(F>yr=eN%0 zzr8e0fmW~5DD?acxMqsTG1CDh>Z&Yyutc6mj*Vad!x`lZ%w5 zFUTaWG@Vv3=P0o|%rqw$CamT~Of$kIc%w#}Rw(gYKNdAz3MNyj$+Vs(exj))namSS zsie0|G?ie+PW&j9!ok37`V*lFE}2b_wLCbR)@jlYKfckq`?!5D8C*^>EzsRoW|Mea zPzul9efca{OtF~0^&gOGH66yTbjW5Zi#Z%-H+6u1vb)_>6pY~{yQvu~C-H}N)7ZF& zL0IqK;C%90*iq(?G3o@6xf3UtR}w%M==^aAN&}BQLKEc2F6F^a zQ$4VwO`N7oXkunLP0JZXp9(HhcL+kixlBu0#wXq^+2mqr-(p?EI}YKyl1(;fDIX-8 zJj~LM7j>JaFu5~d+-_#Q;Xxj#+L12C| z`0a)!H!F9V>l&Gyr0i;h4uMS22p2(H(a5xoKxj3anEDVDXm3+f3+aPMYG(Szj|^&V z`hcx%($}VL%yeW{3-s1r-mC?_HU?7*(@Z?9H`fG-1tMol(^?6}QSq=9T?<*XjcHmm zV;cT&fC=Z*3fDjrwBU1j-9aWR*=q-xBAB9mkqUglTzd>(FvJw2NGqW9;=~Y>OTtk4 zIMmdZG?Bwh*I1F|qSA2FL^!mBi_;@bjs0hFjy637U^`)qX(x*e;Wx*amXSqutf{ob zY)Zaw90nu|@8eDV(djG3o2HYlIS;RlTj!Z-5Z+*dDUEb(6HKiY5s(d5=b56#hY2Qd z_?SJDOw-6rJjt|PDZx@X-4w4Nfp?av7Ay3c-Ri~wsn=oZPFZuS_rgLQd zoP#KD=-RnIn2ZWm;<4B|-vmDsNY4vRwXg)wUTA{9A#Bo1O<&_oN-=yH9+t7&;^A^r zT}EGOrKvb6IVnLPc1oZGL&8ej;9FOkiiK!yWCh*x@|`P9u_4c|Bd_-7L(fqD*)x7) zr70$K0}-bK#4IA#2Z-;8m>D1%5z!|=lqRBK0TCWYM5$+=Kl7tYOm?AMWrFe*wu9BC z;vuH1sLSGOSK|p3ls6XSZ(l*4`SYQBDSzwlf~WbJh&=&f3=uyChz>-I4iMFeXdfUP zL{tk9g@~{h5QKGEi*A8#oDyh5D1qjI5(tKrV2?u*l5!cB)#eM=;z6~PFHw+xaS3^i zKOg!h<)1$)c+ibRoCy$|hz$h^J(N0B>wCRgx}CqiKrhSVu;8H5O0ryh%O*P zE)wyEKiz>B+CupY{=5XAI(PNL0hTJ@Y3xoU@ zhVG{PjjIKZw}gmY0b&#pivvVEB1Q&?szkI65H=#J1c-1VtO4TwVGv;jM95(x?(rMD zOtBQ1Wfz_j4!o3L8d3t(E)wQF%(v~rv#Jk61BPdPb_mzW{_8?cQ~oJe?={6L*CWqW zdrk2nGpY19e`!b`%FigsH>7;;f_y2;Hz>%*QodwC{@p?3WBmEhOO$_m$=?$Y)=TWc zLqP{l35*PTOwF0$AV0Rp)GTz@0kph+v7pZu6S1>^fEBXiUQ-qe&EAK?mgfsvn2D$u zAcBcV3=ntrf=~vC{Y3nAuHc$wMC=O?SJ6^n>c`D|_nttXEMp)U1L&*h$5`-ol zs7cVVnUV&XbC^!%7YCVZ#qL)5pE0a< z=C}Xh@gZeHe>>P*n3P(zhnUNSO4G#T(dNGymVqJT@MstKl5yrOSQ~Q3gL)%IjW^#6 ziS2#89BB;jda9A>p?K+m=3b-`_$Y=>HCG3Q`kgpD-5d>O;w`^D!~87)vu2vjiau}3 z@rxF7F+OXixdw}P!*9VpteAQq7O2V z8|RpHuJ-541wn`7CLNAnx}v%|{=!oKyRg_r-g1sv8*TGf_5udte_WwG&-3P(i|e1C zquU+9F!K*Uzo#_9f6g&ep%YX-QH?FF`o|OhWMHe!_J&={=+K?(7$m%3?Wa zekTifetcOYcSg+CieXu1?1rac7*zOvzzL44qI_pPCJtepz zKT4WJFoVZQMg|_-_9W?RCBQyoUL@6lQSjo6B$&nv%@(&_Cgs6xNOXOZbPvHKMB`6M zaGbW;_&a97;kGsrudt9BNX%DSa3o}1{w~;(#FD?|#t=)4^qcU7SggTPo@iCbG9jF_ zM>CCK`Sa*s)s`kz4@hO7-2-()Us5Dr|gPa zmXQ)X25MU(B?44`W!W#`#ML?$9TfXKwywp`vDURDOW<#(*0V?mbs?rVw7>=gRaIll z4~(U!h|Ntczmt%Ziy`>=pu21bPHON-d!GhB`M9&VE_A=Ax`Q^Trd}h;$ef=!8 z5ZgvXt+3>TNS#H?HI^oYScy|&>lVwU5SF%-&)sFoU_}p$Q@bqRhCqp*b1jPQ*QHu@IE^tfdQa zb7w6j5lU&JxN*+XDnx>~an&+k3DfTFo0i5B(^lo>Z(ANoKso$@Nppl?j?SVs>P~Zfo{aYXVf1pIRTF!u-^c0QIgcU3Vft zJp=`jekiulap&{rh_2~4f0Ct^;J;*9lbNyvznEqHi45lztck&_w3Gi-#af5>hAP%h z3KIHqtWRm9_`*7hX)21#Usz$B0*2^ID}00SwzaHuMqz3#>r`ed$M@B;BH}_h{&(KKu9LpDCMsE`Q~cJ-dY+Mp-4>lw!p66@ zwU+P?VQV*HO534}U<+(#b+8nx_@kY*aR?30Z>_5(W=#X{jIQyLFYTrYN2s5(26Y@D%U~yoP;;Dt|KvUu(h{B zLX3uC*1C)ZMTo~EtS1|`JK_$J=lkS8Dq_+m0^q(3&=U1GtRmZYqm5V z32;E0@~joeO(D;^gfwCktaUL%pHHxMXEAp~yNOnutFuM)m}0Gh-R3?2eVWzI!rzO( zrdc7#tQFm6Shoh_a`#-T7eCcvt~FJfv~>DhYX}q!GZt8LBv#}hzrN7=CENK+6rqc|B(|b(bc$@@mH&%$S>D35!Lin0fKQJzrNC{qXq6)Yjsxsx>)_I z)g&3>uVn`L!`?l(0G=(Z$Jbr{LmI)N1nzT{^{|3@FY#^bte=?oqS*GEb#XAZlvbOq zRh0lxt=MX97R($SMA&X?{YVlXk6XWDWw-IQ$E{YT+a@j^x8~vii6)}VNo#9ZnfZd# z)@rO&Lw^4>#&PL}Job$B68PztXV5)u5jWOahS@Ig!GBtBVr^}C)>=lv%Ks_mU$A~5 zv5eY?>uPO{d06|Bbt#;=YKpg)t&5Z_d^i8`hP4aRSLcOqTC+$cbJOZj!4lN(DGir8 ze9SZJPTa8ib1OEGdi>}M4EW>>{_+JLQ<=ewzqF=d;MaX=Er)M2?WMIeqPdjdN8eco zLT8rq-r9lrK8W@2t%tQV=~T8JFo%fe8e60iTXnQ;LNK7P6N}pJW8>^w3|M1mQkltS zCS*D#Fm#%1aEVhdcMG0TH+O4J08tp}dsv&S|gVe30u4#qb3 zEBwNOsud{ys3CD_^Tj%^Eu2wos1#c)^mu1eY&An&Z?I^LIKYi*HZ9Y<;aRD+?xFKv zQ{iQQApmzrQf)Pf%`BQ`i(y4y9$yA zc_m!ww(M|hirvcD457_xWd`M!baGzK_JpAMYZ_ z$#1G+JQoLh3yGo9SVSlfRu(Ski*m`C#C4aNsN5d#-Dt**Rcx;)BuG`8Kd?(xn=@p5 zmCT?AzwvIeBZ?2MYOBFaRm731wqC%t@(R^$rC>kkU)`3$%2eX(s@oh)uEeiax0R;5 z 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 z

`dgVNjyD%BI4G~68r3G|A)(tXR_L11y%Jqea~m4?A(=vUd$Gx2Ztc=w|s8%CqD zsg&n0rzP_C|FL}=zAc@-YZ~}Q^xs;`ETcKnyR`EDg1W%7R5{)fq@fY5&zek;qjsfk zekj|!O`;Rl68dp(BVf)Cj$=~(q8zsr_49S984PIl-i4NsL&#tz0G+%>ZMD&njI6Ft9nb3vJ9%^3;ooTU*jhYA{bZJ*Is0 zBv4b_(Rwu{@9zU=9iemB1$MwGO2hI@r7<1O@BCjhlG&+z0?K>}dDT_qRb|+QrIBi> z%@JzculA#PRzwfj`Si)iRo?^5`BFVWn*R@5%w=fRfD8>bwrocut-jh5(SO@R@O!Yt z%d}Zc)2rz931{P`5Z#cC=FmZNl0HXYLW9D0Kvxb@X!r}@YyqPbm~%ahdPv^X1>|9f z@w71kgmy74uD8zo7pboGsKK(DuaLxbL|LDJOG59acL0R^@X++A~9BX|)`@{^7 zK!m0_^D)}FqDjnQx>ld38AKsBgKoB2uHoLn)*3x1se1xKZVJ)lGMdtCr_AsW%|p(? zyWR>iR@G~O^e+3q^gnu$wj!(8+ioX)=f3hzA;@3N3zFQG>sk> zE1=Ui1a-m7L=2ppSp6CDex(+RVVrjdg(Hv99r!40^U_tA<&E1fD7~T+RBLDD?c0e!5IEU1?m`B z(KMK)QE@bwN&ON3lu^pkPH7oT$`sU{$IMZ{8fEN$IKPd4PpJJ{pe_HVh!`at5u_~g z^H9Eza=W|OKd?Ca$>ypb(8sWW&iz7te2>#>`QK*bm3X$w&qfO1AY1qGJWh+8zb{zgB?j|R>MF4i^Au8L#bo)y9Q&|+_ zWy(!tgSJ(7!6J30PiS9SSB;>9<_pLG<^r6zij)>wC(w~mFyvF{?YWS|bc41PMc2o) zUigOYdU*t|PZ}dpx9-IW^s@&O_|LHC(~4sq(CmBg1)sBb$O+mP|3NiyXOf+VgUP_b zztI`!(-6rGDU2*aoecWW9-vo3XEu464FmPBxzCQeh~{o>*&0a};Yt%LWK)&LAf)D7 zYuNwt3udphL>A6Ii-dL*yWMSvO;faTx`xSl0~1phld=GGA;YRlkF=Ro$`#}?N732k zSGzMX#=`g_a%B-qm6tcMQ*S0>!+O>kcWXp<|4Z~X<_mer;~zyTQ!}72CSMjSqZI~q zmwH^CV5@X5;d>`!5o1jjy7lBc?RcoK!kV9!Cz!8TBz5VE7|K~_sFyfn$vzeFn?K{< z$f}S5#7ekNji?~oFON01qq?>!B3O@U~ZvT;x2=O&a3CiQYai z({;i3wB~IK>AN*NOS5)WtdtQP29Ua`Y-%KtHVH z4xS=SnMUuyH|X592ej!s8u9!?E1qI->kR`xcmVOkGe{J_qI1$E`hZk`!m(+)Hk)1| zaih&c2nC|Q!~{{r*cX;7vOAZ%VGGJhCnz^#7{I`6BF*<*pMyJ#6(V`XGC`@e-~2?@;mjvQo5dW`FI#VbP}^E zW$NMrDuaM7pixpEwCl%_nLo7E$>#jQD9(M)B6^ab6a>Bi${u;pym2 zp-}erKA>&s3-UhM zV0*phYHPy!ZtCk~4r#*FT$t#<)ukjMxos|le5L|;p zvEWi<+-H*Dlq3WVfdavbLvUv&SaE_5RvKEM#Z#bIkrdYwC{_p%+#yJXLh18eYZ$uc z{Lkn4KQEs1;_&O0wfD^Iz2uhbzV4AI4zILtMm{thQovuxhn9ELMqRopZ9jIChmUeC zW9rsL7WE+Pix|&0D&#VYXcNo6&ivz_l57j_kW-pZrmP0^qrGf6EjSnN(!6C9zGQy1 zq}y1M=?Z5;&iMrL{heTizqGkgPd`gkx(D?gjl~h130ISUzM)s6Q9KdFDVOV7>#z2e z4i|Ce_O6*8^&58ZuL$7y{NRZ7??3~Hm=DHB4oUJ9r=AiS9`xGU}$tXX* zr^HOqH_Wz+EHes$8B!BhFw=UMJ+K3zvLMGqM={d=r>KkaT|19ZcsioFe_+UDS7ogQ zSH<}*KB*rG>vJgto$7StTWlNXp2lu{nLxZ#ZX!k4ps(6@k$sCL@5FTpzUx}+*1(pn z1XDJLE!gIUvQq+X&Pk4Sr+oK!ELW}DZL=LKodmX$eLu)U)>c(goboXpq$F+wxdA2B z_bvaT#dK%B!X)akFAH4>&=3wlW6Wczd$g=`wtO&xzztH$MJ% z2yPxKpt^hd(d2@^XZrsBi9R1~&xf-ihpQ9{_9UIN$|uhpj6fUX?$Th^hywLW)^%~3 z3PcmETnV$J3F|oy(fSFl4Qwr>@IqYjsr*cMT%l{=As9IAsDV>-E*XjHPG^Pkh;@F6 zXhTKQ*LY56sVUq^h1B2X!j=J4hpT*Am`fUs>(QXJ=|j=+T7l8rlYHO?V|5hnoye@b zvu$U4sp2#e$Z3SY>JXY zRZFa+h#Tf7lY`ni{;8|Cl6)?VAl_5il;j&)*1QqRP;q~VnU&*17T{#r-^OxUB;nM4LwqGaGSbzM01rc6r!(iqRsvu-Z24@JsVm|Azl7zz zljF%PCsG@S1-;u%?p^LNC~WhYA+)gKpOSD0&TtkwF~ou_`BAH$YT0Vr#~zW}UJWIz zj-;=>(6g=z|Bm=!Z_WlGx|xNdljpAe?n!8goD%obxuq%ITbHcgp>Je}QVo}EgQ!_N z#0K#v%ADbtNlKXS%M62hdCZVTp7=gK02fEQrB#z|x^3!!pZ`6EeMEeG%7@iqtSZG!h=lk!W#>e!7 z;i7nte0Mqmoa10ojj)cVI7w$4>`ZVK;n;mCCUJsC&ZGCx)rvYwJ1Qc-nJJ!Lk`J$l z)@>Q&vXdy-IWGdnYBDJ<{_V*_t3s&hI88QQqhLU@Due+mIcgI7=t3RSV#k**xrL^9 zmP)8V_{G4C0aV!*3t3KQG)luNzI6OoY2*VoX7-+ z%Evt&6Jw@x79qrrq20wjqC@5TT|+(WP56_Q?N|hHKCF`Uku#JM#)_UToT^wJLeJn! zCv|#=af#gLWLtu3AIiML$P~<=%a4*2D&KoD42kVj0+cj5>4(xsh$@@)7CQohX!|Dn z?lX`MaY{<4l%zd|v)zo&qdnQAr=oYW78dmh!yUt8;(+;RURN7GDoQ07JrF};56p;6 zc;kgo(l-$CYh~(>{N`+GKQ_YwOM`*)f(UeBB7H{QdTXiaJXVS<@1TbBGWxY|*attM z^Rttk@N**0&c=#~2~wmYkbF_(0GI1$HT^~^FZL`3(bu{#{GeK77SaMOR#ziLech=CcQ zaxd756t_+PR)2`2x4YTvnCo2Sdg-oC$KA0qqpW1g*Q_c9^x5fK63h3zZutfGJD)8# zZ!k=ztg`4EK+)R@SE@E?-&ka`6>|yFHKLm3NAo3fS^7-$vec#Ib}NO~R&0oyxL+fg zBw_NE4Mhgti)mk(nwUoT5`|6YEJj?>recnSgfW*?F_}hFhxj8uGfYmr%7juo5tbT_ za86t2anD4dQyAv^o8Xc?g_^Su*SxrRe}ecH9VRE+0LVUOV|8BNSJ0Nk%@ySbvk0WG zgvROnLLG2O(>W#E8CTgprO@`K>KKI9z;O?Aj7=g;PQX3p8E^&f)0C;O`=-E?!=#gv zi;j?jzVL@}HmU~$A#xYt3^QZ4hhwx)A%c3BR`n~XZGMlpSlAhYI-uJ*oV?R=BB2K; z7OmwH{3jZp}r7op4#WB|M5(_5=fa!WX1=u9DWNgnUnHeV8!` zU&;XqVz2p-)B(`b)S#1;_x^gx}lvNoTwzgI-1 z=`%#4$HN%f;uig_{(!g=;xQMeTlRX2^nzKq;qpbNJBB(Jcvr@cFJELPV-N6je7!UB zA||)ZJ7ULpqqk9EH8@+ilA(Cp7gi6c`^{yLsC8rg_l1R#l@?Tm@e&kWxIEUb=yvE0 zNS98)AUQ{by&|o023tSDR_cR7@NP#}{GvPVb-v(DSh(E69J;J*;p+{T%zc@iFA%?6 z;3z^CtQmUp4-k1(qQm7`e2TbZ3l%zB5-GzJQZwf;*h<4IYfLI;AtiS&3bt@JZ0?ohHm|{J3LyZXkd@qF9EXW}ima`Zi(&dc zL)wM45Fajgt1L|Cez3yS?Fg~AGJWB~jK&NJms`@;<_-ik``Ew58BvmaANq~%BFxG@ zl(Kb0+{p=2$^InNjb^ROb(a(YJU#; zWi(cOr7uon?Hh(J#t|wFVca|eK0GB{o~hfcJ6uX?xZKh%=)Z#|dYt&*V;^@h&G(4& z>&hWl9fnubm8m_6nD`o9d-HG_JtsR>%V4kX0~9Y-L zost=jv&TjrNkZ*c<0HZ}y~wQwQ7b9J^Cj@G|8-QLN_3>K43&CvJ``ckcx+mQl1vqZ z&AzkMu{Xjf{oHYl7|IVwUR3tnfCBT{_hp0YN$OYuU2$C{-KSKbG$Oyyfu^s+NgmFi z$<7+xRuvBBFT{{;>mIW_bLfj8NnS^9fqCCdzuwpbak05iK12gO#Xt0�-aPiFhPTED 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 ID}Cnw0Db5x65WF{+~Zfx;v=i0z+$B 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[>MlV+=(}Ync$>Wh4 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

6*s1(VX{nAEH$5!8KVW=aq|aRy(})$n$$(a$0O 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 z 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 z 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 delta 584209 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

_$GBLfX8$XdqTT=*hlH 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⁢$Uh)hG&RxVC%7e8?mV-0fS8b1-C9 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 z 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 z zQEl{aZGF_tBF#FGK+w!4m09pRaxl1{w&wUVEM@^uc|t*lClvhN&GP~}FidDVCDd^~ zTh!N3KUzmAybS4qs81Cz>K>4}zTmJB6Qu7`orl=d9~3IpLjO}JDzwaUj3bhVsNKMXPvbf-bi@x0{z zxpJLU9yBD4GEw&rMlHRNTW08g;_oxm3*5Fqyq#V3S>lp&6NOS-({CXf6g1XfBmTNiIJ@h~6vrViD zf|WZlApUxr{;A*!dFxjfZU*=IdPN3U6d!O+%j;D3<3PQn)iL*4#AzQT-fE&UBUFUNC*+-Z6V zM7y*aya@iQGqT&w-8y<+z%ry7rp>f~>Qd96J zcahF348*yNyMWHMRE2&Ql+p@N=`_1&G`Q6<1A!7oWH2e*#G0jl&MH8m|8L);0{5l# z2k2%$zV(1lrMzdMD3$(Jj)V3&zR)1UaT#wn(3yY%QO7u^rCU+O4W#x9H+0Dc&*bwM zWycj5<&_lIo{^=I;2mGA=C}*y7Z3(dOX)D`$ag@sv1CZ;UWoGNyaWCIunNPH=+bx` zXdGYTf*H(*(tqH(fiLx=9NT>NIe^MkI3vzr{$Y}@{3`&cG2flw!c>gVR{ZGW_=vA> z$Z+hJv4K!>L#XD@tAj1jxxY%>B z;gIczTR7+K#wral)U(Yg2D+(-+q#Ds4%*ct*~nY0@(_c&Z6U{-dN|2`s9~#Z^pEIp z4bz5#ten$L{U7Y^P(!(A(oHV&YXC+joO~Nu3I2 z3u4HRYDG*MX6V>J<~ZI@_-{w~-2SHiJ5V!0hR9dYRUa*JgyFadi>w1i8C>cb^}3Ha zVtJWNyB?W#B_iz{+)y`cl))W-iBBG72opn-*@Ur%K%p6XHOdfB@AYiBK=Jx7k??iZ zziUR6Lq&Ln%jqci0NxU6;6E&4w4nuDdXPBU@KzN4X0TJE3@yd(zUa38qv`)2ZcC@L zE~DY?X`1FW&Tvx{9%ye840d9@?lgu?%NimMv%9AaLzwF+!vQhy5JBV90G`A#3<+?x?a${7 zA)=`Jfw`SG41-_qW}Js0#g-S?-phu8TDMCEMHD9%uxA$y14N$!&Gw4H)<&#yhE>0A z=mh}}yKcC{moBuwX^4fJC70hc+!n-xCs^oBsPhYNLF`6q=WZEp2;$u1WU1XYbP!t~ z*Z#h3sA3E6;5NS+!ffGZ<1SAO-5rE++Ok)M+5Qg6_;n%NxwK{obM-OS>-xI26J4VD z@nZ$N+a`EJ|LfOv0yjb*%ly`z;QMH}PXz;xi=Tjo-VO~%YZ>lyGa5v(NtAZO*9eE6 zmutGF#>b-Q+zsB;jkQF$&9{=jv91jqy52Cz*wR|qsTo=uMH_zjdOM?+j+a)L(Fk`( zwA5~OGIp^RN;LPb#>M;!)SO6Tx(%%62#PkIwiYXSY2`7-u{HwJMo7jjI=GqIZlLjO z6|se*c4ee7#ah^>#f&jdsU)_t)(R&W%WQ-Q?Yk+)a%)&LesH?+dmCZCmXvI?wtC0CDrP+9~d&`V_G@o?iUK_E=L+!>g<0u>c3;Zf$RG?e+A}{!DTfP8S zIyw3N$bV_?G>G5A^nqv~FUdbn}fEHZaln?*O<#7MgY0wGY%WdHvryOoZ zILQUD+T#|#6sp+Cw;Tlem8bwWJ~_!B;0N^Jbc;77;KM2IatbM20lonI2t2sSefj~k z{f2$=mW?Vj#&|iPa{u7UXv!}@anNH>oci0^apbFguT+sV%x8|oKvL4;GaST9%5y$+Ageo1WXd1Ea>W%JJ)qs7{n z*^TqYM({27-Ff2&xH;kN1!EK8I`g>*nRS?Tzi5QZ;n?_###(l>FJbODPG`$58r>SI zh=ZYq3AnlH;zeU!G2jv_y=WZW==?>DjC0>u(C+Vef)H-6f@DK6 z_}=E$!F$;BOGe*T3%C>t=o(MbuMqhgTU$k;B z8{b=3Z_(Y}>UG!ZDU-u2I9P2+Si^a9&_(|87!mY9At7K`u!ufuI)C%D5vn{(H= zqKfTSR0e!IvDz{@U3xBV0JKQOka5tSP|F0otF&je=09Nw18p z1P9#~FUuV_x7eE3#?7K%n%3rTqe*b6`1+&dthTEh!mPJ(lNT)dIEB}Q_pB0do_{@e z`ubE_Pg@9R0ZV*i+zhvz)qD#*ne*)R7T5Trv1@nD@ZRVyHZINj=;@2Dc2=b|_#_UN zgYYRZ{Pgkglk_UvP+`n<8Uhww(k%Bf*66x=pv;5;tN)b8z}mW@f-E`b3l6Z1YJ(TO zgXqSxvw|E18TyYPmkY@==FWsnthT|+8K$uCu+7T_ADrC-P~z}g!dI`c*m2*aj(N%fXSFg zDxrP2hzB3VLUpoRomS+;y(Kx>=9Ni`-rjTA1W*XA`q66Tu-J{Um?@`BAKBD+~mQXMhi#<{{-UnX zdk$%A^Rgw4<6c!r!}|hhgsx!emE}6MrxWU@kb@0guB7Kaise_9-8%NOsQ2b3CfbX9 zT;=7bgI)Elri&zSJo0n_}U_EJgGtxNjHHZYEi@60xH;&w_@>2N&4}2my(vM>f zcCuS-+2Tj+M?VrQek8LFc5C{GTogm`c=pbwdE!Twdi9|OFjlwHVYH3e}*Qc zAd^(Kd99*A+&n=Hn&9f;qSa+FSM)JZjvthilXl_VKmUd|j3`a3ri$}i&6!3|`-@_4b$aQ4twZraRtD)i1y z#)@uEC%kI#8(U#~*Huj6E(aAyI5mIkw6H(yN`bCUcTa2I7{apqeliVfr`T6b-#o zO7L)q5j?}UZ(ZYQn$%K;-{?}u7pg-V$IY}{$7M1Lz{Mx!-XVmYzNuX zj$iWBO>PA$HLE@&b{PTVykv6vX|TsUdJ}{g4lHIz)tpp*i2}{Hui$poMat( z%YDSLp{!ajNMfr{7RiI{hzM88c8igF+O@T0OBibqExT2ThxEgeiL*s8VPIk1Wdp0( zOZI2yy35trttdHMTouS_N6Q|f7{uB~LtwEjiRT8gIWZ@(kpbK3jKW5tev z6uIRA7&-A|OV+Ws93zfxX^CA+Du8ayzbpW_aU?HR9&Fdm?@L=z-<-9PPH5|%mA1jif3><>kpR();v+SDvNy#_(yk7MHp$qjWqAUiWz$rEcAwr7wW z!It%vE3?;wpaDSb8!Xp{Eb<==RmmrS#SfN;!7Y;)215*BVn0~+7M`-|Lm;ekEx0E| zmwjAV?;&!SIJO1*V~|`=jBdfI4F=P%1q&D~2g7!U%0uP;VzU-(_)xitXw`x(1yg{N zw1>(~g&g*9D0mG@ao}|k^W(;D){h(W*t9q~MSS2xiOBcCM2MRjvxGsir*3-Vf2Bf% z6PPdp@4YDk_q;IzwmZD3(y?B$JOmbWZX7OqitgT2LT}guj<>vcCVTK>o)ze}8u+qk z1q$pvO8|te8mkmJ31a7{g5^Hu&-1iSBi0X4_qPv3V@*61+fr2?A|`lJY@-v?#+jhO{Kp&P$|{CI&et3)yNR8V)?{Sp>Zh`fBjnnG zq74`!Hx`_ywdHRu`iX70p=;VkTRBqBuIzTcC0hTAhHgfH7ktSRoW^&D+czi3fm-r- z`CX;XpBCDD{x1Cg_eq;QMQ+)^6;1k`di*iLJ!A)Cr4O*ym z)5dTsNb(>z&GD{$*v9&)mj&;Y$S13cWiHyL7jo6gf|a)KwcK}}u<^)@{>?;JkEd@d zV83=2tavWH316uBUN%THZA0MWQr8;;w=5RVZe&k} z3cC&zc~0Crk#l!K6GdGJHKzNFn=GkiNDp|uME%ASdguujokUxD~L`E3}fgUqfL9cOm0iqfpjgTKhhdcDQTIddjGf_8{`p5^&_ z^K^LPyTN_|`}XF$cUdP#Wt~`7o!xg-+6X%4T2)CD^Y5^wRh7oPN3N<2u5-&}Q$?q= zi2qo1uPBIU^I_`KE&&x!;g{gs=KnB%C&dlAtsYLwD4`8I?4)!Q|Cy-0a#G;F#y+fB zH6=>0(WX^X>Wbpyxf-jXJg?;b_l)foPu(IjdiqCYq;G>n!8-n^qrN=9?#|G*)K;oh z7SAVY-!@R{2*O_Ns;4s0UdYz`{FEST;g~kuU-?QW%+{_1D<4Ey4s|(1St+Dz!`mox z1kY)MH&x8f4^KOn6ieIVWCd~r7E1HIa?`4tOXDb#8pk#`V?y``M%8a^eKjc)TUH}iB<}Kv$goQjFuoQ|<06VZN9hI?g8EI&k zVk-{R;&)ZN?%Xv6ep1PA1I3h~>oRH=lwN8f(PI@Un`o^GDTk=(2&7yf{>jOD7TlU;-iHY4f@gvOc>#M@p7Jz3JjO=#Qf3Kj zw8y=a3_+0DxJ;J zTvc2(=Xj;I0ByVJC?!yY?qui~<+LzR^ZZI_DTuyrSlmvfHcJ?*+!g{^k8z5xV6ROY zr@*zaek>+I875wQ%?>3fyWQ%)hNhp9o&ZTR*P!PzS9q?>rc6-2wd?Z=#IR?fyB0JN zDzKy9U#QMY%-ld5G)Zw6gobQ-B2=E$%$%q+1Ct_u^RHUnQ^jI0~$d+Fw z3)Snb#rDrhsLOvm1zT^6?Y&9b<{V|F01Le9?N-vn?+>tDyOnmZ?DpYqB^A2$QG1m3 zVnGqxxd%$RGi$O}X)jb_Blm(3E(G8NgZn-uRXnwy?b`<~=dn^i!HSLD4=&IA!1nA{ z<_qmvz&FYQ*yEA+4fxZNwaW$L8+L*l%~<#WFyIR%H+)#PgJ5iB7q|g6?GPAH)3^aO z?XZ#z*Y{rM2GF-e+yFWPDvbTe4Hwp5Q@k5geY%ggf-Gp+PwPP|*dMz86Z2NlLHk-$ zoCKk&_D!DhUVz~C9aW~lRjFRbltw}Ti{geIO9VswC5ml4rue`uuV=X}T#bATI;_FW z<2Y0ys2sI?kGe5p)*=d=m%Dpj5G`OlnRjX)T0;P7_yapCHaMOv+zN*v{%hs_? zSD_?YvvXIKKX~1`2J-{R>a$G`mBZT@0Yapj}(6a-u=fuRzmGM`5(jB*|S5Bm0RM=*=&g!QaF;;ELBpgKA6S( zwWZjv-I~RAmMS}h7Fw?-Pz+UdGe7rv|IA?XpDKf(vi$l~2@zm@eVyNxvEpCT*y7(I z;^Wvize9J^Q|t6x=_QDFFS8Xdpr`R>g)fxFf<5b31{0%h+LSWoxlpTosu>33X+BS3 zM^=Pa7;Jgs`L#lu@lpw~Zd%&r1jILWQ8*vobPny2vWV_^B4rZ6!kSmg?~vY0uc4v} zN42eQ6n9a4Hh`Uer^LXu&NbdE%LT!gZU3N5tJP~TRJzm;)=u-|sRo4kzc%0Q%YrLl zBx}OXR4A(i@71z;Uc6}38Vc%V0lt^K6xB@eiOl9%tJj2@%xI$?gA%NvQ?>S64Cr4a zr}^W!e;K+7d0$5S0sAuIT@HO2@zz?UN@_fG7;JoHwWsyzp_WEfR9S8Bk>8&;jwOL9 z0Z`tD0G@io4!jPLspniHg;F!D!?0B+MpnIm9!7d%E)_jMiXjpUk>ZGAtxxj&j3-+2 z2g(wN%#Yb4TU8c1u#R@>0Rb*OvQyK#{dyQ(Sp0VR4oM~#T?>#beivW=(r^1hB#YmB zwNv(Lf(S2JEgjXlFysH08^J83Dj4wHg&Qqc2Pf5y&l{Z7wLC`l{8W;Ke_Gx>8GJ?HS}S@fLGpC|BV*r7D4a(+cX zK71(fg%1U+)K{&>PS$Mape?DUJ`@E9Hqk|e#ogLw7j=^eGl;NS>Q`cZ1lwOroghRr z4_9@fc&9U4<*H7G3(W1^)D>b;C$`B=oymLA+UhLvMmSqn8_>XN)d4IHV{7WD^I=k5 zx2`%`eAJOGs;iFT6%9~uW`o_;BX!gMK3RcVN6pFbl+mv&tzgmB>yP;q5wHlO>8 z6?;G`fBuu5Y@o&n8O+&JRh^PTcUC;D5|Q53l{d=KEY(vT17pt%PqiitiZIiEV`lEO7Hf6h;%Hgp&BAy`h#6-sCE_>YBjyo4+2aM^gikcp#l8j zuX^)6&089&4dKW5bB)xyup+6wwylZUN3dSljz$yBxtZEb5aP5@Kh;wZ+*w?6HOSf= zf>Jk@+guH{W<;)QTBxev%1kZP1nZrxEu&Fc3)Nt40F7!CO9X7T6WF_O zby=f;Ryb7q|Ja9*-e(r*-~5pgOFP(HgW5za z(X;&q)g5LymkjC+@sbVOVg%2-GcOt9d(N8W$m$%I&elA>`b(!`c=kM;4>Oq*7TO<@ z3kOp6hvbfDANoTxg}u@P)KFLoFlK=I6h0yw2dabkK@kJhWpFrX#30D69jsswG}+Gf zeDJ6Tg8X{*mpzJO)zxHLseP4RGA$ds&*IVz&18@iTK-F zwm44h3Ui99acY<_MyoyyYlx1WAFjR=HEZs%n^vL#z{~Ev5$ZY{Ay`Wqqn;38UekK4 zIuACw9_I#3SjT|@cXn{Yll2@A224@8;mV{0FjlfV+^EWiP5>i~{l*QLO;1z<#Ft&! zhKUgE-mKmvwG5W!I3=p%tf5DpJyqQyL^AIr$inX*uw6-@)QL5n2FZt06}bV^=;>g5 z#}0D?Vl@MdL+mIw{8{KsF!r&0ZZu(?XMq86NyTpxptamaPFh$~qt0twW zj|KRI7dlr>he)2EtJW1C-)E2Ks-EJR`p6sx);gA2k-MN8oG0i^ZxzXxrNQY(+%+0&GQT zm7s#v)SayepHq(eRMWb`yh%6D<}5U{uCSRwR|?wj2rH;{Ls;?>wW;{ho9$hqw&QPZ zOVl3lqe@_g>SgVHX9pX$Q>m#XWT-2wYpwI=fuyEjQ;qVHaicHX?c=swbssc>g#0IE zzAR2YD)R3hF=V^s-?nYZmQS%rSI2wcQ{}qwibAtH2+{NXG+utnVk^>^S_b*8xe z498lmY%4U#{jB~rwJp4d57?&0iKkDqGrG9mBc4iwAjPyA%`Zb$3LwI&nt%%9=&wwQWZX+ zR!?}!OF6H)73`opAC>kixBR_13&>Y%h{erW*L>*Vx3i>t)h~H!^K&pQhy8J@ymDau z1n7e@%*^>aw|M{;S|s6lP}cYs?c#Tidw&+Z|0pD9<|d#IlEVL$IFsbk7ZM(+^KF}< ziz24Iq37pv)Sj=S~VB8=B~hNo;~pE8{}%fxf9!SPOa_M2z~rQ z2H)YpPjg3hAN;HT^rO>?{4X4*rSc3iUvAAj3Sh{Y&L$P8tpqq~ra)aNJ`HApg;1j= zv!p`x4ZN33I4OOhsVKXJ&4|tKn5JlG$@G#CK_I;x*`Rr)hs(Q{ilsJ=(P&)%Dhb6B~C&odrGr zvpX=Bbkkb>1QV{RuNUutDzlW=fAf>YY}H-0k2PCNEp5#`HCX7zTHRBJT0c&+w7%SX z>NBxq5!-ZM9V}F1@9wJ|VKUPGXZ0i>pMF-Ci!TE3?g|YE9n_PqEe7*1+z;&N#n@ zgH@V<4$L^ z<%=Dn?xM4V$m9%NpWpB~39MUH#UvN=NqvT{+!3jSX!j28IyDK7H3nJx9HbPY=DU#= z5#{ei$|MqVk+O*XBFZLebubx)IfOZfkaCIM+{Mz6VHqL>II}v+;)pI2#S?kdKv@#e zM4}WTFFnc@5glvDVuONspb&PG-L3&L>+3P!#tvFqI@E;7Rri<5{Zh5 zM!2D@gs9jRsf@@TC>eq;Cwxb$R=C4Z*Wn#zzAaH)e~gSXk=O~naV5GzG7lod0Mzs) ziX4vQPc%IdDTL_w2%zM&)G)%!;pk~3QPE^njUhVS1!XePjcF*0BYHF#DW0f&G*SZ5 z1qv{U=&SK4OCcKamM1Vd)z%Knw`ju^UKGwm*9KDxi6U}P=0VizFp@8k?G+?{qBl*8 zxGy0@%^smFjA#@28A;?3hMLJSge!(o3W>a;Q5Z+m>J)ktPvrU@DS>ErFlr_dwRb^E zAsTlc(`yS~51<0aRbYWS6TN(fzWhq3nZ}F}pbrF?l zLURlvljt;27SRo&Y$Bf)sF_n4&ZdT}i3~){CE@h8NO?r>f{^lwhWH~D5+$@lDk9p_ z0jZeiul7hKL{kEg%tT48kjj9PA^3F^U^xk!g`m)iQn=|yN+FeK*a$59OrnYXQ8SAu zF&<^vL`Oy=Q;!IFw}*O(Du5 z%9@C>T%rrpkn)J45|Q$W_K!y@BudVoj#xzaau!lCQN&E75~6bnNM@qK$w*~HPbk20 zqM1`sW(Darm*qW!D$2)Dvs7Q;we9i^UZl67-r71){rf!?^_^jvA;>#YOK~OYL*zkJ zqb_EMFOgIS$)BioZKM#QG@>w~^d}fX37-VO@O%Qv48-eS{ihUNm?8iTD?qX(Iz%#f zb>cGJO_cFv=0LE2iMPIdK0$@`izF)~a`+l$DHLD^jn<2ZUi^%8I+qjFKY=ihgp=;0 zFrVnA1EwjA0-S1(6iKw}cMKw%$bo{-A&P#EvIL^!VkExs93mQUAE^i_S=ad|#4-}z zyp2>&wD2Jkexu0HxjjJgpcG#G1<99a@IEAeqGgAXLV(PZw0rQzpu20nSaB3Rf)Nki znZWA1?`ZtZqxnYDqv$A~Xd_V(QT<~mD#qQ;PhLEPi z)B;XnL}Rh|l2aoImr-fP5FH?ri5?Ke5p92g0mc)x{u2p52WRL;5%HTTAcKz)6%slA zg_`^l4v@7VUy@VEo6S^V77<-1f}_~Ds<)*w5p^Ry1hsWOA&sRK+f``}ZKlwKBU%t72_HCloC*N*W;3T*+_wMe-Pu~6UH9m%bt@{}n5KFuSDJby+?B3g9-HB*q1bvyPUE+Szhd6P-B zm?(>=ZZ2wO6LlbWIYhannM?GND32)U8+4aXWUwRik(P7{?A&D)8Zuz#Niu?8z(Q4*M8}t+ER*QNT%;@_=P{S@B`lk;dOH;6 z5S<-@luOig9eSEal+_Sr`9#w@V`K`6Hq=5{5z+lANX0~9eUVCtTDAa!LBLG-R~HnP z5j}c^=`AOc>3!G=zBWS&+de@VUEZKOPEF03WX*rUh`JJalp=W$z5EBsmni6WPRXhM zgs)4{(-5NK3RDdvYWoyrkwndGFrqO;Cw@asnaKGMq&T9v?~vk&f?gpd5bb!3ekLao z780fqO*f-(5z$PdOrl=RFuSveJQ^cq6TR$+ltZ+w5mGMEnx;s3M82U&`N@PA!Vn9I zzG{b5L{zT{QZZ49H&O}F#12SiqF67aGNL07F%jiNc|=xlHwP49?MEoHb)=WDx`c4B zFc&_riQc#pmAN2!5Dl+~<6qENbQxE$)j^D4EQaX05lJS>k4K6l+LDA6PZT>2DS;?? z4K=(Z!ty|DqbWr8mS#xwE(m3rL{(cMWf6JMu#!#W8HTbPqO)z0a)}mDi^(G@Ozwoj ze8SNYRE9+Ff{}`dnzu&HVj}h6x^AD$b z6W-t)&{a?EPZ4=YIM*wD#U-8NK;MrZ`Q)s6IXdNYy>4$TbG_$S9OzxckKSSX)qnPF z08V_-x05&{#;M+om!Et~F8vFi`CRY$8H~4Ou9trn$uieF=#1}Xku)BtRgq#WV?`At znJB~!DUN7#O{93Dy)H-zM9m#8;P@9wlZb@N)UOkDx`HHICK#X!?Kh6-oHcn$?imk(CX|VEoG@?8Fh4jS}6^A!QT27Ljs@;z=`?Xg5(F(KDia zqN)__NSZ^GQ2xdc9mM=iPL&B&OA3j6EGZ;1pTeR@AR2H2DT%0=Ek-ScsQGKEz!bdm zG3;oHh^~D{oe09O^ zBCiPix|K;ZA_OUmD9HmUn`n9&`jTV$2-M64g}Ef0y$n;4M`U#yRr86q%%<`sviSjJ zMMPbjp)bWmIhB!0h}Qjvnr5OwZ;{G?`1rRe3adgn3GQ zCBu+%iDsLS@`z%Rkn)LMlDk5pqJ1Xj5;b5TXPFQW()eau-Py zE1@ig=m>=%6NN-2qcD!Ji4iHDsC`eQ1fpKAkdlbvwqTc(LNqs$ijc^L+D|6Yxy9I; zvWSXFmQA$y`Bi-X%OTvb9946PHj$@!MA_#tzYOEEHqM86$DSrO5rMbrrq`L0AN zA$s!@YMP0fSzW{NuZ(cWOZ2pyD1SJrTG5n3?20M0CE7;avoq0-(WvQ4lrO6VYX!wJ+ep2A}V)8$|ic_f|NtF!3imsXg{@>JfiGc zD9a~WK{YR|kkD%aW_}S-CHkOHOk`UP9hMM1(Ic6O;CM3!lTY$P%r2aZwWY6%malkG zG>79~@iv!!n%PyNM?SN=*qvu|XFjvb?un0lD)w+T_THAMn6W34Wh&NxBoz&H*8@#J zP>L~xjw%XeBByakaYU!aAX(;OfuoTUNG1(OvP{L;EzFG=8u8tTWTHK!8Ao)_z}+RM z#uJ`2lBYz!5G4^!8iKMEqRHqmbrBKkkFrdn^F&!hZwH|)o5+#e#q=TQew2iPp|Ul8MqSDI^M|0ON^XM53l;D%PhvQj%pB({CuHkW_E( z!irKz!PlZpEFxO_BW7?h(Xm)`S3t;XPUiB?ZV$|I^wzj)^pm41tnDdYsR zn4YsywTOgc=O7gmU0H)vLbRDa5L)J9E3;5mMzY{MOm8_+t>u(@8r4S;*%FN*az;wl z{fE$%gkP^lhaN1*Q7@~VCkz}Iej#-Ft zgw@EKc%nmVQIf{ ziS{faJnKgsa6mO|)un97joCu&@o zL_bVJhgn45P&>#bYOon)IYi1vq+Ft4@-vT!O+i^c(XQ_yYB2s468@Bk!Xl#g)P9SJ ze%^$#5~2flFimD6B^_mDMBh?m%85p9#UxqLi2ogtEzvQgWxEmMh=x&s@kG{pQIbVQ4i0EDo)GQ`?L36kgBB3tI%vE70IP~3}-4M&Tkd|G*-UkcuW^-LSZ;z(^rJ(G{VG0k}HZP4j4F+AN4a`Li>vP0V%fyiy3RXG~<; zGQO-B7Jc$_&0rVP#1PYISehT)2BHZ2;P$o!oXy6!GkIH^n_9feZD;yU;Fsiunx^wz z+Sz$eNii}eV!HBqJz5w<>D z>18_3FQn~lY7BdAkMuUxs}<>A%$NKpwBp$T%i3wbM@#k;ghCBwA7iQ~{?&pti80j< zE^bi_*#}CrmjG1@Qon+WVj(lF%-{W&7%B?X8a6G)v>dj3IrK3F!@Z>8eN2PJ4{*_C zAIQE9n$Xu2Yy;JvTF4f66R%s^mQy2a8XGMs0%)lvSR`NBulPXXj<+l{6d*09)q^+0G}fm-cB zkTPKc+dJ443EQJy4K{^}cQ&%1A*NPv5Wturrewc^D=EO3iu|LncFHPkK^AXI>pxoK z9-XuW{Om^a0#<7%cofRwz^L`t3X4mNN-kIVd4+azD3qblfXy6cS_~UaDi1fsRR4CZ zMK`VBs0WYyHa2RwDMx&p1;?V8!b7uq!^-=@iqsQ)O^{Wh9_~Je&1;iGop5Kv^p8@0 zXroo43rQzgq=VRU#S|p8*3K!WwKjZ@W4!5Sh-BC((|2O(dlo(lb}l-PHmwuH(`9V$ z7}GuR!3&oDmFXUw88B)r)FScW?<{Sc={)Rv=r`VURgg9B1k*TM*#EXF$CRTfN=3Qt$29I$5mISTmpNf_7u;Rr0YaSbvW*RO2 zIFJ>lnYIc6+EDSf(6-c+UnzI- z-3oI%CN49DhczB^r=lW1wY)wI%1|?%mhHjWEL>kswbsre7iYUeR`;A(4bJ%E*$WLB zmIv}ZtjkO>uoLjcGE%1GzH_w^8?o60n`zmS&89Zq1#9m>8}AJJoJuL9 zj)27%{Rwxml|9*PDss7&^*?@{WS6&?T0(qH_XXRCbl9S25x}@=We#OA+f1Fsf7Yinrgw$!Aryy*v?t*e=enlbgmh0WurXg;#m?+7 zwXDfN@uLdwhIkUpbD6_VQymy=8tpW-b8GU23U*upuOrgCSedJ{89Pl4#Ilua(@s-U z@ytqgai__RAD_0<F9 zaM+kwo@4TbbNd_YGU;m>R&Y1nV0`*A7sFWeE|Y8RMkI9pB!o9xE50MFDoX~(V)=5m zW|yf&yMpC+Dj;1S)lxrH4tM(6(w*-C8CcAAg9`Ui0TT$j6s^q}Yj&Hu3SC*Z-6n(h zB9nc++vMqfG4o&E;joa}LEwIxzhU=xo7`dWd$$`p8#oqm4@@8WvUYo*ws^C6FzS{s zyHn9-oJaE3kHPUQhf%`He193s-2-FhA$DgEx;A#N z$)j1t(*L8#p8Q{yH3VPn2AwH5!?vHyp-Z-JAs`u~4st^3L>yIJ?a5=9LuOUi5^LS{>)Qf6c4!fIz( zY}c8MTymQgdk}UOMXrN*mM%t=dkx)4GNdBKC>5p7|9#Hq47+x>{J#JH_xJaDy}jS> z&*yW_bDr~@=b2|_c4n5Y!Dyb>5yQ_59EjBit;;wTYZ%P#(s5C_j?K_B5-S~C^Sb!x zXnhvcGkoHsn#CEJF-O<1EyZa2mVT-@qg$nz^XK&&-^qB?fKNbdYSKEastUdFqX z@FC(3?`KrTrF$mpye;ES%=Fl88K;{x7>JiTr@gA(DZgrG<==J0^-Ns?{(eOFZpV$u zO`W^q+B+FPi(YxKRH;}bm6wpjlBm4vPLWSdIu#7)PwvQQ7ZY=ACY!b^BNJbe_Qx(< z|04P9#of3V_tQ;#GI;IIjaQ1lFs=35iX*)Hu?)Y z`53PB_(q6h8O&hP`yJ1~_iy8ifWFC?67$YM;W% z)Ptp*!U8_?0`r~9XyJMD#CK}uj$RTfRZQ2Xr==8=*twSYI9h5FpI6EZ^54Vg$= z&V{^D$~-Uj4X!Ua^+(Wm9TD#@=J_b6(Z}rOkb6LV=#JbHa?9`no9N~@vH?oA?j?33 zubAAk@tJ@1q4B6xvKl;)DXK*`3aliUPyZgM-x<&tYaJLnY-FYslOokYp$E@98w7+yga;>b=?IbslT!`E&>l^d9Fk1{*vB$1KH_VoJ3x z*c*Jx*M;j8=JbL7Cvl)gRol_if}<)xMMFug$#f*#H zW){otmtoVVZ${5QZx&wuCYb!{u9r4l$>YAfR&)Jw9)lmxI{%T8-J$uRb7=IS@i+Wx zLR*9vNq>*=bW{A6U`-74+!t30;45ddul~qjF&AxY^q;tw#CLN1iA(D*gV}SJVBPGm zORzsZ$@2b!#f9x}*zccU6aR)C%BpkNV}sZ<4*TSW+V=gGVt#x=KVHf1jWyh;52ZmqL;7F)R95?L8Qx{{Ckvw@^ei1I1^QFkC&DBkdm0wWfZ)HJz3M< z2=}MYfv*3xwk(mKal-6ViA`Ts)BatIr*|ij6pu4UZx%{E&cxm#rMPg;B`L0!ACWXc zj+3oY#U=8fS=NdRXRY>9imT6-m#YS7fmnsewqXoFR)}e_2-GqMi6`zHH}4 zvgvEGwpXvo`IE3YBx@~`<=?$1Y9@=zG|HB37iIZ$nNIBTw`^oX-cR{S#j;VV59FDg zFP1dAs&qv5A+FfyV|INp0jas@hpyU*w-(4&Us+F!O$Dj!y&}2ddk0dA& zS8eq4_I_Csh7$v>C7Yk5+~7?fnZ#vVB-@{rLl9SOG~Cus3?W~W*O#N zx1=tckKQROjUqQW&o60m5>*~qficyuD$U zs{P~;TT}4j7jjGT>WR;(Q^VMMMM++<8ru)Yh%a?D*$-AVJf+{!+TN&A?G2UA;vnNQ zYw|y z&UIAgkPDJ~gWOJX#pL7(j?IgA8L)X8+TLO5w0W{;xb9 zT~97Zt{1tTNY9GQ9Sp) zl;S8pOfm&M$hS!8xkX^BED#4YktD9km7fjD=s?JBQZ~NF2EAm93_BsKlXOG=oy&r^ z*y}y~^1C8SD*>aVi89h&bf%p6T@kc+?GssPBKOw;>D0OyOwLTXt@~L!v%SGXiTh=Z zS`lMI(pjnI(8tn=p92wnle4M5Kax2oxxwVz zV_$ug%+cdW<-^6&`6+iNIklb&b(vG^$-v^;+Z#Uo&_)?l3rXJ~om@!xkRmzp5P?x2 zeoN-Us%vs5$rY}bxd^$fW7!MsF(WPCkHcE8m9eP{l#P`dh@0<2Yr`F-L zJ<=_s+}YjI1<0kbA2Dpt>$_xdCk3mL3z2i}l(~cCZXy>ZH*JT^og{bmL+K*q&W(|O zTy%llJ#saV)9}<618hl0pc=XFJH`L9Ul zBv*H)bZ&CLE|e~p+{8Df^OBpq!Xxb@VdZxho?7bsmD5+#`!L!~8~0$Di(8>{NZvR#IhxJRmdoN6uNul&F0Cd1;STzQ+6 zR>-y8r4%P+t9DY_AP*0bQk;{v-cq_DM^iyA30#!B`FQ33_bieSU-1R(hn}lBOzgf03k_(VaB3I`Y znG^RusO%_@P+n^TJ$?T!O(w;i4U(rNYVl6xavR=N%J^nE9l=2G%T`8NxBUUF^aQpuY{?q+g6a%OUK$aNs+ zCpUoHGIGCJ}}2#b%w>)9d?2Juo+v{1r}eAeFtpN#8%${dnYq@wZCN8%+?F)q~Ct0 zJ-3=?dc&V_io8lEMWVZ@bhOeFJ2aAx)^=h?gLJf-6I;bd7nX}MaZaLiw0sjEYaksh z-^8v>q|@ZSC!V2pbQUDqu8WmPTHA^EBJQ5{HjP`;mdww3D?lfAhqdX8MKaQL}v3O1r3EvLkf$oZ&b4wYQ2Bzuu7XY#873Z9^W7L)sp z_E)YL{A4@@x7Mbb5ZO->+2i-xZ;$!25_|Ptd$X8>mDt96?VB4nsw}%#Gd{hFbZW-E zY+5f&z~?jqHJ!bvTQ!}V*(WG58mX6Rw5^w_$O-5$qH4(r*iu`%(i3nWm8c1r&(eC^ zJK}{Xhcn6iJ5q7R#a)iU#Q}@D!N z{6~GTKl9nSKG?gVtW96IRK0Is`_S4=y6!uJXBD+(?*Y+$;c^j~+y@UqwX*b&9=CsK z#M=dLX4;$92=;i{jwP;zy6Xor?eA5uZnjgv#^#Q(vl6!RSo_2{+tZW{po$&aY#+p0 z=i1E)!EDv2RC>C-5sN(HFtW&IdwYFXuH8{J&iEo#nsP-4)9uN4&oJF>q8?@9>0N#3`dII=RjVOyR(DZ#Qzb+?+>{N6;_ZDXFeYGOmI|xT1u2e3=&c<~Vk8yxm>y7J@IAsi!g7CX}Bjm{@+C z`726TCRNZPTv5V1xq=p^S1L#ZD@xd=l;5IYYWZ>IuP9-eRzZt!MG5b8tO;8{t%-Lh z%B6kPng~s|I}^PBT;raB8vk3=k99q!Wx}Bx>&rD$MS$1!{ee8{-Ups>;D)s)n*~0jA3LIfa9Yt)G<`ue?0m%e)MQ;V-B#a!76N zAoY{OOmmR7d`)4?5n>HYMB)5M`) zh<)FyT_~7mH^&DXOpwPVSeaO3sq^eJ;zRYX4j-Fm*V}}n)v1&=HY7GZtXe-tY-3wr zLoeQRvR1`LmOkG;wtjGkYGo((KSk_j=jPk*jWrFOKvz&^TYwRUhfy}D*vg6)*vBTD zlnoE3v{!N21L$68_a^wBp|a3u;_xVJq^OxYG2dL3nF{T>$>E7=J9CL6>xtdtm7gVs zwb|ZRujaS6HpB<_QQWkHIKWbiu+L?~$BOJ@8wEa9y(kWRMm`KLj&vpqFA@vk5QS}u zy7mmDdyu;K9mKQ*v)aqQ~qh{gi1+uiY|2!*|>%*NWkVV{@~IZt8#FT~op=+G=naTNU* zDQvqyY+-pzaT=QcA{)}^lIHtcwN@jxAuqPwk-3-QB4evgW$yB>fVElDoAzaKmKszO z0$;v%RAcAfw0q*cH7RF|Q=4OX%k4AbEXtZ|p~+PbsNNOg>ZJZF323!)}cmujqah`nf|j{h2L#*{!|Q+d-< zmATj8dKhR*HNGU(m2L>&PAge!PCk-MY`K*<+>F@RVxnDKW87=8sk4^9mr?4%P*bA>Fa3fk7M^ZSPP3&Xo8||J()=^~rDjmJX zSmEV$SH~45Fq(>jIm8h#D{A6S5H~@+3W~Ak?q^kM4DnSD;MQWXraY9>o+l2V4UN#U z2_p=>LSgTC)dkDjg!9Ndo2-!$TbB@rRXhk5Beia}JL~&5P|~}W*tCXNWBWJTmsSbN zG%HFP+fWSsUKW1ao>C>WQ52Pkdf<d@`zOZp9Y1^&Pt>uG}?@1^6!RAIdJy>hIad zmJ_BM-S^6EB6HR)$W^eZh{%=Qlx*h6a4!hYN|5p9`vJWljNLw4a8=6xd$xbb(mRXy1g~??iH7SYE)pYLL8`sLV2@j z+J|&drNh-JZ3I&~xDQw3%ZJ=Z-K)Dp<3|{RFM*nb>l2&6>h$?ooIc|zta*veEbn7+ zyHh6IEL3iIYx&{y{pD604wM@%DmSdBeqygzH6b)tjj-oMO~xPy!=p@MJ` zvDr@?U1{FJXusYgxQ(#9uFAopzphI!9I+b`BFic4TS@F)L9KF__b5hVT18>gYT{Do zVQqHssNI&}Q#s>XR1;b&wjiG7`og$WdN)$|@_H!!9NB!#9*p-Lr<%yu#3p7qj)PJ* zTvUEI^&6bNewO!*y;HL3`pI(cZOw?o{fJHdi8bqFns425!XBs@rwyQZ>F4R2N4`K$JLL{^p@s5zR?${HiuN3vA? zn2g*~{f!YD)HK^V%0Jkzw@GYYGpRjF&rBa83)G0y#|*hg_~;(H(?`*a*r|h2IW!~D z0guWVk|pY+hip`iTOP8YKUzOh4%j;;>PHO`+t-4HmjiNy#t$!h*+FFCW&fx>QQU7d*lKGtBw8y?Bl+UrN8Bm8PXJoo(xM&cZp$bN(%MnKRC`T=-s2}1?mopGj zGl0CD;>a`6_M@Mc{XI*5^iVp4(e`80$7G1SZ#3mIMm;uE?x9tuz|iy|w~B%gP7=Xm zT|;F9ze9ODZP2PZ7&3y6xnB(k1C#^Ma_9<>T=2U+5^q)WY1~V__?Y2>oyCc(iQE{% zSMD!2UbH6}5={H4)ObKO2~mgY5z_jHc>Uxv%7qRRyFVwkMj3f=s~8c*=EExalWKID zSPVe?iyXlQ=qmCju0@durA^npBFE@s%`V|;TQ#BW0P0J_zhN;YH;8+h-3=8Eow;mF@uB0H1lPW58kWzQDWLJoZrk)*)g___hHpc zmD?VwpjtrsH-)gc;%-3G7HsM+^M+7IdeW&|KCf4k;_k zR(3hrW6CzDC9`R@sQ4AKTb2ETZ2RjdJM219tQTG9_`;AJ{+dQ^{DatXhS+w5ICPli zVQ4|T!-xUI$2*#OBHvIldR(hqcT>lh$_7I%LyW-?6QliezS6(sWB)l{3GdSW;|41I z%K$3<%K$3<%K&0M|FVJD3OaaD%#iq(qy>K}X9h3lJ87XGDR0FTOg6 zbd4`eFVQ`Yx6y#^(-Iv06SVqM=nB<xBOd~Jncfa{M(+=`(x&R zE0cSg)c)T#O7nJYWdl20Q*Rfpt!&P%*VJ1|$7?D(cx`35w_QtbdeZF{-x z%aN39{y_Dyo7lU9IIQAUFm2L*7w#9Mr>lFP*hcitRy}f;W0@h@_c68gT~9AZ1wJBA zS9&}F5RK?Hrd08W^ChLNA!0vEPj#%pr#0j6c1&z*`--BW)2frdh)rSTRj;A1#Yn{7 zn(lF!8VF1Z$xLB3q2iPLw(B)6u0$PeGew~ zvix3-iS^wo?eBM0T5sRmakOfDFpuI!FEQS_NW)!1a3a}=V(%pKHswPTrrHboXEwv{ zs%hTws&*WWtP$(=0G@7G^C=wk5o_$&1CFuvwb#g+75nCr$1VJW4i+0Jq)w8Vd4Qv} z!KXhuz~M2}k1VDt-y6i1CB#N{?jc8Eym>WQ_X=X0Ui7fzcRWD~kk{6$^0m?4LjxVo z`sR%)9VCt@?`CO_qSw$q3Y!%Bnc*=9OK^WiVfTJwU+8kDkKuOBuhN#!Rj10AJi4@q zgO5AR3I2mr=2aZ}Li8q2zCk#>f=4JF{F2zJxJ+*aPhg?>PEeKUsA4_!2{8}aS@POx z;>eFQWcgG*`rhGSv5tSH0;6JUq->$h=18jVzo-fo+kR1=<=Y$+6GDHGwP@4iX`}s# ze&p%mPse5=DjYFT+6bn!PRKsuG7{sSNL5KZR4(R+GX(l+%oQhhWM~ zwJGe4Bi5p<<}83_Sml|m#T!mtnQ186xK$g!k=mFPN2l43yf`J@Lvg?EuS-Rt1jX<) zdRqoAae+kD2UtEO)&m)ipdmhzL~*ZTyesX%^KY#Yh5ZePHSpytqdGQTC#Kxgf(inS ziLI)knXPqVwHjMe*r&?eEZv3GYHCGcuS&b&#ro>bti!Ncjki+TeKT>O9dUHWBW>l5 z>ycsN0v$-9tnof#TgTGXUi2oXR=n;U$#nEeHg=|p@Lku?!Z*TUi#PY6O229u&<#&J z7{0IQ0g8M369@Vd``B7HR-EY}vXKXg!zibN63oVm^FKym<0Hgwl&fPl5+_bz1ciN1 z5C>S%NJkc)7siir+>5{RdlXbF@;D`JADy*pto;#JT^1bWNJ$Qjrnt3;IOHcbk0tgN zVq5My_|rM}Tf^i#Q;nE62dgfyK^443>|aY9oqTO24HECEjK)4#bxPYd5{J=T?IO~R zyjxUQm4!Bw55kMGOlBJ+&b@6Ewgy!i&15eHV=*Mlc8Uf*BsPCQY*g$;o}O-5$Kq75 z?NnvEiGA>L&9lf@hd0i*ONI9%>`uT81QOh_@;z!6&UI9)ZvKi2Z0uYv?mWDQqs`6F zU}CLd%DRsdN9QH`%!jcWdSluWRYy(rXvK@p) z2i8+mXi;odEE>yy@U)}m7ceiDU#MLBk=S=yc~$L(m)jG6pZbEMTe4=DE(hZOnF_-{ z5eGT3|4IYB&5L-zO}5mc7Qw2-s%OnwiM$Vt3t~(#jve+pAR zm?*r2;l+T%rqaCxuku=xXgS`y#s1x&7{c8dvjtvG zM`g3fuVTEl zq&V7I>#thJMDAxlyyW=1k$aS?R2&#dKIB%F%rxH7>l(`Z*H&hF`C59@{VzL`s>BB0 zpg|<-;VF34HP&)Od1jj~E*nQ_tkJy-!n2}!m=V87+rp*OHj$41X=Ebi&rz?s|2U=b z2az)zof51kN>@j|p*vpN3`bI|^;C4jeqp_rZCKdQ>1fvEb0k#{|3p3E1$dvMQ}xi9 zsLd;Fx0beseB2w`>dcU5g;jB&7J2;PNxsAJ59wwzk@nq4)n3JB#U@sSbgW2=wbPMV zUUlrO?`==jHpN!O0oH65I;%KcGz+Jrku{qwsc1HeO`X&@6-RC-Z(_{~kdE9zHmum1 zO5V?k{yE)@IkMudJ*nEJ*v*PWID9{aLw$)cqB&w)RvB(}0< za}m}aAscy^*v5)P*!wtHpJL3-ymG@u<%gTSR(|zsj={Lf8|KRy%o7x5c?%rfm}P;( zfG~;-Z`;GeJx|AY!*Fh{2BDj*2~s5bk>V?51DBf zx0T_BP9Fx6-3T%3P>T5*A%@$G#wB95#${usCS_uJxQWvogR#Un!&uyGzaTTqZw~Ua zv=+`Sv5`uz;`B`te=vr>_GXr3bb`WURA?-}B`CnsT7hgV{su|=iSk=Zm)3@IH&Tu$ z|0c?{rCdA85#`@Zxmze_rW{dzd&+g7+^v)&%I`?I+bDNC<%se-Q7(mYohe6@-^ID5 zMsVG$a{6QNUe|PcE9SieyXj@|T~UcYKoewR`FA>Jc)X2f$x54Ie-q^!6Z=)%Y9eo` zNo=Y@9E>5>&d?U!r-?(+`tQkmja27rPHg*D#y#5qbO52IYJZ~k3RZ`mBlH%_H zVOojuyNhKuuvBYr541M3_?}qP5&XrxSo@Zq*h;t-{!ae#axA!4Y&fB0hy@YD3Qg;U zZMgOL-p;0m*hs5VCARyVa~cH)%r14t1@?X@eK+q#d_cMWAH`#6`y2A_$xlBY?q zuNYXVnC|W8OfulKntQ*q(^a{R{V7%7S|+7?t*TjCncT()RI>-mq;&6ts@Z@txs4C0 zW)GK1>E4G`vq#G0HV#zH9xap7y^pG9kCn-7d|WjfR3@c+2dQRHl*w&;QZ*Y~CdIsi z%g(OFM)i-Tm#No->6AP4RN0(mh-x>qY%VxdwaX}zV-|avF>G{Dd3|S@a^35s++0_g z+{R(5+3+$c-8)=0%Pf;C7*S>bdT@j+*AG4I)WuTEcjF|$^*I}ar>G;HTPlZdS%Ev- zw90vj;(~r1yD-u@r%bSTR5`)ioN|IGqn&f`LhAm}*n&yVALATrsBRurAkQS6zqvSn zjj;0k&2>(yAXo5Ag(+sqby{#=V|dniHa2*ypv2kFOwY-y#M6mDez+SG2gwec(!S#lU-ex`)b*?DYKjhW5eT1Yy-CmvoUE{7PGPW@a$5l zU;$Eiznfv#G!{Px6`?gHD+=bK05>6XQDD;3<~ffV#9^9`*|M?T^PNktxatd}Te|?I z7Cn0*uJxG1{6d=8LTCRt_pAHm^oPK5`kBe^G~t{`^`lLI8H$`A*9eY!Ll#w{NB@FF zPT$or7F^^EmFRnM`F$^Onz2^WmY{DRi+^3xexm$0;BZs5R2-4-Fq+GcV$8BkoXVwQ z1#gxKu^?ht(`m~wBWBiq1(thY$Wpo7Z7Wb7Uc0npucnn{y9lpzdNJ$it1uRgHCyfc z82fZ?HJp*HU4wq{P#r+Oq2|kEzrlbrrFyX0GC4h7W?1X&e|3p>ZOIaSt0=+C@$u`O zJf?bZB{gj>=Kcm|*@!*xv;7;zviN*i$}v=2Zg7XKm0!uAVt>-jsJc&|ZTN^#2HWGsFD8(EuO&PNP>J#Uw@TMQQ2 z);*YK3(MatyGq*!^0N4kFp$WG<#HgFk1&wZv4W39NYDS++076e{&{(c$tu_{_dS0< z^>+ZX6KTAnL;?KbPmosm~F`zJ7t8YK18XHYDB1WV4O zr+@A2kM&T9M<4uC>meL=`mT=okKwK>(tf3^i-|2gweHo_sqHv6gx3O(J9%tq^vaUE zZaRUKSzmhsgGWjBcg{6&p}o}IN_NsNR$@nH``(GqPnHRrPKy2dyi|u_#IR_yPs!P6 z|AUzAaH$H@X>q~$RSj7^g$SR9||@z$xlDvwGmD>OpV+t9TA;V)?&0@r;-mes}hd z4YgZca;VAg#H#=9=HKVh6NlVd4LavjCRC$B!7k)<|(bF*d*;oR&PQBfn;SscCm#xA);nz(*XuzpS( z3H_)xy6+u3%Sv$9SMMN9x7XHlo4T9^u_2S|Y;5E&6kLAnEod$mQ+{(fgtQizj$ns( z)v>cABZ<>88OZ=%?7&truvV_KW$wiW-r&NweXw&kxYoo)eDBIh3W8}39Bl1chTFKj zHm+_lasCjcjc*{GZNfmUONSfTuQ$0?pogNi*li=rYbPc_PrcbSSiEFZ)B#Z(le~_u zqp`upTV%htvAMUoc3^VSZ z`-)xBuZ^YO>CzLdnOo@CjwcQcr?$z=dY3DJF&Vnap&b)s(zjY%wZ&t_{#0xg*Q~qI zp{A$aqaeNIK6;j^^;@Km(NE05FU zsn=|}IIwt)9^}`L&2W8DCBZs)yBxSLi&(s%A|GrEm@Bv9EDJI$FCWXEgL5aGOKpQ& zqhqnnb@}7M&r;a^el%>E=klY`v3X(u_*_30p`Yc=mz26dl3}5wtqXA?gg0%MW9eGp zcTK8peVe+&MbYnC6C2*HlFVC#oy2X}B19u+qD>aN@Rc`g>mpY@Tto5~qgUL7FA<}y zO|SKu;y$1~WtP`nwnr_n;%K^S5&N!JWp#<8N7|oAK9E2hu0!mrr&#q9tv9oaue)xD zjWndKb!E0UT;5VIIAfs{EOnXUY|W?#@glTXJQfl3H!mIZA{ehFQ!tE5xgEB4sq21P3=k*GOq}RZl<7r-ziikvaQQ-4w~7qWv)&Mw%aKe>_Tkn zpn7`~4ZW#X^(KPuyGsXyB53PTDp;`Gh4;04Q7q7x*spx>UQAf@ZS`tNDbe`^yB{jm z4f8HX-{wK3gFyu2L+KQ}GEwK2W1=*B=~~MQ)S8^7YjN7FK&>&ebZro|IHiuQz*Pfp zVXSm@svmipN{m^hd+@UCm9AT2gQMusH)6q+XlrE05XE&oeigc~u{02~u5y`KaFxr5 z8Q(ABCKkUM6cls|^R7n5#_~nT$o30D!5WaCr3u3IMGzh%1R3@Cfa`3c$Nb6;xjrI_ zt<%VdeZ;_WDETOB$H`a3{x=WG8~bG4@}(EJE zP~y9Y%oI;m{DR`A6%STyRh%lB*^jy!H2Y1(PAER0IH-8FUUbyeKc#W_ z%xr!D@B=7!kS~c(RlR5@Y6QoE1d4u=^3hQ{V*PSLCevuI0l9w~X&K<~4qD^lSX> z?ALfNU>WNi8n&kX{1*`hQoOHmrw3tZ5yMNg`-csWe{%e>*LaSC&{5y!IO%BYYVMBw z1t94g^bKr)78nTK>%?n(IB@W|zWeyF_gi~D_-a1y4jlOMKg0IJ|5-b+y@bQ_V|apI zD{lDXReCqBvw(jWw}7YCCKkFRYFriXcU|dxw6=x5w$5-p$+N6*0T*~1I0&2u`u^|X zuK&@-s`+VfV!&dMxq8dC!+E9KD;F)`QvtyO3xL(Y(?Hy!1$+zmE9GB=pASTe^vBG@ z|88*ojeQpK2EZTpE#x)8YrseD)1U4$d`#>Ue-B;A`=&4Caf*drIfP=*gS#p%;{OxW zM!VzO?!LmgN57zm;fX2`~!u2F(5b!;RDKR zEKeWat^K$Gg**c=0v*w;HV{!Pw7`cz0C}PD#}NAPM+}difxq-nAs1Zj;XrtIDs6%3rqz>%^baG({L8!Nq(}B3uOP7(0VY&T>>ky9pUXG(??{C za_Raz!#7m%ESXlw1-4EtuaGn}}SF)cQ+WYw)v!6cz zOw%jZ$vm7CZ%y@ce~O>~+TG93xAlv4eq-jXhWNIHetv0*pHH0!o)4aQTiZ-v1n{(e zTidLo4HN%WcV>L4T2HBlqTq8ByjQxYOijs+{U>_;<^Jmxa=+Tsm%*2z zr}xWh8squ+wL-peK_M4>wHDrhRS?aU$NNjPEid2bpWAzQ+I$=?bYjI46D)8EjiOrc zwyS)}oX~0ilCQXZHQLa&g=~T~>*x9(?k9cD%W<5SV%_NZX<0jB zJX8KEz86TL1rmZ@s+nYwhgPpL&glvYs_~5)FRt(ER*| zL_eQh#m_g!`g!XFKY#NUKcC#d&pAdtA9yLrFS+H-e(t%+&o8#|^GP>cLDS~cu7kxUTgT708>x@3mHhn7o!Hi${wFzucu8ykuql0;;t#rB$xZD>x(7Il z_wSyrg~f~bPGIos6{G9I(mCP(2}S7l#|4Y{Sg->SwVx}7e(E0^|5L};l6w~$ zTB^S}KWj&oW-WhO#4W!s;zhqcofB#AvP&%F;4wmz%F1ra0szHJ@JFAJux0<{$l?6wEr#&e2e*C*v^U>i}^HcYXbNNU?}eN2Jg&D zbvBzicQH>}K$r*?7^9E@UZrm}yN6f3Kd133zQ4&TuD4jl2LQ90uj1zs>j)m*Y!$yA z*lsEd(e7$&H|fu&xEEE6|8&_ZzGO8zSpt3o%-W^8J9+l@Sk0^TCkTDw{?&XbIEozP zM7$)dC1P!%qnHFO+KJjImuy##_LS z;^*PJyX$%`3}4M}8AA|Spdoxzm&ajMS6)uEO_{cux0y~5x-#@Ja1?EzMI7)%1%LNS zkk5sVA{SaT6b+)R8eeYvpL-mM|Ge@4gSH;EXaBzj;kkOl;@CVtWi=l$l^}F)=$0ig z0x=OU2?O#`e+0QG-hmcvMJ~$GIT;1c~QEm-8vgYQ!D1oT~~>PxmO z*+%Fo2~;QgOEazEUFs9=XnIA97;+8x+{SD8BY+6(YPg1{0zz-pdn|WXo#D~`T+3ts zSj&AE*Ycge{xgQ6=C2DC*PQr=Tm^mO6^eh^=zlXm{sOzNOLl?B+iV>dFt=XEGj3SN zeZbbn|8J1iWF3F&cJ$qO9k+sQU{jZMJPf!pGcz3NnQZVK*^kygdG9*@O}BM?9`JbT z6}>{=e@Aww7*D+?)^P#vU_vg~1w`XdLH7jieu|JjWE~fH6u1wF#_xgd0<1!vKsL01 z3wW$VT(n68RuDY=JcPhm;2R3cr}fXCaYy}M4zA;dL+kiwKoGD+p|Ixbk?g%Vo$^s9Wd?ppbte{LVc$LiBQ&K|Yf-nq?*7NZ|4ln@d2qXa) zf$O)e=aayvfW5# zt~=sQ(Pl4DfZVoy>uc~LBnyyyQ-68Y$nUFpa&LNzS87KP`beAqF7~Ny_}ae3pB_C% zKfQ5e<+?3xg>Uhd^WWmWg>UiD0@8v7L@a`wO;6lC^3_^(YR7Njx7OLfn;19nZ|e%^ zo4**j$j~{t^#<;0wSo6*zJXtAwt;s8oTd%DFXD@uZs0vrHt^dOT7j_a2J zY4YJc8~Cfhmv?XAdEhAa!SB0UFZgog{jr&k**5U!p4h;*K1D2aNlZvD?Mvo_?ovU! zN~+&zefPl|IR4Z(Gf~etI`a47PZiy}kx%GZK4v2)P*GmQC;v-+cTfGjKBMlAjjxu! zk$>ge$OFK5ptBxt9d&Etc1w#la;|UWJArP%)QuZ?@}`aa$G11~27us^n>X@@O9^bN&FAQ$vLN9-hSZD$MZfPHlNBQA@$p_#0$M!9FQxyF30QCE_M=gx? zjJv4w^z;8Y#-jc3|GbYHe6VW#pgwxcsNv?s$TP(}2>5_hzyu7?e|=-rYn9sHv#gl6 z1gZk3mKO6jz^zslbLVX0N-K-`U8{@vloiGNL&WRqTbGaeqLOFV`eJ@^Q!#J7xtI$b zMeE`#IvTqcp1ZDeyQ_V)kAv72(BSe0qlqZD*4wWc^_t<%Pk$@s0&krmj`|r#iurh8 z);Wsz__mk}h`ivpPZZ-7-0EvbEv?k~$i_{)!}3l1z>H0N=G0BRVB01>dms3tO?(S@ zDIhos;a>)l^iyw*+Ed39S93GJ7TjE8GyfV8ys~;}7P0>cK1O{<^wFaFW{>!<3`BAX z1~vfr6vd+EJoqc6%WG3nO!T!K{k(46%rk&yzz?-I^QnkWt?nU_qXH|h+svB-lq}1? zR4W^+sP>QAnKPu&jp&GkEJR()7${&bC+6JJrD^^)o(a4I#Le8s2LUUA zOF-XOxA83C9UyKNa==O;&$kViS^Z36PL=B2<1)7M8usnHsdGE8K6E>`Ikxjp; z5nqS+;6dAYE9j%hSAov~Pst)Z`JwInf@?cHSg?LgbGkK4es(+G{?c}S8}Q7;?fk@q z?R*I^^ttW);>*zbs-`)2wDycaS6^duZ-T{UgsuqDTEQiCMfKMZf2_>L_WsKtuAx)e z=cD@8UO8uD8b7pkI}dN$&I5oIuqba5UfXps1M`zP+;Yk^`w=-rA%E(#HU0hj@Z*jkqMbj}t}#^N2k`MW## zZ{SW~q1!1IxhO=u4j}48OzNjBsPEw4 zz9S7ktXL$YKoQ>qh&mBFsO#@%<*cji$^CmLmoV(&xdKsNf)A*8!+`i}wTe zA-?Zb{l33*ZXS8#m&6#0uKUz_@>BBT;v|DFLICh`hJhevy&$R zH30tNPJSLZ1$+&B0_+6d1=ayef%!l_FadZDa03~@V?ckPJJ1;z|J+V~6Z)(`tEf%uXH){sMm9*qwa%=$$cqlx_%)d9KM5RZs8a^?oGW0~Y>v@CC3y z)sPo8ElWVeMB7sR>4&}^b5o`Jys^8u5y$@dKQWj}m`Y6j)%Xhee}{hm@iEJ5w_H|p z7vGEqDc9}dC(&uITDv4#$L->mp*Q|{OvAgo?C!sdA9-jOU)!%VmZX*TCG#H*z+n36 zBRh`WShGj3-*)lh3)lcSid<+XkOB+@68_l5FJ2@FE$}tGz&79(eS~G~+p(U5EqC)? z$yc!RDqk}9f1{Jo@4*t=QGHdB8=s`F>M^!|?;ahm+rtG88Tar3z^AqM@C^zgo(l|u z7Z@DBhtC3b0fst+uHe{-sWZmvsWWm%?P@%2+b(|B2RK6j25l*UY5M+w&(t2)pm~Sg z+;aPFo`2hJZn$+f9|^zHyqh2BsQ>Z)GaFZW;wFW-ds>J;0C)kReTqdc3K91MHbBHg zePCjU&j#mA4e{+@p+8kDa#4u*ctF&NnBW26XQqWZ@YXOXNW$=CibXOC5qAQjPQ+U4 z>F#ImF?b%x5An>`Li~B4Eg*Cg#UdAlh<6400wN~r|L|dF!5JQA6WnlBh))WH_#9vvAat=}k&8macLE0i z5u2muk9>BVrT)u>`}s_TrT+a~zyP12w_E>g)oSg|esq8f>D z3)lv1hZcMu*a@vQ)wCMGUT7nDEf9hZf*Y7L?NewIxK18$AOd3Ht;;)M`%Ad zwuPo$@V)5Kj1Z^rJ0I2ZU(_PtHZAd)PG~duC!no}gWat(tt+(P8Ex=mWzarwgPSyM zAhZcQ3O_+L6xs{^6qp1Z2G_<9JI#VNf|~*Jq0QjiZuMaAVJt9dz%pnXcqR~l_Jcd( zx6q134LA$f3+)Ea2R;=w;Lf*c+E=0mysH!T7&-+01|Ob_orxU)Khjy#5}@c(y%zJ5?=N%ZWx2ApD2YUk@0r$9H(@uyYu-0GGE{PiO*fdQuzKZDu zcXgJoHi7*EFk{eyTMX2+zR+gyrbji+2^|Elep1tNp#x894`_oN7%7Ym zyv>acphMu#fnw+|_$2TSbOd|>2tsSwnwAJ`hc_6^zwJ_*Fl!Y07)kJhv#=n%NsSR5&6Gr0aUI8e|g@M`=TniV<# zZt?>5O~k?X0p3|y*H(y;z$7HR;3I$!It-rd#qxpnfnz7&q=PnsUj+7wdho?bIJuy; z$(rT>PC&cCUjP@N!{FhsV9>J>2WL*ffe;#eaw^t!Bbdlk9I0tIBG4A_l<7E$pnc%9 z0_*{_4P0+7_5j)h?gDs4J@}XTnl>I>ktrxTn zJYp+$0NM>M0G!Z%@GiiU2@`@S+J+MVIskTT*R#*c+k23-@4o2@P(zSJMtco4~t)6VM@W=Y6V*u8|(nI37mZbgNF8kcYTWiLWjT?fo0Iz zcUV6_fO(LBX!#?i5(zW-HXsCT0lR=tq21t}z*o>A@EPC)bOih>@FTSLlcqg%20s!3 zZ3BCN*f|&kcs>vZ?FWAZBtVD27erAb80{>+?*~YRHiI7n+CtmF#-Fh;p#={G`a-+G z{eHo5g|>ogpU1UM)PNI#OlT9>`x|BjTJW(8IIPeSaLyl?A!v^mV)CCDA&d{4_?M=w zgf@Yn0JcNhz)2i4AmZS=fUlq};B&wUXiYO{Er65IW^fN60&N8+#u&5<&?azez&IB* z;FK8rVpsx<1?EG*1RVlb$9Ji;h8EwcvIS@h9Rw%G8nmv^X7GW^2CWx#82n=ugEkO4 z0^V2EpxK~9;Lm^@Q3HOUnnBBjwt)`-lSI6l$DmcNZqVky7{Oj(KD6LJftAo&4TIJI zcn8`9{;{S(+YTK8{|SUdO`Jh%3VbSR!0mvqpv~ZQKo~j*{uTI9)Ymd-alm;Gj1gin zZ~;01zUMlF7CR49C%87I3)%>t4w#^Q;Op??UTsAjyd6k^4uSLH4O(|m10G+;pjm|m zXVo=mgP`5u0f`3932g&=ZmoxDfw6$|fl1JQ@Ht=>w3dV-zz^*Ob6};2*EeXd0>z>p zd}{*?1lj@~+z_(@Z3BB7VJ4sjZw5|62f^P0k$JfOM<9kb##A8T28V&z*KlmWHJcc; z1ZX2T5imiUz>9!n=m7YJrUuOnZ3Z_q;U~{T4Y&(10NMh67#IX?1MdTD&>`^mCLI4v zm6aDu}7i?d;pjQ9R_bnHfYPBgW#`$cSIcQX=%`c z&|Yw1D}%Nd+7AxiV9*YVdJjZ=YlC(I#stm=BBBA91DBw+Hs}bbHXm{D2S5UJ2&~;` zz^@~t27DvX7TOHH7w8CW1-}BMK>NVE01I>oeEKHz+Y2TF@hdP8T5F3l02l=A2fq$v zLI=P%x5ErUo59C`=baQ^SU z)u8Q!34tvgF)h%7Z@CSN1=qCA!Y*n1z>~@ zgMR}OptbG>Z8wl4YQQh|z}`dqz#D)R=pb0@iJ1`f;QfFFIt)Gu^o5RqyFY|$1GL8q zF$5S0;|7ldY|uXN=YSJB47NXvy%ROyXMtR3FL(v;Jahnj1{e<=0e5@EpiPCgfTsbo zpnc%Ok7Gum!{9Fl;rJH|GYEV56xIQ>30w?>p@ZO_Lojk^E4ao`9CK(R_)b78#0J3g zfNIcwa7#P-f;NMf0BxZI;0H4?L(n$xprXq&PP+EADvIBg{MOeDZ}jK!*k zwt!aw^PvOa#<@7xp-tdNfwx3G_|NCC4xqK?4O;CN@mK(D1P}CL2Sg1xFb;$EqaSdU z@pugIz!)L=14d{o_=Tz1186V!_gAq8(Aq2v0_YAM0Dk}sfDVC^XJaGKX7H`RAZQDC zH^ZS6HQ=*AE_4JueJ&0ev=8iAg#Uan0r304EYSemV;&wAp{?M}zB5Vwt3p9fE zf+K(lT5uIVW&+v>P5{i%CU6I!BeVtlFpvUm1Mdd9LWjUlF2eOd#KAW$#;ib_!GACI z;35E{Eiq_^055bHyy2v4}2e|htS{|K+^xA===k#n*TrkvY&Uq+S!k?*xG4rZPnV&7>4B1 zQW#wX6ss1OMnm*{y#ILi zc)ZVjpL^b~_xpWLwbmW(hi834#kd>pBn7wwSF}?xZo>nga;M;7IQla-EpEWr&$&Br z4c<)d#NVVt*)y+err=f|GXg zdjal&kL+Sk;C{G?^x;9c*WAq$jfMl0x>@5EE&zY{mYKlA@Q)s<$7Sznavmwb-SC2a z+y%a|pgImOCtbJ)t|Q%e5bh@jaR=7k79oAO1-r?BIu7UD9wAY$GazW5b4P?^ z(s09#z6dGAgYdxo2r0+IaQ}h`slpw&eIaj*hv36^GicloXE#KMjr-s!(uT`J5wdFu z%Y!@cs>TR@TrPu#aZL>Fb@g>kl2@e!=>8(Qv+CJ+?D-co4qS z#oFTmxQn>npbz|kB;sM%vNM9`I(^{z-!f?24X2V)+zS`&VI$)fY~9EHQ2k*C@!}y9 z>EBN^G{j-84=}x|6CCwD(~BE0=LafN4$}`sNHea(*u%UruE7Z;hWhSUfBF67sPE?^bZB&#y=6JTt}l;b%Kxo%PoQX;RO=O?{>Tq{F1cb zA$UVvq^wu{VOe~nbgDjZ8|hMgU~NLAIJgBLBYn6ZYKi=Waa{2na`H`{|88U!iCWF> zg+b!N6-OmSN;+=9-MoJa# zfj^mPky4{hfJ4(Gr5@Mem4hS2Qk~#p(uDir!x@p%tQ@|X&8*-7*gZT_+HeP+Af346 zFo+S%3a-HsxslR?8?a9WH^a!Hf=C&lVZm{uA|k2`S8+(=o98}Ooe3>J681-C^?D{jHX zqz(7OO(ba22qHJvL`nzlg-d*_r|JZE&8HgNfv!8*vA6~&lc=>!DO^SpaT{K}fGX8- zxT%)H@E|-!O7Sp!eIZ5S0ciew7jLFsfHUu*O56wEB(S6m)Cq7YDaUR2$|pQP@BrLRs&EHx`ZQ8z<3V`c7gUFP zVLxfYWh-|UX~u1MjI`ik<=a^QR@FdW>7;r*05AEHN^uX|9Af?OAe`1kmADt~>ShD3 zV-PT757pp0JpX$(8t#VEdU*okUijf*28svakt2~(hlh`-`~N5-rQwHrNHgxhyZTrf z+=93M94P_Z2gm=)(%^0wcbw(GHTVO-R>5m($pa@BEIoE0So zZouioqQs4R;rZDVfV*L*9wlBp1f3iTz!m4_Mu~-+KIG+*R6rvDQ%6ThE3U)7F;No4 z!_XQVC0)4URo6vHFYbXG<}lFpR19ysJ4!NeANMgQBsPB;kZ|$qyl%tE>fxbz+c|vja46b z-)g28x8M`4QR2h>aOfHe!*!Upmco?7CB$#4PRJ(Gj0a)+x+oqa0_q-YIhqF?mr3d%HYf_`dwTW|~J3U%5am6Wv zqoox0z^ozBGIiQ<*Q5n^;3=|7^_dYZ&yxUd!_RMymLML2SI&%< z5biOND`!W`LDhh_kbc|;r_Z4p+zVIyH(E~OHvEKW@A5|QD9OOX@cCP#MaOM8q?#&m z9bP_m+yfg(NcDk>?uwRf+=7{lqNNwt;RZ5*2Ny;2_5V6H%NDAEeRtCl55rCOus(PY zPQO1|#^GK##)_6o+<@Pa8r*@N2cxA9S3K~)Xlca5@VtkjWjXGKPm%y`!$FG~^cJ4~ z8uB*j;DsPOcL}3bC%}suSsLZ=#>ZF!+zVqKXG6Wmxo|tt@eq9f33fOhgpDg0H13DJ zFEVI64BJ*RXw?V4YuZe;YQP0AG1a&QA9$Hj<9>MKD~uZV!Uss3Iu6&7c033VkWM@d zpJ<7eF4YIld7ax5_rc?;K5jZ!_&QyztOFRDg%!hK5U#<=q*3*U37za4bsT<0TJaEk@GI7TJq`a?(Xu2& z1HLe)HlTp8q!%Im9?tznbQGjw-O$u=z+}cescnB7KM-jLIkL~4o zgNOH;(R}HQYSam^<0$vKIsuj+V>xgS%m}mFaUJ%O&3G6(e{c@2c-o(|aSd+!he6{Z zxXBeGQ6Dgi@X@3g$;AC|*q|73n>2LfU~-Ij@GuOg#YnYsm@_y=EZl(4ktW=R6@uAgNNXX&nO1B;WyjZ`JXU2xaM0n{wF3=ifsFiwc&*jyml|6!@Y3# zJ_e*tfEVnKk=eK#o_m1hP!50jfdS!Rc==)O0^9?4lNQ{8B}Z5S)gOLG+SGAaZyses z(Xil@K1PjuV2C)l;ycHv01ra<&nyA1nDiIbv@Ybs!`aSwc*G~od__*!NF*Wnhj91mV=#!Bi9v9e0N0E5$r zdI27q9xL5=7%sepQR5bjpBpQ#&zN=?x-V9AT(Oq-D#I;U{{Vwi4liFEE7iCMzDgSK z0Gzjk!I?CC$e@Q~*`d5Cta~(8Hscn&s)>u>9{A|vOe5}x3!jLU0o4aCSQaZ$pW|>Z z$;2IKJj=}CidVhBKEOS&`NdeN#BFHq+o0N$K|D1iD_ZI zaSh6=vC^iF!(U!wz40(~UMINXgRAJ*!JuK{8wA(jGLq53^WR1)-;9-9Uhu*ttJ%Hk z1US$dE9JPX;rIsDSRIE$HZo9LhZhqIcS8?pz!j@WBkqHrZlVA@1jlWm0M#FEdY`pw zqY->RmaosmN|$n2@L{a<;s(qQa!Vb zfxC!-J8*!M;bMLkD~mpl6*mnF=5D15+fv0`LM#eQ*w99qS*pm5qR0-^1GAUbu#2;sMyXj~$MO;4p_# z<2tM&6{k#Zm4GJOsb`jpb1O8~6Wj$GQDzNPn#S_BXem z@{>#v=~n(vtc*Uza^MEMnViJEa2JW%#+1VHNSA212i{H!a37o#?UF*}@LA%wgE|?$cZN&+co24z7TkfmvR%@u94^#d z(uP~GWw=W^@c}lJaq+w4U2@W-5k$(LWJ7_=-!Gsy@(+YoQTh zD&X0q8F$0R*H{kR4`;2WGTaBpu4M^u15OLD`*APqA-%W*6V|a;a1EY%+a&|IyyKG5 z8(rf1nsebylJPaqe;@J_$>fDF{Od!Pb@O?Np5G@GDYq~PM0((htHB0+=f4rRy+*P-(^x64figWY~9V8;UT!Fn_CCB;7a1)HZ0#m zmAD6PA}8@6T(_6XzQN%kqT^whx{qRT9ZnzxxCdtJ=T1?_O=QLao=P;laLo_wOgsP^ z4^k!WhyOc7mCE6;Bdjs5!@o%bE=OGwPyDzBkM^;wco_cvGfS!Z{6Ya?3dTLq^&9Ko zp-w<z3by}QwaqYA?Q+}Z_TfG23j*637JOuf^Y-z+5OJn0?Dei{Nt~gnR+wk`IIN6N* z;D@9G4?=H3oOI%fuaF)*0RJEdaY>95i-dRZ{8utGnG1F?rLdZ0;6C^q$;54#s>O+} z`oO1%p^n2B)2LE8+(s(#5d1hjj(;)1Vfx@Wslj#lI;q72@M1F~P8w*qp+%Z;#RH@T z55s|>aeN~JqdtQHkv80h|DGAgHyUv~Gfwi!LEM0oNiXh!tFovP55O}=#7Wdn1_5W0 zOx*M#i-}Id4-@m^qyX1oJt@O2m^v~}+_(;JB^9_2wvM7=JOGatQY9XSFO8)zbsW|d zQJCrv`@mmrVqcgv!bn*aqsHB^ zkr=oiHqBsjDTim>%-X6xuyiK7TsaKPVMF1HGv;v)?u8p~qX0Yz1GmS?desLWSinr< zVQ4;H%cyDi;YSPOqz@0l6C|pe&2<<1VG&b}8*l;9aSQIghu3fi9;|17;9 z32;&{PU>(EJn{(@;9+<{dz{#~8`hCkxCP@rr5Id;xugv@;7gyyNjn~ZH*~NUaIc9x zLV9WV;gT=d?aE=nR+eB7C&R^Gvjn&w{@BGE<6)S;ll`Ikz?;5}<2NYY6yEh+oK)c! zG2mh z-~qV%7;A|;@cWok zXvk^t@(}UhepntEFIBh)Hj>%uIQ)cE<01HSRJ{1`F#IMuUM$>!>to}k2@k>}u6Suy zec(HZ@zSD>Lw8cVwBe?b$)tmZ2fjf%@c^7YC|*Li7j7dxcnH3c94`k|A2?Zympiw$|3O*wU^^?Ey=(G@Y~blP06L;H=BzrA9fdSHUg#7_n4;*i0I58@^5&@c`@~O?U{7 zxq>Qj1DeFfE!cN;Jl~ASo`B{Fercy6Q{pAn!yDi_Y$aWI0G=X_>T?aRlRi8I=Um4W z<32d8Dqhm}Go`Sa6yiQuFoR{q4fwxXSXSH*Ze^))nbaly>JdO2Wa?^h2$h|!3T&OVAOCKiNbC8DskZfxONFUUpZ`OWM))< zxUGqS;32sCF>YPlfloZn#Z@2JN2>AgKzTz-_o>DNi)q5C2@ogG=>!CSK+(r+VB67m@+og6mdL@Bx!)N8Yws%kObG z?j@?h-SCQ+sRsAJounLh;HKB&r9$-&CIu*mdq}yx8;pjmWlBgJ?t|7_tRJq}ypBgNZo>)h@bJMs@Cb4Jz#GBV_1u1V06wyT0&qWc zf)s!&uKSebz=QBp;>FDna?xj0K*J5|NHuQ32R>(Ma6ioL;5FQU!@gi?a2+oBngOal z@VakU4%`b5?qDLuI%Q zuOS7v7uJ(P)gQ`Us>Bsbh#PmqoAy(&>JQhEX?PGGAys&IzsV>Zrb2asGY?Qb?t@Q% z&uxj@@W>BbP@MoTJ;-LnJ@C@QJYto@yGSc;!O&4=0#}@LjG0hAu9Wg-(HCe_rTpG5qIF;DdH+xW4L7{vUpAvU0gjRc3E~Faby|XS;|`n?gCAFLK|BN_ucAs^gL|%KDRBoLAqVj=ESW-)xEp@sNsw?a&wmFwLZS}S36@{O z4B#Hvb6tX@;|@%#OprochZ9Mu>H~kgo{I4>{GC+dazlc|lWDjHmrY|?aT`v*iGp!2 zyx-)PMj94;gf!uPxR&_w0DOHG>#7`fkpS+%=-COf9@pSGWHauDb4VNRgQ5Sj+i}G& zZsj&s4hL7WJh-VNcalCD7Ce0}I~mvEStRNRZwhZFF5C-ul0@8rKazAj47293KX4uP z-j*Pl>NvcvhPwdw!hNI^ci`{0v;Ji?(`@iHdHV6$jJWK}gFf4qW zijQ*p!OSPQr*R#gAi20al_2*#O*Oa$dq@TDz_m+RdprQoTgGn3-Eb|bR>xufGZbdh zFp&F59d5x7-{LO7gRnQip1{L!;=9}hxCg#U+VB9}NP?>%xU2zIMB?!eeBRE%pd z`91c9a%c|bmmV5AjA>(2s2AXHau7G*Owxz@piRQK;$hN{hoSL)f}B+S;TavwTp#ZV zD~OJJ;7pQ>`{1jjpie#jk+Z*Gx_QA3ZzpA{6I?;uxDEdzlX2O~!-`D9HCVWfTMIYf zc;dy~io}O2&LOq94=y2fxF05Uvi|inw9W)s_az$&55oU^#X|=7!rfnUYvB(3za2~? z?t?qYL3JFabTJdS4!_ySOsM1V?_Jy-#~AeP1o`7z2CIBeg1kk_@qmeJCKWV-a7s@C ze^6k$;Jpr2;1e8urJKrf`?)0uLO6) zYe^aIg$u|y-1?RKzxFrQST*2pe=rlcoM4y!#Z2HDJVLy980P=Yy5a`hev({?dc!-45arisw!sX&bi6-5+23NQfrAPILeU~K4LDe6A zIDz8uAiQF7qC|z6MHqc~qA8g)w96Cax+@Z;0QbVUo0$o99C}EFIswj5ZPf?%&rFm` zTxM~M)TlntH9Jv!xTg5uM5)6SKfaBbz(ep`(tyWJ<|j%gZotddF%!54M!!vExCUP)VLSk5zQaDieQ?71ME>_A{b4_G;j)3*BAQ9V zMt&vf>V=JovU5|SWZ({5vV~c}{c!wyiQGyI6n@;6D3kFJJm+I(LLG-&Z%>jMbsTJ`L z^x%rKmn2EQa`g|5r>mxDXzhJN0Ouk_rVUb9uGm+QHoK0VAe5a z1J~hM$4sg|&eYMkjzr;JxShE05RCqr3UCdUl1$Yf#%Y5jR~?5F(g#Ty?tx1S2l0_y z6a!}$4U$#35AHj6khI|rTzCE;(fgT26Pb4@C)4o3vu+wBRk#~A&KxAmaX-9$)*xB0 z`oQwpgCvN1;IE_umpOwZ@zy~S!ZrB*U4z8IgK+xGgJb~r!ur*NMEjjtgm11LBxV7P z0P@dUgT#&VUs`3$x+GHDu+vm>kkGBb9xvEZouM0 z%#d>U0;$Gr_)}!E)ZpRBWK)uplckx41|2O~I&j51Jjv3H`{41aWC`OkBUzrfC0XO_o;N z2me0C`>OswC(D)yO@eq3rkgREbkNXYNrEOJ+zoFg-MAN;nkEiz!OB!k2Gnu*ZJNeM z+A&*j{a{U8cn~f+Q{$iL=?`aQYLbC_;hiK`9fwbm0^GEbsacv7s!s65VVacUHvBwW zlW}+mR_L0P;~v;aD%5ei*^gxbALEGVvg6dz1?+ho||e7}sFI)0)i2 z4S2xTq#h5$7eCTuDQ?4>&oybqeekK>nzXCqaCmfzbmIoxos=SBlZJ!5m!2XSC%G8x z9F`*GcnHqTPLT%O2Y(!yB29Q0PP{xtT5u1Xb#;ogsXp+$N-luA;YJe1gRp;EicI^5 zS-detcFs?cTHJwV@a_~@Pebw92UEoLFC&EqmZXS|hvABcQ>08Chc7jy@bw|?0$BEV zirBatMm@v(;2NC%GDYBCSid?&4&oMktTjbW;(qw`+g$4u&wmG5xt{7zaRK<~h7`%g z{qV@f6e+;NaPB85Qi%KD2c#Si!m3YGWHRoBK~kxX!%2I24fnw74pXt}1FtyFjH=_% z>^D=yPs8d@k=y@Ck!IWnFFchZ0o)Bo$ENacb*vezA&Gowr4P0yrwTVG{|c5W_ob#v z0dB!LX{j2aEU}-_BRO4zCCMhMr$l$*J09~snU;YFmgevOy*NmG&qt};s(5qOvAmft2R}mta zh=(w&icOO`+zTTT(quiZC8U}1*Xe1}NkcNyemLH=(_|bCH=OlSnz(TvY+qf}Y5Zk`LBkWI7nk?ar00V)3F8hN{!yB^_}>?%fdq+0L$UUg zG)c!TnDr?m#dY{9DZ~Tt&d(UM>I2)qNRx6r1lM(@@js$@A9&N33>5dmg0C1TZon6R zpg7!yQxCKLEvnPuGLaqmQpe$jQCZTA2VsA4mbBuW%{MD$@z3lO0FTbg;zLJSWBC5vS<YzaPWR+2-jhclO>yR2hM96ChfQnmbDL)o;Yql zH*#Qjw)FEt7)Iq~OCtX+q``-;&X!!<4_}*-&F8#OCCv9^O9gJg>#xn0dfW@Ysmc~V z?!X0ev&F_OICXxuY{tFt{rj_}9S_3&4Q96V&~O^E#oNfm`GSPvhYx3qfd^sMW7$%M z>+tJk*;0->@INcF`FbP$;n^=|OB3#f|Gb(lEx5dvEnmEqEp2!R8ejANi3}R1{+um^ zxNahC*}9a|2*Q)31{YnIQzLXfkOt4yE<6B(cj?lHD^^;%L?tn3c+&&An3<}9{PmD7g}5x%<&h_KDZ~BnnKfJxx8d*a z>Qb%xY~lEa3`iY^t3T7F5f8x2zS8-m90mu|4(YNU*I`TiaOqTi;DtHEfol;S=Z zSCu1^aSc9lbB;_?ec<)p9KKhSS%h!hk|T9^03Mmid*NYt{hS+ z&vT>$w_$k)?}>Zh!&`Isn-znGN50}?E>d{@hmj|D@CGz&`0uwlQi;nR21b_RicLK^ zd@m0t!`Dd*9)R~8%8^yL1)G269NdQU|KP&vIQ;xCiorv$DRP9kQh6UZH);fHO2Zd5 zLe3a6LP~KR-jF{+DsV3hjvXPham8nfM@Tbn!xhE|v6aJ}B_pI2ci@4EBcu%v!z(6@ zkS^Q)v{P~|o5HWj4 zNI!1D{69uWVmcRtf5qmC7Z+Eqq$KA`9j?Qup}Blc2>S*u&CZooxD9(q5O?5v!*it_ z55loIyoMWaJ8|$3G#BONNioVh4hYH=S7)a6PTSDgGH10O;kIJPNQGKZ+!4|(FTTq)%RKfGgE zuDEd@T;ED%co0T>L}j=JpZ|nG<2L+eSFR+UPQ~!n1G$om`{3ifxl)Du;n~L+5blOw z{hKRIcnJO)XXZ(WhQ#N|#DqNQ#Xay3l9|Er#5_4YIZq039eRlySG;;`o=nC)u%;+a ze7FyeDbABx+<V|<=;;kt>8zBo^M)Cn-=&OGVEH8}CEJV_tQ z1z^OzdHg3Nj>EC{3~o z3(w$9k#(=;$v8X+-K}|2i7SqKhw7BWb2jElgL1gw11^SJ@X$w8gNNb$U*_>Yp*RjN z-I*r?xCdVHU7qBgiNhiLcwb!KmuJfP4%0=$4e$6qPnP38So1@ktXB@_{+K6i%HhZ1 zJn6?n@V?`Dl9!FT8vt|8&m=bR$Jq zjg&@SFknl~NLh*p;G0WEN~?0{UN%zN)yc5%MJ}TH!`t2(DgC$)8tX<%Viw2YiyKBt zI&Q;5q!16o`5WnnTkw2yJENlEh8>}iV&fs`*)dYqcy>gZ~{VwYUza4$YSq+zT%|BVW33(}M&_4-Lgv&de7F z55S{Y`4Yy%@Qi|diOS}U;02@-cf+pYe3^zj@GW<~)ZhX5>LvNopd4N|Az%Es7yeVu zAaI$OFIP{^H>H(^XKKF8_;0@SsZMa}TrQ^L@Rgc;$;1Qj#XIw*9Jk?cD_?xL0WWIE zmqy$T+aJo803L$3HBuPvgXe0UfxJikC1a0`x{ zP#|I4fcKOa@cR?o;K$KfBYQPPA<+$b4IY}|n7C5)0)xEuDTkK*SV zsZN7ONz$ZI(ur&E>&j7b5O-ka)KQXN!1}@IBm?)t{nJPBET9jZSUXA#+ymcVIZ7tu zL3l~aDDkS}P*#tUI$SYt!zfvg8yiNM^7zJ4(nG@!w+0y%9)h_akCH@QH(+{*;5z(l z$0(`5L-5icsTlXb$kRs4DqMpTvqwvhIu3{AjFx^}hjn8{%SqgVUydCulSi`wL&$%M zM~infmBBUV&=C*7feS|SZB~r>!qIY~e6+MEpEz0$&loMeco@!%HJ{}?URxMHt)Vl<=SjbO%~TtK}5uZkWct+)ra#Eg;6cmSrk z#z=?i1Aiesco_bbI7S>?lE&~|bYu9)HXLr9O1qFEVPpLmzDJC~!SRod5d$~f$jVp7 z$YdHeY<_2qc$LE&J{co*xEC(`d<=imp#nH->li)zCIGCTw)l@!Wk+ykebQ^+5+ zI2mp~w@^A&AGo2cP#io6e;HRO19%vQ?<$nUVjK=ED&&u3%t~FMRNPZ2<8aSCW});h zDU>?Z3C?)9Q2e+TWaZjm(L8r1U4B578Qyds&G&meFgjJ>Kz zHml=s{?sCVI0+TNFIF%JJOq!eERxJp-V{c^T*P-s(jP7-xwsAYwiHPL?!dvX7fB(m z!{x+KeN5ySDWwsH7p*E1H|~b-kP18qbKWSDX}AHOCbMxHUiD@XKV*+tgrBS~l6pJ@ zkE|(@rFa;gdaFoUalRQ;N=ZBJhPA}(qG2Jgk%M>u?jpUo12fhYNguAmX`~JR@Vu5-A++eLCUNyk0#MWW+2yy_jQSI1$)`XVXA{p-0;CvK!l^#Y9DOl7zR7n6F` z3AU3)JOnR$mnBpEVFPJVec*{LMY0~3_ljiv`>a3ihWC9`Bo1!DoKK2m05{;_PuUCS zvH`8ZU&8q;CK5NH15E2zh}_68~*Ym z1H{9M$5?aR4{fp@S4=j4W~0&2U%EGU^8*yrj48&U@BI857i?zgka0SW4Z5aJG zv!(jLzlnj%$s$=v%2glu{=eLoco6QCVyVC#SaVvjcyJ$F6Uk$-l13o1SPn%O%QQR; zYhsF}N_B$o6E7ZwNwK_!Yw&-h4)?J)lQvG52&|+~^AGqX#pDaC{E z?!01|j9YNsXqH1AhvyWs1h^YcC@GeD+ygHwE#~hEIIJ#X(6|rwk7v-hTwE;IU&^4* z=l1g=$&-rtt~4$T)2}X;Zd`{33FC?@Nk4AGRYWdes^Rb{6o4D>dZOW8nC;=ca2*y9 zUG;&-NiHte6pQN`*59C^(YWxSmwvLD)-X<6$`DcJ>0U!)c@j_ukI^-%O*Hh7Gkl z*hIMEIiwMH!)oHkeK6HWMYs-UkO1z5FOki70ES6Bu2?$1SUPbx{QgdgQ^#TR0{UIZ z2DFi`+G07$3l4ntE(S7=<8W#n>yLZk4&ufgn0_~FkL&PhQlf-fz+v}tcc?xv z@;-{eH8|Gd;rW_PIB=Oym=!tfqUWaWE?J= zxc`HjSxXv<4O>`C+z*r9V#{#H`>Rxb|ay6T$;< z|0mp{sy`h6DKmk);rpL46DExya!Ci(;~u!<3pSEE0p7Zeig6!YLHcnU7I(7VxB)*U zi5F8P^nb}C99OIiQ8Dg?pOSH^4}9-y9%6V9nwNY-#WXzd+C4n2)Cq9jcig+U4_?;8 zOsGEa9^%6-D0^8$T(OH-xC1NqvnOyb%sR-Pz;!s|D0@O3hw* zz(r&gZoy|_3~9w}m>*~GBl)NpK0>;2KRiMlJPaqt8`6t=;BnHAOM)RUktjFI0bPlP zq~jV~muMQI(+JX-m1Ky4``|9(#vORsAVVr}59}b*@DN;_Y)Cckhvk|f^{Nl-AWf`1Ab6oNEi>oGe{2re&XmQ;UOQ(}l&NyCSXJKGR1?uLoy@FK3k zr%9bU0ggDAif{vdbeSc9Lnh8A8TBV#sV720Zo@ zBgezAYq=pyaR)AXk?L>@S~lyd9A>@3PR4aO^EKWW_rdDdxh<8$_f}CP9)x9YQY7w% zXSTBbdW{q zSue|h+i>Dx28es0=LpN89PU5L0|+!^0#U55r-o2z3`JiXyYMx^8jn9j>7>`kISEIK+=Hg@KVx>~Z zhku-8u(ffTAf z@SEroF>nW-A6p`maW{Orl}IHG4R#YR?!d=~l}HWlhyA1um+TT*ODsG9dq$K zVwA)GjVzHi+z-d*mq;gWz$v6>vU>g_>4hb7kQa2gcx;KBR42gxA}YI_3m2EjO$OEA zUid*tiIm|%c>JsqsZf2+E|GfT#Vz_ECYA6RE=&TV%3=FW>=ir& z%_`mtx8R2}n04F?B2WFNL}t^lq3`Arsl^q?dD$$u8@g^O;iKBA0DeH0<3X4^lLBx9 z?jr%*fz7v43~s~a)l9o``0QM!T{)aEkM-}P;h9$=$H+-M43lsBe~#`y;OhDQ|M=6i ztxeiu8sFRN`^TgE{q;Jp_xt_&^*&wI>3xi5l8fQS?;8zo;=~^q4KLv8 zGi@YZ$9?A;4bS2^XPb83jraV}w5K*W@<#^1^LW+*9ZYQ&l&$XtHj6^y#}}G19*eEb zMK&a_;vttD8rygdhcB`7yPOCoTMkH5>bPj*uLr}X75Jga8fc{ko5?YxR7ueJodgp2Pz zG-mM%-g=)~m)G#&``xa*j*T^zfG4hdz+fi3{Tk$m2aU!H1)T7ZjguUo`MuGk1Mu8G zxJ7vdTTj{fJaN(not~mS4u8fH@H~F~S?`QIhet}D7jd8Gyh-sa9`>B|pRG_(xad#r z0$#ycf3RbIq5Wdd*EmjAgU zlH-x#Rgu$;h%4dO+1g|dbh>aRF7l(w#ByOef@jRYK83zb^Q95 z+k9V-HN(Td(iXjV0Z;#GTlC>2{5abd{dnxx7MFdkE!uenyZT9LkDorkh zm)G#k5pA)6w{ZC=Bj8o+FYt8M_crqZuFQvT(5cJUysmh-ohzeZ83otaP?%J=5@S%s+r_9+Wfzc<3I%-ee4B_j@zlj_F^iY* z;w47LD|maQ%@faz60iGZTP);N9CC%bhUf9=rEWFezyVho7|-D^uC@fcf(Kk<3CigO z^3b)GfY-6_awC{&+Hvu(lz9cWUvCL`++a`01m41zt2)Y?c-W2ZZ(hKAWdX0_%{RHd zc?}n@Xp3dMg5^_hweuB9IBTWN!izZOcGJ%D*#8dqF3;hWvXfWw{8c)7q!Z!scj_oF zVy-4UagV!olxOhmdt8IJaJPGP^vLw{KRNWiHvhcpV%Y!wwpf}D#xJa~t9cgRe!y*+ z4#xUJZcCnc!^75`SMi}o+G0nl$4BaJzoR&Q?XkAV@Em?1eR(|Yjq7o1K0u+N@a3oN z1D?fqWkPDS!CFg!CpKj^Pb@s+7UhZiKkH3~=ddc>Jn^jO?0nvhEm_7BpJ>=0yiq3k z=e?~eB!1xqqvTn9SJw0RV_W=6Hu5UIv{6TR6ZibHx6;%eAD5lHfxB!n`fr=#ig&?RLOCV zzZxaaU|Cl1ZhU8pLGt*&w)p8kEMcnuM_W05{HC=`1uVa9EtBJ_cdR9^;VbVO%`Bb6 z-aFmLJc~!gz!=1fc-*c7qcb_q`P9Ie#Y?#9vjbx;Z{p-V2F5~Oz#I1+7?oKzV2zyD zcVMjaLIqFw^1xV~4#x4{80fn|9Dw@|b~2vBtMUW=$5SK5k0uR_p5HODE^THFj4aRL zv^fK#ofq-k(!eP23jTJX4)HpkR9-wVx)n;e*V2LhQOU^g`Rc%^@g`2aabT?H1$ zderpsDqjEiz*vwRS3Ef|7V{eRc}hol7B78vV65U5eElV}#asCJ%Vvu=@TScJV+*h0 z`CD}~wZ{{;5A^*n#~A(gf$`^$O&xFI=-mcIJI~{Z`wWUgYJ6-oAK{&;KdZ$Pt$eisih3dt5dsR;EVy+~tE}HE-Y*R}6|eui{xt2gL^7jYnTO zC^qpT{U4#2k$85}Ek3-=v1IM(tk9y)PwY~*>IHe+x!c@dBN_Tbo-9CxO0pW}+_ zrRQ;Ozbd(7_TcD!oSDFWCkW5s?WYWm_EeAGK7DX>@gnv-Yj6~K1|MCZqr8qkIA?Gy z=H2+;^9ILq9_J5^@`ZzARjS7mFV$&Y!dX|8jZUF>#o*ZW*1@rbXK>7~^_1uF`zu}W zcn9Fd2X&M;@tkJ{#{k}qUuh1G2|SDW{|t`VJn=g{hQxec#EJV1i6y*%ZQmRcD^i;> z*>BX4SgVl3Jqtr(BhTWZ6Nbb#Ucvv&9}+!^MsxO%ST22e6-WPYNc87<9Q>0ZF(^4s zI%h~s;00WF{*ai-8+gP;Lt<{K$M=6RB+3gF;<6#Ja_NwCJ9uK%kU0KYz2imPvpOW! z@GM@lVn}S@Rs8C0Lt=BP$6fEzQJ%patB1Igob%oxar5toL~mZh*VYe-0lbNOJT)ZR zdFH7h<+yXRo~A}PJcB!rH5wkr4UH>LFdAOP_EU_8=W)|%M#G!9 zpky#7>L{Lkj?VHD9<{^(co7f(#n9;Ff1T&dT* ziC14eG?wxz4qiUg2MZjFo2olxcm=o1 z1|DmN#=Wwc*YOh%4~-Vj;GMFgtWYB_JYvmHGIcoQ(V@|g=kc9&M#JODp|PtB;u$~Um!tW(I~i?iBe z18?GSN4LjjUc^(5X^*YEg!j$X>A6OXub|7-UgZ==NfdJl_sUdO^-!(t9kocOh2F)umZ+cqqgr8ao(_+e4! z6}+)?SZv}oe6DL)^f@hUK(fd5VUat{)ZtSzU4S?6_9KTyp4ae(?+lABUd0V_hk3As zHh9cw!(u)!;zwr!c@d;PW53IB#O3$MEQz z>T%_#hx_Xo$Kprd8XhCLkJ?$f;W3lv@$%D$`~G)@>gmIy#~H(8DbHZ%_lL)FUck4` zax&h+r_LYl8%$gPv%eS~b)Iv&3bL@ePY-0-y#QRNMMvHyrz z!<)FrH%EBXnsX)&7!f_bZvgnt@Db6A$A}Se^kE~SUs<6@uAef(Xw3x9J8DGCz$k9{oqgDxSf+4j&ooQav7j#mLyqi+Ik`k+Fk!dhV#`#f!N0N28(-Z{hzfbgkrA|JkUR%j;#b{+v;Eamo#0tq zBu!qy?^K+a7xAs7qdfiAN%6X?b!5Iy<9*9V`Ot~;;9l2{iupW?-??E_EagR9C*>6i z4KlVmDpv6Ve(T0jv6kns-_4_Zn+e+Ppfd9AE!G7gNaLzhonCVb?!gfEVzUe~yZtKXfrX zcAM$tMZ99C>E%`2EVy8zGO z4G)cu0Sk;C-+0jlcnb%-XT;7q7g}jOrkJpYD@XYV# zqtDOG5T5`2eDvoP{Q3NR%u0@bT9A+Vyou#aKhe8Xz$NG8eUq_9c>ZO1UqZt1hU@Z? z<5m3A1NrFWO}yd3e9TMrIPRf*EaC`EoU-fKSd$#T(yKhyzrolny~f4}*}?O8u0*%dW8cq>jb1#9CF#Qx ze=PlYH@>jP*yzujxcT#Aqdhr(`3qyCz_WNj@3FqR#s0t*GKbg7zPqTiT7v6#(G}IWA_^yTX+$der;^D zcopB>*>Li#Kq; zL&wHkp2L0G#>V2*22Yb^yoAdK8#S-uj3HxVEiVokTaI%S8VcPwd+6BMlwQDF+sDQ> zUc)_x>ow0{U3_or|K|_Jj*Tqu#*@dHc3#3`4;vd3co83-XbDn#e6YhclH=K(mf$?= z-A%5Rd0wdEV^ZP`ysgV}@EU&aNK3#=c)+(U0ngzFvX;lJv2oCB9ZdDu`0m))z!Tq_ zV=$@BNn_)G(&K!7^4Pese2UGbP{Y1+Z780_Pt3EScm{7heQe}Y8!VqOHfHi}+#*HZ z!cTqQXi|H8;4I6*>-d@ZW4&9d$2M8S^EhpRW#Z)`SuRzDDo*{eb>aog{lw?TEPT^Vn+IXYijgm$&etOUL?JUKhjq<#uy&%wAy$c;X*r6>s9!rP}cpete}R;BnR1_`$V0 z&AYL3osRz8opqi2f57t8bECws{mODA#}6gL<9fZ8-pOz9dez8y2A`6?yn#>Os8h)? z_Z#7fg*9WNlP5m$ge6ODF#nvrRaQunZ|GHWTqny?BV6#j<>1};k*wkI!q^xl>r;E& z`;SJ+v$#yQ@G5?FhXMu3yc^SY&8hpjph6Q={{Dd<6&>;Eid4nZ@N`@7EhKE zFX4kSKefj_x7kps4W9j$i}P+=)Uq_Zf)D-Ma-{Zn^LCx)HC+C#rMkfFS0$f)&s(n- zGPu9&##>N%0lvnYLkByF(aQ9uu zd3KC};n}i{cc(hp&TD1zvFucc9^?GrFwTe19E>+e4_?JTNKf8K{>gFCD>)w8b6oV} zdEE4wanZ$_IP0_HVjeHzX`dSx3wa5zk3w<=CK5 zS7_k>WCM?{kBf6<6R+Us4;U9)covHX>L^bf)Zc7fZ1h6+cnvoc$HiRUz!fK%jZ}{-PO}e^%fKyotAzT!hzf=?|OLqB*)#>*+Q3D0z7krj`D82MP~CFE_+5tc@=;Ater4Vp-vur!5x$w_xj^F zkA*Ta{Et+4Y}9+H^2E=*X|M1MKEKUd18?HfZ|O8|;KBd496W~yzialA?{Z^3b@xTA`mciqraWS#S_{gO;c+w}w zM<*}g`FH{Rb<+kiQ8uFUsB1yA2&d@M)@<4c+Gv4l5q=po}{ z8PDT@QR96u&ars2tm8HO-01PKiD&SI{P@_+n>c9f_}I$x`0@Dh{vKSXCybB5<@3fz z&tG~0GZ&2a2|EYl*Df9(Yk3a;A)9#%$6xA1ynq`k88E`VSC<@jjlSsW&Lp2wfd z1YW_N(#hlU@$sP)csZ_6klE>lrQ>6a%;kApB_&?NYpyaYyo%RdJw6sE$Mws`$5P(F z53e%-9?Qqa1vfgLS8zmae5~PleC3|;v4J=7`)kIRV~av*jSdrI9v>rl6*G^R37$BxZuC5lhl>wI_^#`+ktxhh z2jI8YjgL9Ji0?i*J{I!$-T1g|{dfG83W*YOuym3aj}-abAWsr|d-w>3|7&18i!bfesig*q7xtVG{mTj!a>8dPm~u0LKih3W%;McRuGfT^%?tSJz7xEq z>I6Rb)d{hHH}IA01YZa0r1+WrCitomBgP^9C&UV#$G?ALLagB}y!WgLQRj6me`fQ9 z*pv>yjY9 z2F45csShSZfoJdyDPHOJYmxrD9_B%q))M#cbyzG;j?eCXnCD6vC7!s)VZKi+-Ij;N z!8aTht5X~7xbd*qzzcZr-G{}dRF4-udRVl01>fF(V)VSqwXpkuiP6pzfBcQ|#K@<@ zHzvm4zd13wQX~B3fQd1aSMjogCq|K1uzJYEn49Wx;I}5me4fWGvXHm%k)ab~F|T8J zv}1TT?mli}tl=4)Fkxaec%e*ooj5VJrWf$Zj)}38H*oaSiIKV51@K=-PK^G%g=c(c zVvOV^yx~}#=2e_BM@M-92cN2QJdbCbJ~0-h_V~;1PxPr=?eQxMba1&smP}bVF;?;d zX3WZJ{{MO2#8}JgIAPJmSfAQp=LJTP9NRCP7@K(>=PWiGyo7sRG%;E{i+_suA@UAa*!~|Z$`@hoRd4#45Kl)ln z%;B+rM;!X~jwtawK5}qJEKF_iqeDAlaca}n5x;8hh^4%WPs%dhz=MZ%#B!d)=ZAG@ zpwLtpKD;AV@I0+@eGcT)u}yJMs~y+p7@(l9kGGe@PIKLv5Dt! zUcSSF6zvuK?%0m#aUCC9?uggNnHGf>uAa~l{dpbF?C6L=yc;V=bi_!W_{%Oc#H)DO zl#b|1^>}8XBMPZKo-p0a@e)p-*%7mN5#N&8yoGU8hyNI(kmN&|oBZ1yvEO&}mgn#l zna`Ve>CqjrfLCzTF{Yj8@n^F;qMLVP>DZ1~!V|BRWxR^@bIr7v&biB%`gDwL{5c~eIW;5jTxjwik^gLvHB z5%)&+GX39c~-mz?r|Xe!PgeyDS+`eB^FBKeflN-`5cvQ$1d=rXx1<3T}MRQt~Ed z)>{9q3Q6)0cf>ZHSbD@7^Tewj?}+WZibJ00h+fxggU7CO0$#+Yo;1C@fg9GF-sCvz z5B5Q7gIlFPZ{dQc%rx(Q%Kd-c(?+3C#m6?7F5bWoWG0ViI%52@mV_5@?}pjpS?v9S zJ0&@`|JerSc|1{;@e=+?R`4bc{)^3?+ThxzTyF!`$=QF?b1!t`>#~`*@RV)qOi-8_!}vT0HR|vYof^ z*1nywgV*q@U+#>ZyqqQ1i+?!sROZfjMtblD{!e=H_)2FSEWLORulQ=GzZTXW8`;k2 zm)hg3uXRR_7xB*hJEN1=@a}${F`L(M!U3HzmlrVGztfZ}kht@p&RCKTz`efJ8B0?= z{_xPwSkAj~-N4RR!5bKZJ7XnJ%nj*`RXnjcw9{9F=mcIcqBBe{Ow_8>qf`o8`7J% zaA1d#@;rX(aI?iT*ke+s2ZN>p=|8nI@;rw#WEL;tlQM@l@aqK|C$+&<-|38nyoM*u zHgmj$&&zVW25PrQKd9Pb$J|DF3VO{f1@p>tTCc#_ejM!4rGUgTN4<8)JelMCQ( z^E;yt&*1JqHQmYa$LE?Q-i_B^XzF*Tn4nYB!9@Q2r0Cf<$DUuReIChmE?O?tDz;CnZi zVeTKk;>$Oh=~RzTt+4(R6dEh^?iLs1Eqvxyqe=Dn*I#$Wyi||J-ew7S5!-QnaO ztM2TKMZAU|%Q7B!b;fw9@&Y~}D|sD<)eM5?%j8L^D>QKYZ;dP+fPaupsUC;jZItN% z{KP$$iD&Sfd)?o>8xMKN{mpZ@`&u)R+ThGbE#(TG#+kpf@si`{-&_Bl3VE{VDfc(8 z;G*YEU2^>73wAQk;LjzS>ha7!+P%CRNB_Aq+Ib%5Y&N63gda+Q$1Cm>nawM>@2l=2 zo_*E*e}}?+g&N-bnknUVocK4pniuf$H%uw7;w^7_4@m8C$lLY`&*ORTxqW#B2k+>N z^{E~+AGp_fV)H|{H&0yfv0HjY+JL0zu7^k5q7fdr*WuBJ=kS_+4v)UPiu--(@EDZp z@vJW&9$mZ}Kb=23iadi?PCeX5!nMb%jy>G}Vdr>@tmHL(KvwZOK2i2dO`(C$%WB@l zj?)j1HN1f1&N)09$uWP?;jxt`-gl)=-|9rT?hc*i4P1Bc;gL&@-H#t0ojmdH&*>;{ z;lVHKC@<&8k$=}yg(5!K(ohT`NimY= zapCtIpW1w{?1ZQ3okHS2elRI!^A_&?qe;=tv$)Fwo!}YFOPwb^_~S{jp4V~r%O*uL zwZS2hy-gcDDm(_Z=MtjcoBQws)sy_mp)?Dyn_2a zF)5a%dYry)QY=sH@w9(Vij};CyT7S(JcGG^O^OXX@tbe!Tyh-$!KB#23s_$Cxvto* zP{AwubVaY*tv5Cf>WaQRap>@_7{v2ddZ~%`-T2ewQcjnIYWcf-c|Cs2+cRiH`CH_P@5=70VQI*LKB= z59&2<;8()5ru5~BM{eqhe!Pgsy{xy%@tW71m{)Pcwyv1K^SHES^r;@7 z{HQC6yn&zCWpXUw8T|NDlVc(G=;!$2ev_lTL?KHq7%@3k@Cx27Yk3|2D(iR)KRkWQ(Bn5wgl9@G-iemsNUk^wx2Q)Lh@;F&U#cjHYmf!FW_>EccN#F)wcBxM6;NSn;| zLLN_$IlP3I$vj@cyJSAE;R~{mH}Mns$+3uMuuYcmJf0v+c?mC<<-CfI%L?AW`^w`c z$0~(7{&l=*=PevI(Nyz1UL#Fj#TR8OZ{im_CVTL;X~c!HgLh+(PPtQu@IR9#M;{(t zljEQ%W{c$S#vPfzd0qcJaNQ9Q=&i5<1!hP+ThNEr$jrC zL#9MmZc2>g1^nEhQ(^+o;KS0z>-a?56rb)>Xpr9xpAvJDW8ZO8VhPXU09nCvxL8*5 z3Jx1@WIT`8%W7W5T_#V7H9Ui#oI1tNlpH@l%^-OeH_n_AP2R+E^T;W&BNcGVQAWXA z_~x7`5x?bl$=oT?n^*9cr|KZD;-b^cN~*^fF4I}w#IIjz#5{-7ubvXKc@b~B#vpkO zZ@g|w%>Av~uST9+J|*UPp@BdCm67sp>~q(YsPHUabHCB^DjxEHCE+=o{LqwG&kK0b zTAjXIhw$=;r+6BJ_W0f-I?ChGDRE5QGVvmo>ejzgp`@^Lor=`x$tm&t?{tDUarfU( ziKRS)8)P|e;AQJ|h*$7`PgxEgPfv-%WHm3~JFi)eRNtHuCrg8u@b3RiiOsxTCL`aO z65AE>IQV@dxQF9T>B(bcLe`^!^(9>C1un`OUjN-yBeuT723=>@!H z%hcGO9N!X;@QoIJ^&e)7XYu>ehnMiif0{X7!;fSTk2i4J)M)2gHt7d#j_y`ZqmHwv*Xy?}*-3en(+w+tx6R$jw>4=%(`p2b_* z3ej_odVF_K!NXIGcyJ*O7+Q#Sp2KCsjFMOJFEXDu@xbAQSdiKbFBjsOkw&1)@OLiFGTY)ms^o_P9EM$Ah%@)RTHdA#c=KnXZHs`FZgG6g$oMt9a+kYxJp*=8a{cEQS%1Au*8UY6HmI# z2zUwK{beC`@VLAX_b)3%=0SG^7H%j+f1dd56_$e+amsClnDwCBuRzA%ZbPL;IN*+g zuXMIH_`RCt;3aIk$9nQSzPwuJcoRRhR_AyIpMA6tb>6_29y4R94bFdBM|n3M($GVM>*+(L=mneXk9x{mxcAF?%Cq>3SM@Zt!EbKUQJ%v=@7V1;k6(D-4o~gzxz9|C zHN1iQd|_HNQav8nXIgCKIlTD5Y5vo+bC$`RZ%vCn3MG7W;546TFm?Fd&S}w^>hb5( zr$sRxfZv=oEf(+`PCt5@-|b8(PB?a2EaL^7eZsV;rFy*h#A&gfSFkllhj?P;lxb1k zl3pOA=T3{AJddA0bz1azSg-N!?@f!|ypCI?KW|~5)279M)CLQZ}dz!!hUu0woRlM$^X)!-J{`<0Nv4lruTAZF7g$DjjCh!(M ze!nG1^?1_*)1r&l@VtkNj92i4`m~tIOE~UvqvQqr+B&1;Ieh$g2FV+E?bDW=SMkj9 zGt*+OLO0&^$7wN-*Rc8GH2?f!x^V2PW`!5IbGe)#Gj-nqHp4 zmt{6@;um*10ng$BnajJeA@g|RQU5bbyokqqWEPX-Ngq#(g}n4}Sx*%fDb#R_Eaffi z7t><}_gvkWBdgN^xIxzO241;~GOuF(6Vqc8PuzRg>Cxm_yk54YHrTJn^w`dG_zT%l zR;ZAV#7~0}pPU}^q$e-odg;X*nE%xD=*<)B(w8R|KkdXkaj6X8Roo#Xxd+`vT_&XV zIO{Xh(h4PkIGTO4`cz4UejZ)bn_CflSRCN?Vp<- zOL!jF$WmU%uHC1{a$dkivZ7vgQqp%1)9ZySu97vphOcI($6DURefKnq)CSL&b-aQN zS*fY9~kjo z)8kY7SijUBcm3k@*qI#f_>!f0OsDa*uTJ;hhMfl|WX%RI;LfjELLU21kL&uGbzUu# zW4__y3Pl|B&FQg_=W*Kr)5Kdiqs`Q%HrPJc)TK6fw5&??I9FEl5Fh#}KG7+oPx_8)1~JcpfQjGh;8mTcoiyhB>NhHGReuj6icoA+@ufoC0N!}4yN z)oE6E5$}<{ypAtPf8Okz?*2dAW>d)HB{Gs%aG7-SD*j8lcndE%!iiHG95BhKc@CeE z1-yZ0bXjv=!oSNh-om+)r^m`vkAIalkK2GPa^e)5D7}CW$tGUMFHSWRJd49+JI~{_ zvXfWw-_q*|>soNzN?)GAIg;fi+pxnYxtCGNcFf$Hu7?l9CVxtg&ZCs zTX+Fy$u?fZJEX;Hc>Wxt=M}7;qT}n#1g?}`yoMi2hR0m9B7J!VkC7}d;uEJ^{{ae( z(;Zy0`*{s_{egXu4#00pC(q#`DewxuEVFqNx5`}J!qI1X+Y~&XDC<)_w*AlyrFy(awx)XA?ML2bc?M6F9#2|tyjXhk z3cewIc?-ubuxWV#XUWL2LXoVNJg?(%KQ_u#j~`2s$4{om%~IkuocU9GBDKL6rNWzd z+(Ju|>hT4srFxw4Gw+_M9`BF_uVMM$e%Y)L=S+_dY4QSIB3pO`{~}v?6Tf1{w(%^^ zkrprEgR-61@pIi~g=g?+*~yDollYwr<96xsJGWn)YqZkS3yD`tFJ8sBB*R-c{ybBf z+Tg9yhu82S>C5Z*mSj_V-2Z&PEAkwETl(`NUM>T86`wj^Z*vL_g;-<*^2EW?&hxlH zM)GdFMDo0XkI4kyz)%0&Cgm9%AzeI=Ka>LR#ye#uui+M%#am_ajSK8#g&fY4A}`^+ zGKbf3w+roXp24Xyj~DPdDe)@)Rp#>+wlCIkp2uIvLSDhwr8~93{6*G(QEEi4lEu7= zZ^)9=2q#`_bMXTHN|vTJ_>L^&amn=fjx6UzTq{*x$ERflZ{WwWGPPe~c4ZaMr>Etf zs!&rX;R;#JYq(j~@Fsr#QYYqF{I=A25wDeXyoz_odS1gVvVphoo4>Hzc@B@0jl780 z$fmRbtK@mv?1d)obD6t?f6Oh-n|Q$EZeyOqC#8!w9(Vtr`h@9H zDB&sV-Db)0K3T}?IP_U}1kd9IQsosq`Z+Vfi@4A8HY3mCM%lrec=rni@CWC?@0krYz(w9QtQV#`AcIRConnlI6UKhy2Cu z$8&gutmXwQ&+^M!g(Ch`>bx6AY;r-K$4=Rl4#4lpW?sTS$rj$k52eN9Mf*c`r1p5D z^nA)PVZ3C6^Te6b|0%a$k=!QjsS&P`Jg?(RGJ!X7t90=e?)I{`Ri43b%Pd~RJ7f;8 z;RjOUv3Yt-k%hc~-;>3>gconN{uPCa!m<=z#fM}$ujAgY*!et*{iVipc!aFx1-w_* zruO)*Kn`D zno^#{5we))@lvUz_V~I~c?}aWe+rG%2zSUP?&;_8CE3ig*k88r z98Qw0ynt6ri&ybY*~wct{Qqpa4K9Yiklwt4w@a4S@G0rP!3J!QO_K9M6F-zeJpMjC zrpriP#JSSROL(z#@d~~xGgJG2_(Q4`c@|HXxv4!qCJT52vs=wpYJ>C3ep#l_jf4N` z9_4xLlr_A7-;=exgbQR{YLCyzdfveO-Y^KB!*1D{+Tcdn!JBySn`Y%1ZSY*_!^;)Y zl>Q2dgSOc?Jda09Coke$Dew|rA~SgfZ_1NpbW{ziY zq%7lkJp2Q1T)cpbKJsS8E4Xc!8PVV^EbsM+86FMf!uTU;@@{-dTD*xvcbyUOoRi|U zlHpZs>p8=xT-4*~GJu!xIT^$o*!GzjF(I|VU&~Bh!+kzG!|$4Izbu(7^Sn^NyJbGF zZeuKe=Qq$4fomIAbA$glP$c0@9tin z5!)4Fj~Q{5^k^6v4#^lL&*RNsm=S$>4gVzlcoToz$B211{zlqU8+=9bsSS?oJ0m)I z9#4`2FX8WH7H^cvH@`e1<|^dyLRr8o_=YUzEj;gQGh$h)$A@JFuj5zuH+r7M^JHym zgYU}*9{py-DYA)|@K>^hSMd{HxBlA{GURO8$-D72>Gix3;J5>fo)_?b8Nlm!;DJWW zb9lK-;8px&e{0M$c;-PfVh-=dTVx)uVQ0<~^FnS$Iew zeR&JNJ=}Hkf%yW3GEZ{}FRJwTu>m3Hk6W=QPWw}BN zr*;}8FW}v>IyJ%r51$e1cn+_Y2Cw2XvY9uq?FggfdAvoo^BV3k$)^6JnZPrpH}A%O zNIza~k#Bd+h@3(ZAD5B5frBT{h%TPTMKfl^Y+k{KrNry_mMq{cJaeW|@@{-i7V`#v z^+>la&*FVj<#qhjQ8RooibCe788JiF@FIRB>v(*7Mog3jFW?ojnOAZ2tQr2vPUo;D z+j-(wzGK82T?|i_-n@kONS4>J*U^@hXO4FNAEVH&P{dCkV_nk=I9m#-9&eK(ui*i+ zjh^T5M(IxVxKk=Tj-3&QOO+S!CaI-1xXW?YpJ(t!X_V6o@+N-cB%|axyjAMFhWnjtl&KyUN|SfvAEfoC^y3%# z+9^i%XN~Y&$?yseIn|o+JpTD~YsQ=S&>2R<>v;GNY*Jppzsnrn!VAu{OuT|SWg(BV z+-0&TwZ|LIDjSVLRpFcS-HJSiWm&{9$A~( z;OBofBi8dQ{#iEiCVn7Wc${Nz$u?fV>tzS8o-?ByZ!7fJWX*8A<;d^?-Xwi_4L{XA zBl`0U9xsD<5$};aujA*>wGVg}e<-tfH$EqGcmwx8&z|5pJWm#GvH>gP@3PnnEgW;c zcPpO9E2PS+_#auty%k2gtVwNffvn@*sZJWajyq&?YX5UfEL(XA|0pfq#4+UyG*rmr z^%5_-7!JA6p5S@>v-IXo{NZAIf_LNI7ugd$i}y)8uj5e{+Y`Kq?@58jC4Rt>*}RHF zmbleOGkai#qsn|J}Qkj=b`f0HI} z;jgZ;=~6v@B-?mgZS%@@Uc|kZx&3%{na%ZQg&r>%JzjH-w^d%n9@m<7p1~KSZ)$@# zU*|2B*Kp6}mVjsRc^Q=2VE$L$HF@F(GJ(hS-ngWT*YVOD{M=AhsF06jc4}00AIltG z!ihJ!cXw@JWGRnZX2d^bId9=Bw^}CN#PV^! zwoVE~d`(uT7x2$3ty6OR%WZaea(v}>%aj~XzQfY+6232+d92cj-&g{k!M*Ra1U!o; z-en0=d%UM+v%l>2tCNF%YuaBnGQ3VQyo$TsZ3%b=e=2==H@+!-c?*xZ#~s0o_{r6l zCbh@!$pBu$r(_Us;5qkN8s3eE+-LnKDCF+*b^ zmhl?ivrb2O9oIeS-7U4jO~2DQ-o$_Y-mS}9_{@51pW5J^f0z*~c@5`0Wm$O%4}RME zZ&1jQZL*oS@RkkA=>VMbjGm?g@a1Q9^c5Gwu7;`R1*|`BN_pa;f3&N49{1g-b3BV5 z$wD4~vY%uLZ~n>szvj>0VioH6@Lx<_a(rZy-&B(0<1gwQZ{Qza^7hG_c>l|8(^s{@ zWt;5}Ud1C{vG%-(yi#PGQ*UaLpHei(;-Sl>t4!|$G?lwyY;0v-S9e{rnPqk{RO{1GltELM=YOt{g zgQy6j_F8*6du`RKQCqEK&nZO`4W$WTq{vSg6@{h2Mv@vTMah)PrZ7L2lBNIq*){#n z{CR!${XWlp&*ghLXQ$oTb;FeZvH)=>+(CkP1TOlO`Njh<<2M!~Zot#)xlr76An%bn zHbU^+Ke$J67xW)vz9Z}m6aVBwaRS)zWDC*w)xKd2j$E`O0)^=9ePKz6A&PnWOAQ9J_Iwn!J*$A!Wv3F*=ax8T6j z(xngXhW8T}?t?G2OqWzV2)ngPmo(f7uWp+zgS35HlO5P_>kjZoG8m7-OOw)NxHf{X z5Dy-N3)`hjIv#*~NG=|MSDl{DS5IjVTeVM@65OFA<+v9nJJR`$A6x{iI3t}OjHxdm ztBHk&U~-3anWc?jkj%lAV>_nvWmww7cZQ_PVr>s^AC@jFa1YENHMjwvAR#;e2i(Hw z;x1_3%IM-2H1~~Wc-e@;4SDI3xS!PvdzYm1wOw|APfcKW@c_)YkD^ z<5AeRno+@B@F*$KI@~aWk-)<+b0!_$Z*m|cK<4p+^5t3d3=hI}WCf|aKiC)sl>hT;y*cSl-Irz16HW$OUXdY-aR*#T>hJ)(<*E!hihJOXgEHhe9)*A0kRgdbaB+h( z>E#Dj<6L6VL~Vg3*<2shx7VO)^b;l`UY#D|CBZn6xIz{`hc z$O_yIhm#QQfnBpQq!xF=v1HE=EI=>v13AD8QFvxHJI|rC@lK3OD182OzK;b^v zup&cJaCtdHM!d?!;Rakm2IE1P^BNbbb$E#6;!!yE^$e-Nz3_|I8L8=PMA*1L$X$Z_ zU>#YkJHQ2Ru)gpB{FAK1WmSf>SWRzm2i&@r4&Y(9{3AMm2jP+pbl?d4!hxS>ND}Ub zUu>l_c*I1;f5}j@;f1^Qa<}OV@V$L3emn#VeqizA2K?!8hRngE@QfoF62P5s775}$ zI6RsmYj6*|Q;y;;xGXVK5{}XX_=F=a3HB)MF8JHQ4bJ3&sgDhQQ|ir` z(ieBb)x$IS{u6ch?X8)TjYr_n+cNn+6e9s|&B&CBpICq%EIg*42;Cj*t z55fH;1&_iGlQX3c?u6Hqez*rtB&oOsmriE>2eA=k<4ZCakHF?rSX{URUP97wH!LE# zxEDT7O7H;ukW}Dd_$#TzWhx!3VlmnKFTmC2V-%<762gfFF{T zco_al*5Gnart~5;xC@RTwYULilFhget|Hs<5Zq7p;8ECNTBaPpo$z{c)MUehOeFQV z1(%WrJP1?nW7vOT2lzoX!;XjH12Z!v8TY}KvoiVT{qzz(Fq>7bb(ruVx2)FTxsR}b zaTmOFK8qT6Lvz*wR;=y-dp*IT(?;;aMJyaV42{LC30ztKY$o4TWh9=XJxRu0a0GGU z2AoOy;y$>FxbP6%NYd~y+(iaOx&0zY9dYwQ6dosoaS5>U$xu89vz})i;0D}43_J`6 zE@kdAmj2#+PIT9)Wd)?-BFUR=6Ot z2Im)AOCni^J76-Y!JY6E62il9>T=crZoz|O7aoNfFEaPI0XLASwl|T1FEQV2xZw{Z z@xSZ<{VTY&@Bke0GQ*2|;4#toD^ZdWIXY zZVR3HmCnFjyXgQPfmMfC2e@^J`+rs)PcJrnF!4v8&$t67{K9>#4i}JlcmVc}(o@_8 zN0DW?0lz0J@hF`1UoINAV2fY5MR5mQK*D$c_Wq6A@>dq13t3I-cp(ITB=vX{R{z1& z;1=wEjN9)w+QSjVi5qYx>5Kc|D&oRJa6d`Iqj3Fk7P!{o4S%wbaSz;P^1)yu0^6Km zCF2gbfK=iE*!wT$40plRWF8)ZH#9I3xCd?{%kT&+{+q>%d*M^01`ohXTVzQs?uH+c zJ-8W0MkZuQ9UBImOX_hS?08z1G~iD70!gfAeZWgwW=SX94L>4IJPb#+%94J#0lz0{ zcod$Mm?eX8C;WvB*E*ckI*Z0^Sgo_9MVlrI)x9&K^$Ba35TD8@<7UuwX=%tiuiXU`7^y--I^srBU=o+rW)^OdlSG z3yQKt{-F18%@{h0hu}uy!o$$q#fMZjBCw96;Zb;;48o4WD>@mux|zPznu*i8#j|(xCf3W5!?$OCUv+E zzD}Ze5O%(cli*G`nfmh8@QY-)Hd*@`?C1z9VdXte{~OtG zBST3jR9Wa?B9;e4}Hc7&LaMZ)Rh8wV)xNtArK~nJu-0h>2>adPv z<56FhDH)GtNiG`(9KVPI;9gioEZl+z$t>LgZhe{_<6*dqtiU7i#wA(&umm~)TRu;Z zaR*E$VcZF4lkK=q>r3gd{yr=x@-&I^LI9ro0{1=cg0GOIKN(V(wv3%{H~g6N#lz58 z&1<-FUM){I+y|3C%aRh@3EvH8$#gsf)Az8bwLM&K@?j$zk-b?mB*N9<9yoFzz0*eU zp8ee4xCL+do~zb2Fy#=_ggfEOb#wp^!pdJ+j3;OhU#+Jd9)$VFxlr7IkGIJd12+Rm zn>(_liVX*xOZxpq4`8bi+2Y0>a4zv^9kv>oEhSoqb4jJvVVm@9nWJ?$mn_ygY?F~K zE3^*hk{YeUW|`Rxp}vsG3nZd1z;;>LQm=LR2uW<94%=jBOA79QKH}0kbmU~qV6DTs zBwOpS&8Tdt&^mmOSXzf|MrX@Ht&cW20UImy1=uc^tJ4?YToTqgbmV2r0j)zHIj(is zCO=z}{-zEeBu?B1TNQ9|T8DFqTkEim!6<4S&LxJaFCeW78Ag2p&LwlS4x1Ha%Mz`_ zpUFx*3bz(#OD!ITua#uW9y|!=mojp=4~{G2;{M@of)|X*mOi)(wlB|?G~5BrO?>dM z5r%h+WnOUuUNtUTrsHmSf-J0MT-?MQd5J{uAiQ`|4*%Mhi-1o|GIOL(cVMG+WsV%h9q>*P#l2c1 z^>`GHnVciXwGKB;$&m&;47*n4@VyL+zp;@che#qGh2!tZkrdnu2TaT1pA=jC&5RtW zCaJh(B9GsjBWY{|;MLP}WDxF#i-}w7@QV9#WU$uZ6V*Awk4oTgQRMId$>G~47XSJx zM;2K*LjNTIubGh}x!NAiB?j(;$uo2KH_coqTtdup-2v%(e~wh>3veaz;z8(|l_Qn7 zGDxbl4l^Ijk?FVrmo8w0v<`n>&OXiPJuG;Uy;eYj`IUd<+dOrhkJrKJpb8n zHm4CRC4F!&oJ{)S7W9*TcmOUZE<6a|B&m1^ZXjuR7`AM|*$mt()b-Dxmh#bYka8@ln!+r3xPng#h)M4w53?=S>=MyLHf|E%f+=7Ql zUpxvAe#%9w!y}uxICVI{{EVw(!v&WR4<3LIea>9sKKSsK94S|a>$Wl-cnBW(GKXKb z#ev|IT{$ujx8Q|8uy$}4yrGWi#67V3Fg?cI-ABo-B#fILWChvIMiBPsF-ju16Fx=i zaF=J4_(%h;{QHhkl9<3;ju<6lNeb?TVbTv*7Nn1oG~9r@$Z+*1N6Qt@jFw#74U3)| zZAv8@-seV34XMIIaLw}3GF=^B|Ke!=FhUPt_g6>DV%!PeB{kXx7QHrFYH=@oYVBy* zj0fPR&}i9?hvB#nM#~;;1JC$yv>d>lADW|O;Af-dC>w5=v3<1E;|44z4Y~u|LF6<` zBCw7m;ZfLT$7pfj4tN1c#$E6U;=}{+0O_agVd__-B@K7Op=7Yhh6j053wQ`_B?naxD$RtJlY=qH9Akyamme- z3-j_M7k9y${5&baL-5H0j)ezIa07lvf_Mbp@lu|IwEj|_ zDG#x+kqsaGjBLik@W6^Z3FA>XJeVgD+yn0?Nr|+FXROMTWZVg_T}@AMH{3+h@Gx|~ zNyoGe%p~Qw0b9Mr6eRNecOZ3Z^JF?NL}BC|rT|wCem_r^;2!ukS%Zh*`Rkca+y$Q` zwRixw4$%SJ0T+_(T8Di;phMaomXmti3zwUGIL<~8cK$F=8gM6kl1OWIhE*TsNg{5+ z6{Hg$gzanTJ??-fNea%l^5u*@tZ>{3M}5mw;s$)|5YvYT;A3@M2yO-tl3?uHFN(=%Lt;r0KrXz?I?vsu0*v|)r`X1jbz!40^+Q@*5X z9rj4cm*Kb*X7O`%$Mu>=F4>419$Y#mxXu)UOg~hR^o2>%vJePiwEG0Yx89f z?t=pd=S#h|f$78YC8;gPgg4!uFMV(iG}7~Bkk;WxnY6>hnP$EmWuu&pC~U~emkOMp zfFOw^fIDC^S%y1dCRu?S@Nu#d55O~X^7-BAw1JDs8m+@RvJQ{Jt4HNa4eo|>NXTTv zhkQ$F@d)fUI$t*8E;yZR#w{fY<6)SRn=jjOCtN~y;Q`nqk5SP&43LP{VekBWIe@!h zfYfOnn)~>0l#M9dT);5mVfc!{2qZDDu(FU7;ubtu%mw06cu`rt48~n>0m;P!uwo1& zihE&kdA?Ms!}>e(WgaeL^W}zdjHv$FX%F&U1;fG%5!hioJ;R-_o*dO3Ca@+5KVX2b zlH|+syYrluAN-2A@d)fah2G;XIGzl}z3@%q!9(!0sVp?y0W(N8ZouUv7Y~|9 zlo)I%r&i@l32wm};>APo+IyG=+zl;_wt=mt<;yJG0f!SG?txp$LOcvR+{>KfP8cN1 zaOF?L46+eLs;0AIaSOJ&kCll#U_J@s2K=*{g@*H&N96=Ls&3`W-9%1jUl<}uxN_5s zd~x7mc*{(t0QbOWhzk$Qe>#>239Gb4n1;gBti5blAQVMYZvpmQ6ef-9Tv zU?gw{Oy0>zXdQ0a#Yo^`IN%$e6S(O@zSzyJ#zq9r{g(Uw3|2e*WiJQDqwui^cLW}Q z#rwGk+zWsHo{P{naMM990uRFlKd>0JJ?ws%CnoNMCw^p&;BtgJ<0s~SI~&GN`7-kt zMgsT2IlnRz9dP(*JtKjK;fH@P66)~oKe-6pf@}ZcBJdDg^*0xx4h<=gg}Cy`<^{46 z55U<81yYOq63ha*v{eDW)1F%kKG(WH>a`JE(zZa7I^yu=(+i{z?twEL1u_Wt!6_XI zBptWlS)B`{0(ZhOXBNmT+za3C%CYbeY?V?VYj6k5>0Th4O*RbVDrbQlz}>K0uL5bn zo$#;T1=6V#!_}uicArxq{qP8U^1K2Wj0a%O`2~`T8?fI61yYH-;H?)HNEPmZQ~Pm2 zxCMt_R3JXBL-Vfw3=tb%=pRrZ0XzUJTnv}i;UgCpND%kIwU-n~4IYB?E-jFaT8FQu z(i=PocML3$U3dfzxr~nC9{4q>(>i?oaz?rn&;I~&l1OKInN}bVkObTZufL)|9JmL* zK~nG#9DZd1!%Q7EzlvVt4mg&i;a=E42H`S@eaTQf1RuVdDZ_p6ookr?Y<=MxhTUBt zCAbqFAznNR&$^x=)jFJiLxEVh4~`zp2;c^sdm}@tb$Ie7<{OtG1@akLfrsIVp^T{3 zhq3R?1+oq|Oyt5_SdDDB;HcpYslEWW-dZ5r@i2V)wgQRZ0l4XQhE(hD+B*s)io0Rk z5%d~&z$-^GqFt!Nr_));cmR&eD3D~_3!lnl{!{b?qWef`wR}LT{+y&>5THFVJE-#QU z9);J8<+ks_^WTk>kUC!Q!sp0QJODS5C?1Aw#<5~?2OLO_<8C;fG~izNERi$W7j7X5 zco?2rQ6P!93%*X0@E{y+-o<>d;ejubKKcS2FrMkq9pGk?iicsZ2?gTTI-E&{;y(B{ z@!;ZRA(CvZL+9NEQjRObqzYGVn8e87W*FHvnH9@M1Wua5y^dS3hPfP3K%Qm1X;fO{BGZ38EesJ4O2?qUAx*$A>xGL0eC7vSuB8M`#K8~cfbX2(0e=p-(F3R@eus_O>S2_0)JV{dcvcy=Q|t= zcfG^?@2=sNV?%lO`}794U`>b%!b7m(Lmot38QzcRIq8c>;FMY}2)E#y8<-|M1Q&eF z#o+{ZJ)D0wg6LX0>q4P5qhB|B@9-Q~)vWKMO5m@s%2g5^f z$rhgfcmVePf&=3&xN#e!iihD3+Zh!+3X{I#w!|IK{Du!+HX^WoCr>(Dc5(ZW>39g5 zU$ao?{JH{iT_=1JSYp}!N{1MmKW6XF&e zb&RRe_Rx8pDZrIe|757O4ea+fixGFhJN{uYYI_s;miH$?HX`t~=7wy7kjd_J@-j_qtnHtvPLcQyFsI!x1FVvzqwNQc5g%K@DP0L97809g$7g4Gb9;z!^6adN8yuw z4Sx6mZQ!)?IWBHN_XUQeYkSzezaa+h>~EN|pN(=hqA)3yE5#jfz~zQi;Vx)hL2zZq ztLOplgq2qt;?p`j^IAg|YaOn=&X52eg8mx}S%C-Om>U^s+zY4OM2Ay&{#(es!wd=W zf(6gH#gNUo3oaXO$aXvkowpgX2UnhXyCDbE;ogyk9K|DWZKfghcnDsWV@Lz;hD%2q zl5jT1fd_NxC?17l%sfLnvEhY3kYs%U2J;O`(H)?-fRk$*c!|OE;BJ^(YDhoafMz*U zf?F^=mMOrM#TAAO#=Wq1ydlH24##+z4&3x2Ehcd=HXQK#N<&KUC|osnjzEG;oZ}j4%~wE_c0x~RCCcL(}63;SWJgH>_407z+JG#9OggBhGUK)56opg za3B129@Bx#BZdrolsf`-AbgX! z@eur$48|kyHg};6$31W_$<;bEt}B!ZlMR)h$#gslyIx-?b8sh|eM6zl!+r2+vJelz zPsn0C3>OS8lqFh+?~|2y2=*UR$hUMDYB-f_#4Y#*3F8rH_8(d(yR;FUMeS(~n+qk12Vv4Jg_78V(Smz#E97raaUl3Rap7`%p|m2Y+6G?WDU>wa1)nA!JOKYg zvU~9S4ub)Z+$RK@yyt0G^x2NZ>BG zilpEnWj-T;JK={U4G+UU1%*6iX%E+vbZu`U?G1X#h6AP+7K#^l!_8zC9)@QZG55F= zP9lqO3%*>++~YymWemO4HgIQoq150J*mZ27Y}Y!xe_Wv)zqt=B!=v{w66$cp zbVd~q!d~|=-91gN2sug)Xd`%MHLD%>!o%da)?um1qUxnjG}em6+~ZEzV@9ELQisz> zAKZdh&7u>y8+Lz?khix9GlepSa5r)E;Xv@%8}uHRRfTdnNx|K46>;JrxR>&udzTOV;xY z*E%c-(M#M5Bel#iuH5+<4=#0hJk0HVjwSL%p|ssb2XF^8fBKrMV_z&rWOZy^uin#Cq z9OfvJLAVDNbSmO!TG1J}w6j?xt;1JH7!R7r-RBg^0X8i7 z7-_%*@EaoMu`@hG67eWJPLgmrS4W|U-?YP&!79=Tx8PGG84tk3^NJ)z+rZ=fio}V_ zMVu$KNX#_d7+55yUsfbTwGq7e>LSU;J@EQ#io{Td$wQ0yo6(F4d}dgY%)tY2=FRjT z_raoD=soU*X}1Tw6`>!J63d0N3q z#DQCIIZ4KYu=gFzx3+-`(u<@Y9)RDH!FU9&%%o%59v;tT?zNs%Bt1tJNp4?#{v+Rz z5`6*IlL}l$7s&upiM!yFWI7&zFOWHS5UwHf@DQveK0FN1&1HSyE@y%_$FD0hv3Y+ zSzOv4=1yefa051<#Ax9Tm`;vr9WEpFcu+|iaH-_}Us_ot2^a7J^iAg0!j&VdxSenV z7Tm+)QitZf3?pvA+wbGSf_vajG8B)%r)ROy@Bn;nHfu{AZhL^C*EX<$RGMsfA1sm+ zWI8T$xNXQh+zoTdLOcwQk|ntDP?0=Dmf=4523d)R;Bm4Bm$^mKgVf+om_cfB1I{3u zaUV3l;KOz{BJkmdS#`WmBx%j+yO z;>N@9yda~3yWq8NFegj?{s_vwtbffui59pG;GRfy5UBXHmbMoH^%!dB)#sUIiXS|k^Qxm9o% z%q1?|fJ;d#9)$OQ!F=OBc!&(eqwwi3=@}k?9}@!)!(X>?r{J=k+ieFO!#!~5S9DC> zL>7?%8v(duC%wcYaK|q00(E%sYvvMdj;N7Gi zw_xvY^>YB7gt>c}{{}V;#j#ll0dXUk$)h`Zn-vJ4NjEH?SYHN~<g`ES9H9!{^nFd?}?^99!4{{z6u6t!`vOcSZ|WUPda`lZ|G#-NehcN#oN2~b?MX}sQfIr%cpWo+zVHbAg(lz^I;tu%C%L+{L4j709)TfFL31mQim%m zrZGae7cL?x$EzE;0q=u{;aT_6V_dnEc<>xz#p3<5+T>>na?g{+yr8`E zK5iA<3xlN333i6(Rdb8tE?7W@|F5;mUK~D3&?6aw1uXTX5}aPJFVuksp4*(-Bwp`jFcaS6*C8 zk8w9VMv|JDjr?N+YXw(M`h;o4txvfByKiKu*-&2fIYW;t>&PHH3Qym{fts6*obe?i zg!|wTGQ0(CV83n5E3Vv2LU;rY+D`ifvypRfC$4OiCMj*rMyCD7{NZjmi{#?U8d8pj;KF(qCa&B5!JE`JpBv&cAElG(_#W1I|k!%C8iE8ig{cnEg;lM|lK-z9)& zoaDa7ov;fV|!0r*D~!+>7_a_lj8}7dI=BG&YoDTb9URypgR-BpV+Lza{0k z@{FVssl=V|YDbAgaW|ZKMv0`H!F0eaq%R(ZMu!sqLK4#oj}ad(9ZTd~(qOWoGJ+&@ zq!C<6s&M6Po%q)}xCd?{eL69haAaqCfGeF{=m4&qOa|kPJgbEL*cVRhR>EIaF&nw- z>=OQhiph6OO87Of=atABHk5<lR*@gSy5t7}-Y~;99MgmvfHIR$Ly>J`x z;mX#RaRS@{bIC4TIW?_B4&WACK?a@4?H5G8AVbeI8~G>h!R3k)xsfcxmCukM9)KT^ z8eDmp)Z$Ut<4T4US574f$(#&6Pm*wD_^J}=gewPJ&HNi|xUMddgV!*mUHQEf@RDmw z_+Gx*$PWi|rFa-NkcGJNU@l;Fxfx0FZ)?t*ua zdAM>SF&DC7A+M9|xU$pm64`@0q5F;!zW>V#hwl;3+1zq4VFV|`mDwXX8Lk|WQzEl) z1I{3Wx|@w$iVwzv@CPyvho*c!s)X-kan-Q%Xyz4HX5`W%+<@I^brL52U8ant1RCOdZb&aOFQ$8qI-OISPS z^3(s};pdot2OH7nxOW3Qba3Si;=_G#JqhBU=QVGar5%9qJzJP3OP zX?Fp=hsQ`CT;AXUhznO1uHy3o?uFAxC2qmBqy|@-iEpt=*>J$i$Sz!Yf<$mx%Ulw< zkhz4{l0@7MCy<4>@(Z#AkHDMOF@60Q75EZaf-A3lhc$vLM{MC1?Z@q>GHol1;v%z= zKYq#64OgDGjo#ocm`MiV%7@5c+y~zx<+yS`@#4xOWI7&&y|%Mx`q+_m79;$Jj&t*39 zTRatyz@$T*15YxMi^yO$TyP>O!Idu(FCK(nkcGJNPqGA;A2=}y;mT2DBW}PM41CoX-2OQy1jk{n0@!^n$Y%JCt;Fn|_u5=xxXSxH-A#y2q0X$9;apkvBh7ym! zTmDO%RI`!2f8~O37hFryN?Gl&Z;w)O<1T0sV+;#WWpB??DIddu;8VRyr5+E!wM5F< z8Gb_&@dzB!yOb}ln~j`$ZmAr_l@IkTl|FZ}R$%`5rIL;t@P-RYC3!3lD7cn5aphko zANsK&7nVvU@!-n0NG=|NN69Q)nc1&Y=HUi>o&<4a;zgyh4tKztNfcLpLXP8M_y+sRbO8FW;J%hW+Iy?ejyn>;; zi!}r*2bId8@w`2Umt0HlaW~8-2Ch6p%JC>n*0~6?;dGbEP_hSC9=fhn4rn9T=Xwr0 z!EEFiH~@6xkBq+E)KT4iO$^3zc+zr3@?>V_!+~^QZd=+ z$AOp59Ug|CjN~M^^0#!R1DA|a89?fB7aT%dlUN_{6Ox99 z;SVGmS6-XRsF-ZHkt|Y$D_zM<$l?7m-BZPb4G%^QQ<}PL=a05D)mr5ge*rkjm?;w2Ui9)R0O4X&K{A1)48en9r%%697*Qd~LV1A2*j;W{$!KBf%r zB#Uw7*bkZi02^N9K~jS&e0Z_cuKehGj)R9`?*lxzaOFFs0#_bA#7N-Ewm)z# z+;kx4|HMHTai#F8-?-BM@Fh4nn1pc;oI?7%!k>!ZQqm6(!r&h~d|t!h1;;tg>t-Vd z{mmM|m9LPYco6>e4|fEveBdPWA7I0GvQ)N8nN+@EHga^cGQQx*Fv7Xb%j5vATtFJ| z04zx;li{m){=)}IIqrjpNdS++C)$)r;u^D&liQZ@>mm5c2z-j9;DNSgnfQ~+q>pYu zt6iCF#+3!9bAq>cmjZXUFXP|tF=wz(hccV41AL9dH_P{lEhXn)mY|jSU}sn#{ukaN1>M z68@1!a3k4;hhak+?f=WO;fgZpdNpn8=>UAkT_y|vfmK$j#!O+0{7v{vTWuRS6-0M0dN;ADJ+v&&8$XF z!B^tSdr1&izC_mG%KgPWpYj_^N%Y>j46{PxbkkY2Df04Y;3{z zg5ghOUIGV#7nJiF?t;^Z)spt`D^k_gYGmI#spHD7lj$VxY>hlcX7%y!n>qEYMJ3hC z+qY>cZC15(on|C>TX>p>9$Z&ay>?xRIsCcDTnQ~Y9!v4JO0arf866~ITp?mzA`-Y% z#6{dB!nQk=*Kh~%;=ZdP3DZ7$#oD3->jKjZCGjg4#3{{1|0@CR)9saqsTgsUH??Vd zdz){lIN~ZNsD$DweOd@#c(v~}Oe^LY_R?LHjJV2ER04688Y+&C_PxHQ676KK{6WRl z*W zQgO#shEg%&Dg{&mag}Mhm)XaD`bCtyah3n*ZgG{c?skrSuM1i-`RCay=~SY9?Unne z80Xt7&*)y~bFcqznY^#N#Wnhtidr0;ur55UkdwaazwU(@UHtD^R&W2F8CDyA=mBe}fB*W~9sI73X1DhDe$eXO+}GS6 zU1D|d=RatrH(%V`Z#_4wyZ_4vt>Mjr{vLCfPH+FFleExfFFA=Kp3Ci(NmPUzMLXTp zW)_v`RrbnLy4N-K$|~LKT6<+P73(^CclPPh4df73;3v_C`6BB5{o-Q1SVHnae;q zrr4Xls(Z&(KAROBmr#nLuS z6~30stNgY?O0GTjMo&|5$5mdW;*G1U(gVd+-lGzYt9(X|3B^75}B}BzKWN)*DO0>>i`9|CPXs;Zh;xmufOaD-E{$#IoeJl)tKT`t>Tb5{zzqI-pr*&` zSyUXqHJz-f(w9mou5vXMSG~Q>Fe;JX?Uy*3O7stVo5@td$LwwHH+8qT(i2pSvWkioS9y<$oUpgqNW~df`LYAg`siQwMtgL(27Bd@ z?iN>xQgNNCOrBU#P*ysjEOe@(mv};t^SAvtr*-6_<0|bt@~jV@DtRYY7EG#~IL-4< zY_~C`l?6qm7hmQ$X|GgJ@x@h&N-s%uNHhM|2bJzsK_whlDJs465?{0UHkV#v`kLEI zMWvUedRy2l6;zDVVimnaJ-xe?y`q;Gh^y%7B{9CuC8<_irGg6*vvquJ)2JR#u?nIVEzcqJ!C=Hdg0Y8?B^K z33RbnuGiz7X|D{Y;xv=(rA$3gT*aUwU1M$Z+?9o6#5z^clZ~ZKIId#pUT4Mj(l(D% zah<9(K1C*`@z;pr=6gAfe5V@eZm;X1<0@}ciFUIex|Rxm570JoUr`CfRSr`L##Mf! z;yRo6Hve00e^ZK{Z9h<}&YZrxy>bSXpwnLIM#a_BUO9(K^i)Of2z`n~d)eCz&?EQe zz0Lnle-$NnAA6&rdgycPl^iO8^X!$eR2&!BE0t8FpS?1hiZ`zE7!~Ux+Wham-4aSZ zEuDI|_ac>OTxFdesK33?K zck4{Wdx^c$pNbV%xq?a{t}>L0<5K%x8QP|)ay`#y{jZo(IIhuTDv`L#qg432r2mdk z>~p-^-|i`E9Dk<02eb&MHuLwKW1W5e+cfqKY--%}S$iXuP+a93J)r-hr}+{?$Pi!>Rr$Pg`S~_4Dt0+8Wn9dYM1)tkvCL!IvL&W7ZO0^Z0*RVhw5Txv}vzbJ&@T z%8jwh(#~X2@x@ifP>IA*2sq0OT=>E-n@-9zjr`GiCI;woQLiQHmub3`k{?Ulc&I7iqk zXCyP2ah2XwJR|LG22pWbo^CGJ%p#aBINjcq>fbpJI^@)oUSz#7`Z zmD$Yy{MR$O_hpx0X47Gtrgjb$BiCMeQY(Ic!0LT@sL=jGP+usrSKg!I9@A85T8!JM z1pWUFu&iAEyyva?EQg<-w}!NEmN%^~^Zc$HrQCj$R4P(ouUtdLG2ULeMfdXBE16V+ zlbR|`=PuQ~D(#giR6KE&IsR=+t@F;YrrVo+L^Hl>{{QX{r@zMwtm8H9o5u0A7Z}Ij ztfpSH{Dob@v-~N`SSGI7O}jP?=zy~rleo%FRKgG1+vHM-##Jh*_#TQ~g5C*ps08CG zPwH{vDz8%Um~-vBZJ-p2t8AlUJZx`skc!N+SAL=5I91WNp%c8Nz+QQUiY&BO)>DbZRX(EYaLXg?KWk-c)1isiRgj#2R}wpW^`aQY|hmG)E|ag}qZxU_P~sn2>>QS!t!x{Zo2 zu3}IL`j5QG*D{0t_AfCH>HgEK~^~>B-{rD1f+Znz5n_p%Z z-?Pp9kA240760KScL)7~bua(M|L{_XmkJ-A+5LPDW&~mf(-rd%73)+bcKFb<{!y=3 zk2W95LAuQBn9DL*SAR*CH&@ZYnN&xGY2#NVvd z?4JI_SFNFZdc5ORt9P!kJl0yz-{Wkq=tX;F0G04d_R6(Xd@tK8(|J02Ua?m^vl;(_@aC*pi(zQ#rPxQL$Da1k%Q#zh$ZUtZ&ZY^<{H{F_Ugy55R4*TLx4oyEB}R*9XJwpDL%fOHP<2Q%7o75(t~Z(n8g?r5!xwbuP_Xa9hI z_9|;2ufMyBRZ!8<@0`ezxOug%f_ML2Qw#MxHTFH1H}3iAYHMKg(7TJ)aJD5Kn^xna zYuGbT+q7rPPiPme^*5}sQh5(@@tfAbb9^7$57e&*^KhyX>q5Z)@S9xC#*TjP2VBir zZ*k1XCrzJ9&u1D$R4Id*?9|EP5w#Ji>GAh&wiC2(pNJxDc`NL=L+DvqtO z!)lvnv=WY0Vkh$Y+rQ0;26t-e^RsVrBHzwt{xAOFOFZlm`Z~6U9%Cn!z;1ixCn~|c z_DVA+;}Ta%q7v9=Z<9jBv)^9nMp|;mI3m)4cJGcfq+mnUJ=zo%By%`X^SmD^}r5av5zx z7uzd0QE}d6uVhd$hS)1bRK&mGJ$<|0#{c7c*4VZ+{HdksD|_?&cVBq_S^j(8w}v!x z_&<1GAC`C6_nyGQwoX-IBk1tAUeD0+XOyOg<>K{?_xHZ_R`1b)5wZPa58KelSVeoW zP_H@NUeTM!nQ5;)M;muetP(q`*Iy8_#+~Nn&mS%Qh3jUV+4R2s=Mc-(IjU(OZ+n?t zJ)>f~>IvVW5{j#Aq7sR#d_%<=ZQtv#wi)eT_5pL|^dI?v`(k^SMQOaNp7x>Me|i5- zT-RP)YQBBXbE$+3d*uo$(L#G=D3wUDy)ueQxYS-5N5$vA?jt@gc>SdxS@WBxoZ0k# zG`W_CxVN(D3X&hDolLgx`J^6ws=u<<>UFcHD)tIrz9^V<&-h};^jJklXQQ5XhP|?r zN_3XJa*#^sA%CRSN^Kr}!QW*Ak5aGymJKX{nlr`UqaB~BzS+R2$g54)bpD{;JPBU4 zALBME&e!dgJE=JQ<36@}4|A@yzwo5Ku+CmtMJ4jKy;4gh^j@qITOs1#`LQ*>t$wbJ zt?!;gW_0z>{e%Gv);3+-Rp05+YGeEAApA@v8dv#;N^nE0P3-tVf9s7bgv72*pJ*0u zWZAp@`!;gh7@x)(>jC@rVLfe%Rbsol{pWwm?y3LozV1_Y5Bi&JV)yWtSYzFN1iMQ( zR*CH%^bgy_kQ-h9z3X;uYTUo)XS_RbeHm-5`|AL>w%IF<_t=hD<$p)K_cJbNPS>Uf zew)qAq2ueOVe&`bw-SbVzK-n^J8n3xqQ~`p8*3B0<7IEG5<8Q_zkV}k3UzJz19zz1 zjMo0!Kj#T(?EQDi+^a)&YCk>O!&ID+|9>RI|J~;tslKZ}u%A!N!);xA8(F3tc>{7&katlx3WdHoFoZmY5@A+TjZ0;XojrIH?Dn^~X@&%QEzekvN zE0#Ya%qNk-{trM4*H8Zrn)@>=A-TRU`w% z@b*K4Mk;w02182o{@ZvK&O7PRS@`4nPY5%ETcPfGCy4OJNp=53Dy$e#zyBv@w(nga zI)-!B=urHn38MY~;)Ye9k8NQz>>Q4r+Lb2HdL-|&=TM!FBFZTmvyu zlPlJQBx8bXu1p0?1w7HluXjZ(yb(0(3bx|MOVgGV>{Vl~`orD#DtcE}QPytZWQ!n7KL->fSse)LnGMiy);3)Kjmab~EK%gSxY! ztiFJ$=MkZ9raRZ5zP1d%>=}O@>Ud1)I#wuWb6Nce)U7RKauLL(B6mT|ErpDz!bl(8 zKm!kyA;U$)$9n_A7g>lNP0WnVs0bS=LW8xkD2N8>jn8OC%7S>>$fOpCv#lV51`YQg zyI9)`!n9gK#%dBo_=0)^qq8;c1KTyU_AhI%pePEuiNWbf<%5%)kCD;5sY02V>k4y* z?lPH#-IB3~Aff_KDjmLw(cmb{*UPSdW7JxE@=@DZWN1fEq36HlIAp{?cOGH2vD|3x zC1iwcE4}<1eYK}7Ur?;KtfnAr>~Eo~y?uo+Q)fF^T|YsDx`RsIhPtmTyQWH@O}CNO zO!VkB8!36hqIOgN57kXn_YQ&-9vfJS58pw{+yeq3Gu*X?B>4siC1xfIA#)8BM0nvI zKt1l_09MqR;Q)sH0abAE%}6`)5hx`*2>9CZt)d zXHlzXq#&YJ7frv9woi`by%PNo>NHq*oedtbp^`3Cm=SFyq>1q|i2yN7kVyiFXCm$T z2fJkh1wFv}x{>BTVC(BNZa8BQMBLM4rF0Olir7JPS+dN0MyAUohiR$E9uVV9S>^4KGuUrn<1Q7WARvn$_ID`VXO_UoCX}4X+H99GMgcajp|Y#8X4x z_+U1(9N$GXc!bju_c}6P#GMg*ZhnNm+Eb3arEo0O>oNMuLbk_PKOO6ZC01J<*!HN1 ze^PB0GNLvMU3`q%j+f)TH}nY_q5meBa#mT(Rvru^mT$NUPx4j}!?!Y74&wfn-aNrB zUQgAZ!q|&)(tQy3Qx=x3fiYO|Uu$%vd+Uc@XsF}AP)yd7uZxmE*ZxIU8@}f{p+&2( zZBqMZ)|!RD0y$<3!=9Im}LdBNl3G<2=o z^f+4a)}Mg(zqQs3cim%JY|FF9zvU@OrT@eJOCQgVeY5^UH(Kb_e-O3&BSc#Sc1IQ8 zp|l2#ddC9tATR>oyt7u+x*se`vJDMtzG%K}STHtW{##oALuxnpgqN%(Y^|_95=2ZH z$On8{OQY^tOVZ~-wpKX&-WmjBt|z>nO2w+8^YPgH`{7U?#QZ`KVa-JYwYFhFnRFT- z!R{Aay>dMW>s|_B=1dz9Zypiq?iZ95jHYa-N5RlHXhQs(K$;w4iw?(M0Z(It$hABx zhIWM5(zKTX(Q6rMD<5nM3ZeZCmDmuNcTjeyEupqIgsHL9cJ}Wy3iJhJa+7(IM}#LP zx)W;4*7{(a?L}7Pvz15k-k;BwkYO$&t0z^%7%D20h9DlDOuB)1i^*gZh$TuUnINuc znGlG+luUMj_==U5(K#S1jmdATnP_Sz7nCw!a(0o)M<5to`E3bF8VfJrX)p~1h5+GF znhN4c&y5MQbq+$ahZnGAW3%_RfDQLUX7WA>U0WUDq#*@uHMO3Z%4nf;j2t8t*6_R(0)jdo0hmA-596?0jtyCo(HeBWT`n@aMhHcRtUT2AWsMGWR zsMIYC6;FAd>y8wLo8Gy++Gw`J!Phk2j{yIciBgK#aOO9c(u&xIYHye4*ITcOu*$Nz zW<55693N_W=gVXrWPA$+dEbPUMd43)qW?%NSqG!WMIlr@Rf!G#A4b9=TBftrKtNCF z5ZBJsCjt)pmW5Eq@2#+AL06tyXCi^gc^TO48VCXx@UJ^6~mLFa~$MWdA13}$AdZ1_JA<0hGe ze~g84vrOVZ%-_kRI*4bhOjYL<%Yf#B_DGKvQ>4U~z2si{aK z5bGdWrX7fWuuQsxxK(5@i05-zW(80`2xf|MJ6*r zbW>$QARZN22jb3`&3H9)w`YY@XmSu3gmMlW?s#Hy#Gx$MJ4za%1eKBa0&$oi%o zJYCSPBwKW%ZjWq#IdnZL@(qZC{!Q|msZs%1a$&NDPS-+~yix(HsKd>zRl3Tm-7gz^ z0HXU@koOs^ZAIitZ!*8e{;wj8=nirt4Z<3t#Rr87%V5!r9Fj>Qh($$ef_M(o)Jj-z zbd*yGZH=MAmD!&B7z{7Wime9;-wD}DA7Q zvTX`#zMPEB*iIV$5!;Nt?_G|Hqch_Sg$dVrW)$YeN( zPel|EYfB+BdO&)g{{3J%MGy`CWkbfD(OO11K;||w*#e?#D~P2pH)QN02<&L~LdK9P zlM^70UV;p-F*=Ra?=}mS^}2W_!bzlN=NIR3(jX6Fz|fy0IL8n#wiQ+2-A^Wu+S9lqG) zf9!cRZ0g6$o@`@ef*>Lb>1b3q2VZ-7diG`ImS7reV^RRfz7e>QH2 zK;N%U`d&!BCmXWfI>K96xnD~-c}zBM0WqJDNd}1bB$*r8;vD@BEpSE=R+Hag{gbo`n)0s;XWJ0W_Nix~QYMLw)H;7}ZOinW`I^6~- z$wm3wVuL!T7Wsx@C$Xz7F6Ob5Xv>ECG+9U24#R!AOkzPyRG}UA|IT@GK_e7+Riqt= zFbU@c@>X2a`T!=Pdk~*l52|Ha!?n9GpWf1 zZsw6_pRWUE&No7swV)&;-^!#Ch~Yb#)Mdmah^WFy#k*jj?WyBGc|F{PMcl>fiD?fF z-BzK&>iG=B^F5XCYHO+Wx+txyZC-Fl-N2$B+YQQw9|D2s-OU!()AWO^y$IS~6z8{sptjEUhX;VOtn?SvVJWU{WQKV?CaUS^qN_G`WQ(7OdeQx}Rk-8^n54Cd)ybw6!OOp8F>{+Y@(k4pWm}Xqovq4`c>= z$dZ|J9hViiK+$tjCObj&9+?~hF{{WeM$U5?EifZF(cp2FmGU zD@Wh=wngLrkMu^=-_+xer=|8mIiAAl!&2cxVHFlM9@JxcBFOuC?({)8L+S@c>3B2r zEwtYZeapW>n(04^LyH!K1u;v+85hJ2VLunU8O!O3}Z#F!Oj`~ zDtwB;N+tSXb#hSsewbP2`g~{ppdV(3sX&;2B@b-{IVaWb?_b4w_D2Po_4)0ayZzay zD#+#P4~3k!pj^WwMv8L6yKoMORVT}=1aZ;a0a(r51?j*5jHJEJM1AynwrVjESnqIS^lc zS>_&yw}DK8I-}->as@gNr;6x7%#CFk1Cz;UDjRABefVc+AGJQZalsgz( za3e*0Zp#jTgF`qzlQdfXf{g>8;}Z2vL(=(>tqemj{){8T=-Or_wjQftB)7*0?nw}x zMJ8Sl_b8b>W-|2M5L-ex453kM+UA6iZ)9dkdOifhOW!Dvj_7PTC*9M!U>P~hOW_Uqa~1-*S^tY9)>%x zY4mUy7FP|vvg^NiKLrDBt8CH>VzLP$^fi=`#?n$FeuP+LIHs*>W?*({x}nOMLIrWs zM1W{!%cL}jA&&^NCfYh2*HbmfX0auZaRjV7vboiK^`PO)rf*01FM&^wu)W5K(}|J( zTvXfwEj$UtKDN+5_z3oW$@N-}N=3gdl4X~Mhg?id8uxretQCJn0ky+VZRlX2krHEdw$U&DvicY zt!A9jCk%-CAr+Xjkys9@@^?EHSCHfCGz;{URbf5l3!^3#Gh;u7G2J6!g|%w{h%b)_ zyO0mq{VkaE|Keey8g`g53!_f>)@=6d< zvF9mu&BPXF2JO$pcyqtvQSd)XT-N;hLvfS`{JcR$%T6yv)2AVj$D5Hc3y<}c$g(8_ zyIyk>^*zkZH^KsIyBEZ&B0doPJ0T;Sa?zqJq}snIXgbS;?*axxK0}-Ggqgu&AbL#! zxFq(7@k}O<2!j^-6_&JRn)6ZDbq1p83@*SIr3O&(1j|O+F%lw(Fyf?JGhn21bH0}x zI}<}!Pe0AXfO64|nf_T*auy`goAdOsaTX+u^k^1Fr!`ENV}3711-?8YDlk&r*-&2+ zP(M7|KiMMYK;2nTR`)<%6E28Q*HHI4P~X#>&yCx2pl+b*b1_#|X!cwfyd8*IsdXzx5|>Ra$owabR4 zwRj-jsjRYSQ5n#aD(}&c`^W@@qk$Poi7zp<4^!QRY_)31U(j}cq5pZ3h(+it zR|8p9W5$$eEE64wtEnKOeGVG72ocY0$wqhry``nN)n3Y$ zgdTE13y8XV%7lI2z(pBLZ8=5ZAY5X5?x2#`P*U|0w&K)$nJo=pve>$e4ZQxm1sN}4 z#xX!P!ydcy43tUXelRsiCNtrcVX#cfK*p*f1`zL1S*8()FHI&Lh?d*dVHh=BVcS;6 zir4AB42b(}JzQv-FNo+MUw^8&605p5g^CQtgONK{qL(!*3ef&Ptg#^j;5sF& zLhPM6LK8?c8wJ+2f{Yv6$A8@CS|^CGuAwQbFvE_w3S6y(uZDH+y1-D}1S{tCLT7wm zZpE}g5Mjl;j#jOPk1?&u_&dG}_mLBQ;NHNkH24)(ym>mzyFWoZn}rodZZUtq6GYf` zZy=8ocI&kEe>tmn4xDp;7jRBH5aDtO6=oz7#J5e5JR{$cF9$}(x8_59>Q}I0+|I3Z zs|X$IcA>+p)B@4{Ad?m#1{LW7;@Tl(L`^Un7?vgIQ8}!)-PT~1Z{*JZy#_POypvbk z-U0)Tox%XC*2c(>GWn8KyGtf(naqAcM73rbw-!_Qc58k{UwNIayw-PsOzUj%Z43v6 zG^=9=^vy?P(nycyACt*JR_k#=L>;iVXPs@Hwm}5ZX+yH?X^y9@1~bh3X#qZX*WR zUu{I<+r)bGckWDy#!#^QE-GRs+Jcy9=_afWcy4wR>I-kn>+8K4nx3;Yh;Qp3@#ntw?<(T9 zV1gUY%NGBHzEMSPusZUH2(X4GZ9#*_x8;j_!EexD%f�HG>h`i?Z1W5T}Zi0nuEN zWh#TXRHP1w_p&V048(UuCMFQab(sw84dhgzks!t!vQP#ybWpJftHWSwgu9u;{E;(IE~1b>c({wtFh5chML#Dn-= z$fN<2c_Wjy(Llzx0*THtQG^S=4xlOc2sXV9_&OBAt~_D1RWlXD{GU)~WCn;wMZRKM z?_?P_h)GjWnx+>R36jYJ5T}ad%NPQoe6mnU5SNNn1@Y#WWtxI`!UP#Ud~_f7vMXl+ znXngPISLAr7X^P)+3Nn44o|Ra@Rl1}FYWPmw5kwJ@3Ox4Pl;3CW6R*y3EklXYWiQV z<;^3)nubbjLv|d{oY`0|>vf|!bK6nruG>4!6fBpk=wR*tSh@nug zE~}RYvE-32(k(o~d4x455i+`uWvv<@t~|oD{Jl^^midHPuEU9znb8cW$534vO$D*4 z$WjnT9uXa2pn*FusKeSkx$EyBo;;G?pEt))PdLU1bJdzh zL=8^blnc`{J_$S$QD-NToUaiN965K|Lh!Sf!VGK8YgDB-3NmH@ugaB2m`vy}{HKYK zVI&^J6Chd*(_-#en#nSCAY*RFi8k*QUA`iX7-D@pzA%n|X#X)hSCsN2&MOa4_K)!0 z(vEvuDGde;?PZf$AdZeQS;Z=$X1i?cdTTH~GJKsxmCVtWX&5SoCjQ#V;= z36n{c$z~95cbOaq(e#kX-yoJ&Dx?_>hgBpB#M@g|s{mr{BZ%lo3w7L$p<KYI{cj*>w#cfx zKy;%7v5ZV(QP&vqhzOUJ=I%qB)|vw2zRXXst4}XT)w42VqhZ9EE{q5jJuUwUDqg6J z`eRx=RdHh@Wgg32$#@1G%UGeqD$PF<;ZTtn5QmCX0&%KHJrI|Qv}I(Ruq?bm#er#2 z9%-f^*_T_3lj9JcwlVCtH41t`Blok-;dpW!!)5Zj{Ww`LQ1;Jw9M3bEF}xskGQIg3 zp>5TXe+_chFWCHgr;zIxTaDI^siH#Glzni)ry^%S%o(!G-ymKUdBbGrqXU?02I`29 zD2-ich-RR^83%CxzgI^Ml~eF2cD;i*A#hTkgY48c^FwhbEjox5X-`Lf@YL!M(!3_C zAO$_d@n*SS@B)`*hiv_{nk;`4ae^E7E27}-$RF5p{R(l*96mKd*IUp(^zv6^5(_ms z47nE_Nq-B`I(?X3gUu~Sec96_4UeG6J(mX!pC^wXXu3}W-<>`RlWqqe1mrww3yCt$ z|IllObGcaiW**_@b$a%(= z=KsroyKxIteZO#39=)GIoCiKMW~MHGz?d5cATZ`T9B5*@v-p}X{t7f?sFuu`xJ&oo zPmDyzSz9CRn@;38i}Nz`F~3I1jDaJ@^cnQUz=76da;1@DP-%ehy-xy&{P})NI zFJh2eI`eDB#TVh5?{_{5V*Wq{rZXR^_962w-%a0L!BjO}<_=Vf9*fy=S=eOVQ31qr zMG(O($6hW29U<^6S3{N+!>UvF_cdE|6Vo+b4<8y|pk~c=nJ6HpJR*F7jX;Yl(6vIDr3iJTXy5oK<2#%G-9!gWrgFE~lkWGqK3>#$3;GKK&Xl?h zed9m=vO>mxgn@!oZN4zDkxt!a4m=PJ)V~7*?tlYF@4$e;$IA>9c^4!6T)_CDyU14F zN4$s4Eyf{+k9kyiCg=g;P>~TJ9u={J_?~br-aD&6G|vPPec^pXL+>FE-0u=N^L%j+ zjmOth@8ioUuD5cvSDAtTWby>Wq%DNb)N8nF`Nm_ysYn?RM=+Ope+}TIpY9_Xb-MDm zkA3nFo=EY8E`EsTi?t6}t`054UfGKWpF^qL19Y^bD}V6$0!p=>e2|=n4{`)P^*&pC zk}p93J{7qS zq6wGngiJt?RHO`uMMVrCo{XZhS_>deq)d8(SXJZ;5SNN5j6`uQ-Xn`aoYAtKZ$NZ0 zf{4Hv3X%CS0^{z=zohiwF*1aqR3ZP-K;@Irv6hnUUI1~Z$Q=-0DY8DnO(Z>j>Wzh<*5b5s$N>VIZd_kzvhDj3I6nXx@4AvRTn0;@(3VoH`tO-8EABn8BoM?^KS ziP*CJW#58$i6ceq$K~_E7g)p0RQM%ZZ))-2RvHd{b1m7T4aAa1ghdnWhn{wADqrGE zuh8|L2HZ%E4N%cFl#Tod;%y{|Fam{uTcz-vSu-VuLSAE5A4ugZj^#DN;cLW=re1*w zV`E{0#ly#p8f6kR8B|5s2s1SiGNNJ_4ODzTgg<~#{tYJeZ5sXt!SFWYReqcVbNc2& znN?W}#FR&bIVc3o<)hVESdW{(ML3eX2aeZW>@QzSZnQ*Cn9!uiMu&swsM>$*u4^l~ zAO{8Jwt|S-*pDgvhiTWjJKsa+dk5F8)ZrZt^c;E8%-dtocjXbGk1w#iL)Xpe?vL`K zB&Ai5Ytcw0p}x11sER4SWL|ZaNxmuUSVRzE&c(DSd$PR*nRaA`ExNC?(z?3yjaO=r zf@`hLh5YM(`~N}T(^crRI$AK&jT64)bOF()%47hDRYfK;8M+gsBw(XgSgYWzF!;Sk zmOHqOgDCf^$R!Y;iacR9ddOOZr$VNuOp-v%y<}1k#H%8mKr|V>Wg!cY-YkKpI6RH$bd*nY;n?5N0f5YMJU@zMx<4CGY_ zh1u8~4+_O#)qO43&>97L6)`i>Ewap15QB=$0kNpaN)V@tYyT zq^BR?SE6aBTu?$m4JuLr#6@pe6O2E~qJ5aCii`zusz?@yW|yqB3`D0QUxOHS3mK7L zkUroqTf0u;2HgrR{+CwgQ>Ng$rfhx%`}1DpapO>MOMZpD_ro?Ahevt*fhJaT^c7x~-$TGh& znS(O<9Ypi1Os+C=R3;BWTq^P(h`W^v70JZ#Jua)21+jW$VgNCm7DU9@NS_r@*h9ZZ z@DXhOgD30^GgJRV2(zG!2JxxL91!DKS!OwiLq#@$xc-!7c7b?R{(-0UHF@Wf<3K`L6GgU8yHm{(S_z3oS16L0|FI5d!aGBVfUp?#z zS8%X!jYova7gnM(%-4i17LwJlZdH+Q8M!XY><7`@lF4t(r@Jz_0pe4UCm@DJ^|4`leLC{m{r6E;!=^t%+4!WYa@s^=oO_$C@pakygLFdJJ6ed zBX2}8#K89|(6!$eQ}CN$ujpto^nRT_fv*Tf`Wv4UsiZ{eqr;Ji*k!ATsf%7m!k)1Y znUCSio!>?&<+aVB$$nYnSrjz&)VR2UZuX(b`aTu&Btvw{vn zRP>emW7=6-nWw$qhkxa6Xc@Q`Vh$W(oGqiI1)DmA^TYnZWzh)s7duzYC^-iMFJO;5 zlL(^eBx+#os1IUNk=7u(&azAo5KC7<*uiO^v1$E1Jp~b-qT)bz&kV=Sbs80`e1=JR zDi%(8dxrBv4*UXyxf}-SMl=6P;)8M+%f`Nw_?1C5Kv@^8xFnmih<=Axxv$z&jiOGOkA%Nki` zJ&0+oOnw2;tdq%A5T}Z~1~F5~1SO)UX1y$0Z64sr zOopZ(Lact6F0=)Z|5#DGC?NyKs1U>UNV`C zOc@n+0Iifs1rWy1E{@QTIr>um9v~mY>{)OL0cvc54ZKuX{(Fth-aWMAY+mm&XwB0#H z=utXer&GJ0@>!&QjcnPxjJ142J?35x9j}KBxt*E7k5kphxx|}+{954<{s^`l;ZZL! z1xk)1vKi)}fm$?B*yC@L8o-gTLDGw;3pP~Jv<(K4@d&OvmNis*L>m71P~A!S8zKG% zs?rF(ZW_c_ohyy7MfiLW-&rL!h8f=zTG&{LXP-M8qk}R7W``Q#?~*}06Q4CIJrZ^A z6V&Po)SBEBwhj;SA8{^e3U@W_g`ybr8VYTOL5go# zHdjis(cuox3Z);Lp}X~r;Z>y_i}FGGd2=N?(wr(RuugBa99>NFo1lawGPF# zK-eY^=I>u{wNM;5Yi!aI_RKW1rLs*sXD}HO@T_y+6lg7BbtKTn6eTUn{gp5+oO6Fg z6wijAqgdFE8En6!+uocQ_4J&xR- zDUq7*J~WQkv9?9a@vfq_@H?4_C6J|^(kjEfQ^>M5E?t3Xwp%89KwSG|a+Q&jGSRMt z>Tfbh1Tp_1lNKPxKV>oy#M0xUjHWR|S7fpd#Qj(%2SN1DWO5V4_*y2RtJn%Uzdb@? zrSt8v5}CE^x7FFcmi^m^axXI2dvXlK9V(LtAl5=MdB?1V%cR_D$f!tT5T}at0WoJ3 zmen$tP!XA|2JsY?$Jw$Mw)y9Q z+1x>C6`qQumk&k3LE%CC`_K7Im_hDHGMSY4qV7m$mleM%#`47ci`Hl&6NdYMA$))) zb;JP0p!^hXCb9IGUVy&rsC3u5ljuQ5B|hApB=pON^Zk5{Pn9&x0m!rWANkev?3aHH zo!Ax1|8)L|S825qA*~_W1P3&mK^(PZG77{G zo06hU8_LsC!Bk{3UkVvgmDDI-E8&NTHcD2cA_Hd*p*#~V#viEuYIme+ zpP52>DDlWN6?&jf9ks=6THiyd5vjAvCFv+J z&_6J%^*N|mPbEImxm6ap0s#x9^hEVe8rD;(8EN=el#BM5Xj@N2$xY>Yu@xbWr?zi< zVJ-2#)zPCVSd&V8rqnHpzXAgU@66JK^QRTZdM!19QGO1nr?-3Vz`uUg9*e4-zgI3or3XMu^Piv3}4Z5n?W?}h#_@ifi< zNLER@G+yGeZJe*%7&l-q9kUE@S zfj=9F70^9|1`NVDb>^NLq_huaf5#40<^>-g?!SukS8cdu52e#XG4{en@Nc0s7{;c? zxCnY=LfCD?l;Y?(8phf&j`j>=*YE+!HfgBw^AUX5?MTB+b5X)@bhMFDhNJl|nlc=# zhIK^Vs^Q-m8Ad?OIfCEwT`>ZiKwa+s5lV^R*5(DGk!)ZV-oiFKGN}&YSRs>^Al|QJ z(i_A{abGAY8IE{KrH{rWEY6>At&#TNAOkU(MT@G>GWt^x_U;w?@oV!&FSbt z!}GupU7M~%Ct98h8!Qwd-(od=CzA*eyt^u0!Eby87n4SFClu%k%47(LF@_T!*(pqh z>W+c3M=uxbVpfx7auUSVSSB|>^z`Kzj2FB`W{ff{G~9wkLV7`6>R8NFTwae=vfJqT zaou2z*h1_23&L7f_dBE`6=@A(R*^0s-T^dm9A>qM(j8Y*nTvzTutDtEQ+ z({y{1a)5n)I~lV%{0p%!x6a1Q>^lWBv-1}`%^#n_X6D0UJgMoX;*!Qpb*Cb7IIfwh z42#r+MM_;)dmD@FKU3j>fg&=L?4r;`Ia^f2e4FJQyc=Pgf0n^Gf5UsbMY9R$pE1Q7|!tEXi)q>I$i{A9GEf_~gi zqZEu;b5Cx�jR_OQ^CgybNNZNW0QK(%M@T2%Bcgup?m~AML;ND3XaR7nQC~FRL<9 zjfQSzqTL!QG!4zFk2oJj3P`-hFe zCHE{e=5{*2YS}ysnjvF&4@A#arbhX)K2-5#(Z<;rCb}`aMLp&~r~DY+qC<1wsUsVn z;!Va>Xf86hk>cjEIXzz(ViBIY18H=zOuhthEs@DrOok>w88%kqqbLjq2G87Rjpl!R z@Z6e>!>xDJZb$V);jW8VuG|-m~&pr6#9Twxy9H_@iHhe^B zz80Fy*MwY5)^BO2Lm4{4uvIQug%Y=loWjMDb(<`+88Z4GWU?2;r6NZ`tUF|xGa#NH z$uS?NChk3SZoX2Zr+J?&(Q_we#7{CA4C4G{cr6p1t#H%eUk%}OeLNaLtg6aJwhBA)T z@zL6(XCQrLK&!aiAoLA(8ZP5$L}7htev zep!FA?2`^7&iS&-b`bZMaz)EP%uboOK=kWnvX7AsGVy?D$hH(GNv5N6!D|#4DHjEG zG{@zF=6kU)pOi^w5dA5cuya|jhl(x34Jz!@m-#3BFnnlz5#(5gn>#xCa~blNqft2x z8;*QX)Y-@Sq55*1r)lWsa`eL)>bL?Qo#{~yKj?4;p&PEPP^KgqjI!z;sG6I~Vzy5J{7nX0c< zx}$vdT8z#zlX$*vv<{aNhDm(yo3#$hmv8Zw!Tk0EvOYuHQ1 zcU_9&kCZK#Yx*nY*bFF{o3%wzf{;oId<*&JlgS)`=YaQq3;AA?$(x3gsY>5L-d$Ah zpE338?nj5{^!~xcz_=?M99EgcFz*1}L$8y0YCfY?Nxgf6IGC2t19wd{? zAZChm;c*S~D7hf+XZSK!CiOrZ)RT!iSIPy0ndoMjC?HN+<5IF~yLQM0O@4v*KglE& zME{3OEFdl#veiE$=Wa!Mw$d+KmF{h&G&{mwUvkx6T z$48{2gDh6*5bLFna#8N0j=31~zE5diu2Q45xr;1!6LN-BnY;qgeI^rjs_X7A6Wy;Y z;PrR|0o-L`+riVXnjAC(T%f@icB~qxQ0!99c({ax{k*C z53WKX?>616yPr4Q>4e{jiYA9zbX&EBq92%K^CUE}K9dE%rEyIj9ti zbe0pU?B^^-^&fzyH#~?{%o|7j4&qeGS5pXJl4@Azn~0czyDaTFs0|yNuy*VFBd2`5h7+pA?8Xtl596KKaCy!udaPCa-zjP&<)%c^(WbL$r zIH}T6B_+vnST6V-1>R#axd-AtPK%E!sThh6k17e_u#5g+tL5~M*c&AAj@@I3!&=HX z1{ca_`rkT~TjaQMCaAXIZ`l}|N}3lk2|9(O^iC$M5AY=TN&j@~a1!fwGF?5%E)FvT z!*j$b*0`eO{R?65W_0Q{w(j0DU)(yz5W&iKL$L3Gc&u%C^;ye#N zY%(Xz!?;2kO$q+U{`9{vp!WovjJ^qD9&T8<2`4qL0yQ7Hi8B|xxbP-wzD*f_L+K5I zz+Qx2W?nnRNmUE=8pD20nSnY>skYxt{(#fHRh(aLT& zg(dijKPl9Gf(kamCJXT4C-5hPBAzPQk=D7g4o@W8o??gTUPN!6DlHR@D`bJ9SFswe z5k#~XlmB1DG=`Z>pi<8e`($eTOvx#0T>qggCv4DsOdVU`Yh}^T(cBfYc;Byo4%fEO z!{^GB+SYG{E^Fru)a=_Tlhq*BeS*CAWz7rB!vg_>U0))8XJ!R1dse+vrbe0$eyC%j zYOmnGj^+np4}Sd>22%Oiwfi+{XfT^xS0FL+4WiX~ zHuwL+8~CrMgty3rdP;cB>$oNhJ!PQOVS& z04$p3`Wuz|pn$zA+p)GNWXI*Ao8}d=*N8OzB8;)HhW*7>v_A@=rPkb+h3tj>JKVyE zOs}~t74XLchE5Bm-G%Kbg`9K6Ma2sK@|dI|_EzkRrIsRgTxnkyUX2VPPZV|-JBrxx z2*^Bsm6=i$F1Djl#SqBviz1MwTfDLKtf-x3;&M9lkBPeI?AgHs<^{eM6c&Nbm_r>S z5MupS(8cV-@CXz{5*A0ouDL)3e^10D-^4Osu!1ybYJ<27 zQm;sR%S2Zpx#Scf;DrSdfi}~xk%;J-dH##>u2E=CnQZ=k@4ut$J!Jou-(ehYW zt^o~}?>{LAW6in7u5$JsiOzmPg9VNyeS<|1VZ%vv^=u?MSeO#%A3cV##ldfErpCdb zk#gcN5R7y%4sy;wUE||X=yR)8K(2(!riv_X^U1Xl$6~!IA=16bR>{6CN}nw&v5>j5 zsa0h-qNib%p|o*6ADOXL(2d9E^FYn2f*GM(%12e7y{O8$Lbh`bM6*&5aU;&MN)YDq zL&zAm$t3I^#`SiYlmW5QN6GetNbk>bfe8gh>Yr@KFMS=Q>&f=`D3?bTD0CmTF6731 zWN*rT>!oK^bg70i*oTYO;3LYcuPDvoF8^Sr#?ghU_Q_Z;yH&Ff3x9)06!8oJ)~^+T zM^XN+hR#^>C3}j{pTkVAaDF+?U{46PR;oy+|HB#LZiBsTq~T-PbkYOXh?3Qjhm5%$ zs@rRaVCYY;=}$Iavkxe?^a78AG2 zh8aA2eWft>yL#}GV*2@zCFY`5p zmrknI6e|L*UYf$K8H)qCrx}`KJXJBUe`;p0fd1Rv3=?L_V!jm`(Hs-T6%fDB9F_Py zi(A-RvR6U2YJrsC4hX(#0l{+t!9guy*KwXZP@={wtfc2fgV?NT27)7-miC%S=F4(H zKNL8w%fvsKZ&H~QOlAi)PQiM1o4&?})=YejsMiXu^*-R0<$i^~g0$}EbicJ7FW!GC z+xqD>+v~)&vFAh@U&{p@-oPpPqYaGXnS-`0kv*V6Z80d)>2zC!;|-BD11Wu4J4_RA z^GbME0p9%zE&S*K5C*{`d}zIGD7rlyHBsI6NU=yl5BQ%EpCCbdn^TWZ>_fFtOK1z4 zL$^O+BWnq7#rO_(JXX29QeZZVZpTfB4yfN5kXm9w>$cN1lYNT8uucfGkoNx%ky|f_ zQ0Fpi)GRARrlPnHu)ZTIJ-&qZf2~hh9$&)K;nYtNM~|x#+egIGtxxU6ajo_CQ+q-< zAlzbBninOfLvC0$l=+v?)E$QIMxGl?tt9Xo{+l~kh|LxgVR*BGM~d$d)a%#-?_cu zFMjZ%7Y5eTK)Z~eK`Uxm;4JPlds>vWbY&^q?ggmuBI>Jk2g&=qld>cGYNFt3{PE&mHAZ#u9Es< zo9Lnmec_}dU^T2C`g2df$tC^RAgcLc6?itcKdLyljCaw_{;1+Mt71xRUwa|U22m|- z5Wa;XlU5*(t}^Kg;-nwoUzBy7C=iYDwWs?7(2<(u{0_+KftVG#<^C5U{XG!X>Z#fw zG(u0~2Eilia{kbJ<-v&b!sXn(#e>mm-!0xhCDx-l{T)#cb8;(lk{%8A$D;1%_UuIc z3%R^H6cI+JPZx_gX4El=a#Q_WOYTW!E(k%iBsoB##2a{5j;KVTehC zl{_JMhao1Wm1Mq&+0s7EJ}lCj`(d3HI+lio5hv8cq51hrenNI`I4ZPK+z4D3==N6e zkMqzhG!?I_8)2^*rTba7<4>>$=mp`uC=0-T>ufXaZ? zykFW(gv$8U{B~dNM63tCamoG|x385yNMoKL^jRF5g6Jp7G2gSb9p!>W@_viSd5x2lznp{V$1*rR6q*5p4 z%*Ec`Nq^2oSK@*31!(=Oc?h!pEAn+g4thS%o)YOj_mMP5UFX;tNyltVZ!3+#ht_+J zmSv+Ze0_r%Xy?F1S}PjmKn`)<`iL*NZyf#&Y2tkNI3C8?B7bf^oN_QF9Q)q+i2vO6 z%mwz5NFOg3K+qWw-0~#^cXI173lU+<6K*!!1l=_PR2u!f(zZC=9MUCXy3 z(M#DzZEjVHsDmFggN`p-wz8X5xIiW+L7Xb$1@SJFWuAcONhbMK3`=F1Ud*(LSU^n6WSLA5&vKb80r9Pr$+n_F8CZE`bQnTL75NLq zsv=K8Tq+WxLp)R@3PhhHTdo3PR*^;^87>v-2&DN+RvQ3fQju{WP8FHWWY)-9t3e!V zWwMRQte4425M9Pb8C_*+D)JP>qaxuEFtkb5stDpx5hIA^Ygr~0#Q2R&EFjjc88Vsy zWY{JXCy4I{nd}77@0Q8$AkIB9c>vHJc#FT)eLEt8iBkgWucxR#@}Qz z7Q}Z}CJR6umu0dU#Hk`bgXpfvG8aJfAQ=B_DP;d1Gc}b^!ASV1BJm)OtFobbAWjwe z6vX0{Wrl)SRYU>tUV}_VUiHg>bk}9I??Id@auh^!N0zzHv{d93h~=&XKDe$Ba{Z>ejuB+f_Qy0SqNfzB$Evwt|v0t4dVOPPcj0* zKgHCZ$wFQbw~9Oh(LI-Cw8haKDiQ@^d?CwJ1aYZI0}%a7E|bAq))B}PK%5K$F};=z zO#-pJl?j13-pS+}W=BPig6K5Wq+xy$#3%^zAO773vIyiSZ$VrtQal<#Q;|v_#vs{r zLlB3GbOiCL$UqQ-R%rR_pU8yr5UW2ML?0rA7+K3?LS^CxapsrFZ%ivpCbvP%DiTxz zcHR?Ke=Lx`fUH&<#8FTtCJ;}!Ooo8yB4na~xQoeTIf%8mOtv$bQtt`s_W&8oyhrE` z5L28?!eT(m%cMMrrJ_ulfM}}8EKOyZO(0Gc`5DB}OqRI_ z;%F_Crx{F5g$kEK^=)OLBoKp&7(xDztosgZ+Iaf_t|UMypAurDVa!X2U5#$kMJ0u{;Azr!_%{m9s1-S>Y zeNAINKpcW(&4=^9E|4`Jg4)ou3J{+l4Ipw`8q*Qt7i0*;)}F>p;nI=HQi#*mnbH=J zOOO)~uOL?-0YM%^tX*iGPY}Bxx$+Yn5_VS<}R8B+mo>cBZ{Jp4rEAZ`cWwk@e5KDV(nj+u7BEs z^!_w$I8PH~22UGEV^%^egQ@I*$POxhLp;N%+=m24l%?yR@EAHtw#Ilgq zX$`RjC3XEX2ow;4REV^QrY(VZ1o;(WSxjS&L9Bw@gt!Fx0P!ygW|`}soK_TCMhlgK zIF?hX2MOp@IzwD5sf^@xexx!JqOYd%Bg7Yy(E4W=$o>-z`WGUtq4E&oT}vfhAq@U{ zD)}Ln4OA*ZTplV-A%0Vg^-nKQz$CufkS0Ks%`|Nu#IuFUMqX$ul>-plZ&WTpyxXX} zfGFEd3AUd(7KMH{i8o&u;@C;0Iz$(wHALP;V+KKdf~XMf4;r%sV)v#BZ~r%*mPU{h z5bs_i$hex_fGGP?(-8BB7dk@aEyQt@N<qp9@gX?duOgV+T57NQHX1Y*fYvwnuy^Hcew2+se$0+dejLItV# zA&x>+ob zR))$ZF6F44gjk%FC_M#Pt5L~O4AZk7m68yjAax7s39iHG3iQRzY1c3$m?jG0z5{Lsu0_HBPO)|X$SI$$awu{IK;kz7W$sY2(kte z_?5=&f_U~(Im}~HWq7Z|v3%>5{h=7A)T95%p!pBdv@=MvAEI&-;yrB2=n>s}@qyKk znZn28IbvKsDq$s&b;^{{=I;2{l;HZu!h_D5#0wRM1O!Qd=;vrm6Nqx2N;@tWOc@^R zAU+Ir(G+ZIaBZPqGDYI;_e7fgawqe+PI2+{&#xk+PsK^#<^(pZrF77dyT@!h5} zkH_3K#8_;tf=Ksh%x@5@Ab&v=LH^-&1aaQt^nez64UryE`LZ;|Ly&wB>th;I3Ze*7 z1L6{-CB*WCX7zG{bb-Es$N?HO3*r@IB}92jW41y3f*gT3p3#`g5a~IUr=_v}(F96Y z23z)m24#mRf)s*ig2)j6OPXba*j`g<0ny)3=~f2k|G-;HLlES7XNa+lNnQye74(V*H8mmnQ@T45S9 z8Dc3%Wg)Lqfy!oxUXjXSh+MfGUH@DI*%D~bTZocKC0luPNRVm}TNN798sZRS5SLms zMuqsAK+@JfOF^!tH0U72+l9$ zRHi}#f-K`%I*r)|(TSk_D@H0TvXTTLZPBF5tznsT_q^{-JUS;y6R)u@hvwOewr7hFXv)h~)~6DFJZ_QWN42iLoYV z1F>H-vJ4r_V{TAUt783Qy-iCq9wf+mh<=C0?1%X7QaKH=-=lH|5)kAqmq#=vvKn9i zJf&2i8n*r!m9h}Wb1DrX0YN%I{4Z$CaER}vA;#8E=P|FT=n$v>Gfmsf)1>m`N%$d% z5=O-jv4tCAlzz!$(oxA=9g>-5Ss`9QDnexES2U;@Ps>8355$p`iW4Gbqp|>^Wv8;4 z*U3rc2*eUa2S5K9>*ESD@a+0U!yTe5M>UP9uRMu@b)Kw zJacK#e26xWiU;DDPvr>2zJSUNh;0#-4-k1Vm0Wc((nQdH8IZPw1~r7(mr=1pWSz=4 z5X(v`b0L9MR5tLK)l?2ZY(EikN|!9cLSB$5dCK=9eK6g2+ygvYVzg zfyjSQ=?&2ZaY0;rXv|_rK#&xO&r4(ehS>H}d0gL#?bt^tQv+k=8sb;1Mv!y1aX|8 zF+Cwp{UoJvApI1TSrE(LRCI_-knIrZG>!4`n6p&wa=A!FN`g4AQi=w7ZcvdS{yS8X zAl8Re>=1i^%2+PXsb~<#D=KRt{&!AFUXb#c%6W(cIXE3aq3-e?zQms62q! zH&98}1jG0Xl>%J0P^k>@{6?h(#JYn^>iVZ2Nc)2ZO@RcCP+<_?Q7RiDo?}!F@;c|J z_#uv)RNg`SPl95ue{wd(FutcjWgw0(Dw3&}1krO)=>hQ-q%r{_m7+2q;z^+5f!OOB z5?cQp0a+CqbQ7Wp@(Cifq%qOW&_zLHi1%w6lLWD}rDBI@9YSKPf5!5lE;LAkC_SmH z?0rUcu!f-Fvx`1&Ui;+sO{YlxmqWeCKjQu!am z?xwO5640pZDkIwDqY3c?9vLP|45&T|7ypAVj%MB@v>1q|y@N%UOxcp#hLU zOq!tmWRSIZ8sSS;A-2j?euLQSQaR40Ar(JFN}}={q6-qKV0SbnF-|ECB)1|YRpUYJ zsC*5vccC&6V(CdG8RG3nWiiAxgvwTkG=hrrC=VJ#=?26xk;;3BJ()_*mS}!Hm3WAa zQK=4bETGZ`;$Kf?h!f=6O=%j$>Z77VY}cv$4za(W@;5~JqB7aj4|rByD(PBbq)SsN z(2B2rY?LY^NNYu<1w`sir6)ueWDLaChsJ1J22fcCQHD_2*9zx<-v~+YbrBn&zcuJ)OM2kou`?WvB6=jIA7#|PuMX~m$k}Eo;X!^)SJQB!5 zlTrhaT#rg`h_wL~6=G>jWfeqfPGvttZ$;$>#MX{VL_2JK zrvzg;XY7_ZkjqYk>OvetsPu%`Cr}v=Q6^FO9%6G**#MEJP}vW$stLw&&S?H3$nT~> z&msCWDw*4(^h_#6AbyQXO^E9UD(xWFMN}LR$1(_C&Kb@B59D1*gH}PLRaACEY=WGD zD1tnJ*agYZ0h=L648-~)uZ-oK(R^i)w3;@iKx9D%@68EXC!C}2=X(s#sRwvMJ1fY>)sNq}gAw1P+*Y0O}VSCDBC%g;tkS!3&0f;=HI zWH-dWi55Bmv9YbEljHEW^=I)T+&7DTIE|Yz z=d|pm4}8%Xo3e*W9*FILA;#v)kiZctjUle1RC+?J$Eb{h=z`3E_>zv(pyeRDkIHt4 z;}n&@xLh#Byh#IY7j+)@3u(%n{D;OKoKJ38?6+W;6nb{~3W>IhJkgYxF4&b96O6ln z#N!t$8-F1=PWE0k${Txv-_t}2m|`}FJfl+B>O4%dPm5+TXOc6qz=h-cad;7|T0T%vMk$)JjD*c`EKM6nzPQhaX_wFY&tud`w_r ze@%(W%{%zXOy%W+4Sr(jF5|`}N?0OF@Tb^jQQRT#GQZu(S>tOreUm1C$qrvmUV-}w z47`%e?^1m43g)Q&tT9KIT*V*Qk34JKj3A>Q_Z9G1a1R4~eRKM_uGkl>r9U~YlOwm$ zj4?+#;Q^N*;~;uH8uLBGQlH9Jh(C$SK?v@i<`4eafBI|KwKLf;{0M(>HhA~2`PXqj z3I`i}9k+UMu)nUO+tNAXZXV-qpxc&nMz?R@K)1b36LFh|DKRM}Zzg98HnJm?f)Gy+DiwJQTXze0i;&n;{0R3pWmRwE<`ePfn5_!# z1a;^(cATGOyMrC)*p_JAcV+3Fj+XZx`YrvQ$inI; z$29GZA^e>-TMA;^LB$48_)Wv( z*sO;brobb1<{`gn%_H{iA?^@jyP=TAG>`cV=XcRj(wkz= zY<$7rg2$+$TnOEe<_S)(z1YwvxVwpx{lC$M;A9Zi+rnInUD2#T0Jla_L&;|X*kcP= z!Kc_nZ!DYn6y3y6&r{sP!^3Jl<9xyR_KTCxaIYJ!LKWjC9@(E`%QaT*Ikx=V1>ugm~&3+nILbP&|y0jF1`s~yFR}`7j;(YEsng-Y{gsL|6~^{_YQX=vATj=n}^j5 zS2N~xxXi)jJ7-8wTt{8Z^N#OW7yB1KaS?m{4z2kwhVIZh^*y?fk)3=Gv?m+=FTN9r zda~JnUg|tVnnvXr#LALC;C$s_MLwcq_{vrM2+w(me2uX66Xv32erS(O|CH>=>77se z$aVuI%vOf0?ZbU9*oSa6wutAo5n-HhcOXKtRt+8^h8%&|SltNqECwoH zI(1;UbeU=OaDUMC>C{2tuFJ-ZtC}7i(OI|jD*wif=SLMAmTGky#0|25&pcgJqageo(6UOr~!UmDvWQpIg`EY(=p zeB21|+eozuPTyxEQC;U1aa*9wYT&Z$<4w6`+Ha0(lC z-j#>l&55~o0FnHwna1Wqk9=%zE=>ABD`V`P#Rg#Jwl@34#~~4-3(^4M>qKMPK$Ol@ zdh5N7;u%S$J6jW_7UPQnUz9o^{M=RJTGll;_LZ`+TJY4%4(3*)a4ox> z8wb%?KMO3uwhW3!gnv^g;@@aBDjeTZ_b?hoT%nM0c@SdV9GYX-^QiGS4Myh0I8OH) z-+H$vui7wN$1nVL;wAE7a!D!GjC&f&Y(zd4&k7FE-ew=jr~kTqDxL$ei2SIu(Qn)v ze_MVGZASJvKZaI26Kb+g0X06S_bjb21{H88s+9%s=aW|UX92ZRf*w|#Ov2;5iA+?k zKrGQz9tXQoE=G+@uqV?8q6T3Fp;9Rfv2LOg{9+LHZ48b~jqQ!W#7$zQ3u0vZT{o`% zy9%n4a6DDBs+Drc2{lOHwxF2KlC7AKI$L8^w}!i}Gk;gyP0LwGjSF9J-S{GcgN67} z`gINC*v=HI#%IQFp=0}b=w9`0V=*x=T{oui?O2T73syD`qvvQFOf;@+IlOIY2kxN* zGW$6WeYdk4h{oYxvM@ij-Z1VIx}z|v2Kuu2A}a2{*OzrIqJ9@H-!PV>mZCUnY&VQ1 zC-7eagV@2MJaQ2GP!y5vLy?<`;lX}4m_IM(Mc#P);vLL-#Um0w7sVrTY$&p6aXdIZ z6uG@PHrzMF*zgR~2ICSpjD?p#nr{e8EP=EIp?=;kfwV(6i~(<35^2_PHQ1?=_`cu8 zCDmN`N(N)IjZ4XGRI;=EB{A++cBdpxGX5K(>-gwW!Fji*6y{<;WlCwaVq`!y2YUm{ zb`jshMqd8g2ayUaKmO(;cHn|LTyv`n#!AV1(X2wUcmVZpi%Nmx&gVl}rGi4Fq zl*h-hIx-)LnQW%4R?O_3X=b$v`$5Oe>2Atsr5Dc{h!Z@1gihN2a;RWs#mi%_Sy{L8 zI9sbm?d%os$UG7{sRBmAKHC_;-1COutTWpf2;&UB0iv+;75ITUhdyv056CQQMI4xN zO8<&#-7rj$pDSTz{CLy&KIZC`(f8XEDQsyK>_Y99F;$hSxQ^+!Sed1$zOX8`BXF8!sD@>Sa+cQo6BYdDsr&=6 zvu4%!66iF4fM2RsMFnpkIIkM^&`sXuhT(5+8Mm7oR2@U1KMc*;TfE*wcA>f&o5S^p z*3B}UpZc=az|gy1&<9TX_}!xGMaY0yLSDlpLX--R2 z8HExps5F8o3Y88JYf86zyuODOXvnV;p^CnS*sa^|7&9_D3A0~j-ILTmaU>RNgjpc7 z?;9b!)Lr8~jSU(jLSeHT^Xv6tW4lsbHCDASL{4jp?ZA`srs~!lj@PsU#mAvbDL*t* zBQk~u4zopVa80z|Wf#ihWES5RC10>%ZTU*2Xf5OV`k}2FRm5JbR&d~r17OP(Y-l`{ z!w{V%w8Ov$iZWL_6wP_hxPNe#_LxJSnzf7*{^<5 zK=kHR7C`JRsPJo-)`7|f9@CM^F33t2*+I>QRa1cu7$gtt-2sDZW2ZXckoB|f9WkEv z;k9r><|#2zKj1hWVHPlNrEgEU+EINShDmw0Gb&hF!7e!YDy(i7bz*|D#SG`O>MFj2 z!n2dgbBO;BD*WlPobtMh+A|!xtdm_Gm|nv9Ap=|fbV_bxX?x$!uL$?C@=LqxW83cP zx$wYVCilRl13$g^i7vJ1iNm4Z1LHb&r6*3A`c-4>Gi*{Z&{tF9d#QE8a%g_q2j=D{ zn~A;EiI{Egd!t0>2gdH3(FaXWN4?P3RT|&j1dMRJsAarl)2*+%JA%*Vf$E=`p`r6i z?SjUal4Tf#S+$n67=-aXz^>v)xHkuL3|1%L0{v*P8kg0Z!xqYkiIk-LtoAA_n=1{$ zZuyt3z>n}Z4~+AXJXGzN!ym(=&2{;d|M64W(xI4n{up+9C`QLt`nUaRpP@qtV#B=tsu7PalKf*LsCozBvYKOpSdt77-&KF)O}mj_nUk_Y=7WR+F zY?2>V#kg#xk^u4lYKqw{R0vJ1>{*#@n;OlwC!_vG7N)8z(99}T#TSb1G}CzLohalw zWQtixXAe|$E56@qxf_!y`bp@kpE6CwvnvlPI~8T53uY28^9W@ES4=U>c-WY!*aNMf zkXJ)WOvA`XSB;U${l$04yJqI`O4%U_b5FxqNo?ITq)&emd1j-Eh?ap$VJ=^oVh#tsGy7Z2 z<~MA^w-}Wr0pk^(t~0SFvt~4d`L=gLy8I=TfsjC?DQN{S&qSpk1ICT-wORbQ3>fF9 zbF*-CcrE`;@mg5>?{IYZLphmdW7^zgWoPqCO}5&`S0gW;jl&=iFrJK;(D>n!J@`joUKkJT)(48V<=10p{1#1`$$DBMj4{$sBBIX1oAmF0U`lQIm2wa{aeM_$tG> z*oNq*#x~rYi~i(i*XH4jB!7>VmFU{Rvt{u!7y?JMna+pl3B;Q!=AdAO`aQZ|>Z$S7 z3Z>?upp~^mLHrms54~#2%MT3q#jxf-sIig07;}?avTQf;G-TcnSblcqUB{D6l;L+* z*5+e|%Z1G5&BpNc4)f7_*HdF(dKem;ZuI^Q{vTnDt&Q(!oE+oS(D_(1n|FRLL@z>R zImBL+$}bR?AV+viF&c9R;)$p79%3m$C2~$Kj8rO_oyYeFF2HasU^NzEOI_tyU=2q7 zIDWy+r?V}_|2r?j_Bhz&MHoB>TfGR6)Z>p}u2eF1OYX{ZP`a|wTH0&Lc$sH0YAVl+ zi$u&4jD^W%Yh~5|xJyrPlv`1Z^AVVP@wseUa7l~4#S-774 zk{(~OcXJ8OrM+0`r8rkR>W3zwgYCxexZVf1rRg%vKe?gVQ{KjWRFv47W!O5I9W{PD zS%xdkugtj|8@cOQ=-KQ2dG0Ho+s3SB4ymsto1kOybCVZ{V`Wz0hqx|w43!NtB^jUsjw;a^;m_a`*t?P>HOGyW6WEsZ3m+{1IwX+L3A>S8DH zBf`?l2uqLuNMUSpH++AtvJFp?x~@@^*a=i(N7kU6Efkj-{|S}L7J5UX@>(o5riX^? z;93OR`vr^QJKon}SL15^6NY`+I{sYIc%%@^vQEv!a;{fvPJ6=q4YO4 zKK&7Fs?5IFfO(*>k{hsnp6AArbH@h6S%=^t?yknLxQ!S_E32{*hy10`Fh1PKM*tE0 zolYkItX2*84q=0S#yR$GsG~8Pct?kaI@))WIy*voA+cen@$zoIU(~n=%c#%*;yp|9?=xPA7IefwkV`>L}RPi@8DyMgf z(Z#eAhIbAZCe!o6+Su#Lt5jZHz0A34EY zu`5N5DjHDDhWM23Fb|_M)f97d{K@Q13Yzx5AWNb3+p$)8@xoX_M*WV$t{FyQ=QLE& zzBQ^CPa9W5YByv1nAvL41PL>B?yi4f+})FQw8OqO7Gd zhG%W1G6Q1UV@TS5aIu6Pm=MxSwk#6I_rV?5a+^18Hw+B^#`mOi2QTS03-Iwh4RP(I z@(d#FqmpSpniV7tV%<+;nm}|xy78C;W=wF;r9*>w;=BvJUGUO)rDEeQ%xvvIXr|@d zji*mR{13BLFp?&)n?I;(_6uwPa7+StaB^Kfkqyoe%NPV7l ziDtEhxGq!a57GQoM&k`5$$O2`G>GRWm4y)fmMP{W_MT_j9(4fDU+?$e__W+M2ElnA z(eiCGns3kth+UA_1=t`#>O(X^`ayI-ra+WCwDJ;2K#(m_JngO-WOmlV^6kYg`0y(D z;ca`qr=TEBExsz%-|h<3eg@=iCl;|^pHwLh&NTtc08=xKAa=#u_ya*j+7r6 zO|ic^I(&C z*zf~tUR;1@9liS0jtCuxosW-Y#v7kLj-#jNgPk$+;KUc6@ZNqF~S@t>&adtqz_ z3qOc=ZG11yDrOGe_pNzQ9T1WEO=$6Q?4UX+!uBR~3=jPa1uMQWo_Bxx3q#Kz;s8)9h_i8xA&L$pGD`iGhXhTb;XO?ihPd)n-&h#gaV1?L}6+DcpYv1q_Xe`@w z7*!n~YX{#ah(`(iqfyj2TONW01i1;plcOUT75``2e!;~!Xrwx5n186y+(HMNb_C5` zdK3I!(x{`jEahk2j$+zNVReF=lD-WR753yPDtf;#^Z6F7zytnFrkEA+p6M}Ew7xao z_&#_HC3TkdI7)hQ)M0aO;~KOazlE=TYb>71oWOZe&WVR`8A^};NMS!*HrF$*^J)>c z=LFtq`t>dI{e+LaWH_m6jdUIr+z{Roe3>NvE`UmQh?I*;35b>|W@mMF^(1EXb~e<9 z>EL}E+|9Ag4Nmko47<)^+G4@!k zEI)(Mz>Du^vHcdg4r`fpTC6cS|2T^lIq~UTEwB_bQ8ruR`ykyi%*1k3q9NW2rkI0d zVcpMRL$<#&UhWQ@Ls@I(PzS86%XvI_>7DU@@5A$W(35~}>~qIBQO;AempPxm;KML zzK>9TPCF@o$+lcmdjyF;OKY|Q`N}V5J|E#7WV?Z<*4kF%?4Q#5hT4n2r}F!4gjhZsuaYF)!AD3e?5{g&heX#dvmWoo{56=Q zf~UE^x8LVaoIV>Lu}WEcU%ed`?%l_L2sv{lz-0yMjf@HS@RN6|Vhy zO#e%?L~n@iGL>&2@--^cxv(`)@al($9etuU%#89lruiH4dowd%PP|v)e~gQ|EuhxK z=Q^DM^uT|o&JV+;#8gAB<*rf9xWHxHfIbKk1ySzPn9@AvA#3my@7_y~=_B2FEF1q6 zZ?HRF8V?vp84EtJ`KkK8vHb&mpvOk^{v(x%5KWMo5XWa4vmD}=*sEu1Y))HD-QXE4 z?PBAj*Gfnx~}n>2mTWpo)N5UV|QNG;<*|(|1CzS-zHby zhy%zf7m2KGFZfabS;5yMVqU6M8(GR2Z5d-F|BPP9X6t;~)q&W`QE3H{Dw<+Wbq`zd z5_{nsnhHx)3o-c>Uy_6cf6FsRPRHZ{ZhSZDD|MjLHr#B|(S5{-Zaw<`HGT_N_n|rBK|Is#8i~4RK_2`P9>CB4!7pfrx7Vv zxk6$^-*h4s$|qD#lx7mCT&Yrp${OqT25(~8*za%fB3?g?_prT_gX0~1FM7~hEJ}1X z=Ph=PO|KhVcEi==bEoS^EY3@f3Ud+L}=@b9Ou5R820sMgBUaEB*e9W%4LYWk;)?; zlPdTQfZ>Bj;5GT5Y0PWHST<1!`xW!mV+ykR5065gl1jXJ3xcrH4|D&C^KX%G_dt9A zaSnb&*nh3d_MV#>!wN*WbK!Y$g$Q@0oSyAQIpYw?`5Vr$JK2N?cWe&roY|0h7}(k7 z2-KMn5ys~Hjw8;N&Yct?-7=0i=V;_=cWAX_i1nUXh4*a*#Q%`WA)fVy%1wyl9hDCd z*Lx}jw&BF}fl7@ikSBA!|D0PSRwKO|Pq-qOza5^Z97~TL`?A&xo+EOPLyF&GrttpF zgjiUU3~qdyKPz)&aDRs}{G7qvFv1pXBxTr!kU$wnYI3=SirC@b+j5gB*;yuRlf9Y~bb-S>Qekk91GKn=sBu%mDcV zjhps6E@7Y8p-60&gMEy2V-m8>nbE_{tiV_3p**`js~wM*=huDZ&Xq%%Q$IN3Mi&R| zz&uYm^_6==IL2+F#r+yt|h< zjTc%-WfR1vQ~4VbSViSImo-%K?nm>RoRn&Ud|RpXfLOLunF&#LP}$0}_EGWktiPzd z<1vS+L><7SKHh*nvn&g;oTNdGxtyZX6C(XhWfDaGhYExE1=#}8|D`b}A=;$|^v*mF zLG~LoDC?hS><*Rk5ak|~HW2FrDw80Ahg6pGm={!bL8SK(r(`~_z6SDsqCpV{F=*ip zB_xObETkmF^CcAp;>|*36hz8FMTgjOQ8~o33UDcHmVU+4VvV4*H4ILZ2;xr@e$I(t zcC9}?E4MV8yD*zr(w(1W-8&^C>k^Gil^)+P_!p?oztHD++E#gpT%1a6h+mL45L*cv z(+}biWIWFj)P`L?l+Urqz3knF5^)U8l z0~%A5OG7F(A#x)sEg^nEdO@_tG-eFM=4?XgTac?MmE{meGb+DAbV2@tc$?Fhix9g) z~3_oMOwA`hjK^C;?!q9Q~5;~UcRSu>Dj3JvN9k)~5ghG;XX zEP*JqsH8xAf}DalG#c{=BF}}SozKFLp^uy-^AwW@B7ILK9^w_GIz*mFV_HBwg7kp+ z1sMgg{J^tP?=&_YWDAnn{BmAsJ}vzlFT|+$AdZDp?nAtbsH8iN@mNg73b8K@ig~B8 z1dzO(1}PBlN-EuX%uiItK(w_~W*dVsQXjUtT*GHu{#Pv_A z@bVh%FtJEf6U^5vOzvq-7)|-Gx{qseFPcf<&Fdmk?2szIz@QE36u1#$KS`2-pRk+RUVZy~ZEt9YTTG-d~{W1(^eV$V+HDa4b5N@nNZ z*dIA56^AHMRBA)4(NsD?Jo%^$<}n4Ss1R2nDvKb#I4YjMvHp>YP&$YpxhR!O5PLBy zPa#@KDqsAAtWs2BAWCT}l_B0TR9gJQ*FWVb_2g;gsf>a61^E`@s6beTWLFvg<3PAA3>Et9+5#kl38N}|UF@3m9rQ+mS z)061>XF13Dei8F7i7B^cgGdczi1RZ z(2e)|4k1&{MCBH*&ekCm8OMv`CEWaY8>Dt?ylC6Gg!>#m=hKM4Ct8Tv)4MaV9wps9 zOp0Z{lycix*-N-HN4ZjNeBK(N!B4y$y@Ua)Wwv6zt6*W@mO}ZlC|_te3g#{C=5OoN zD(#MQdYT#05t8|JnBG+3WBC>peS$<>#yAO*3!-!}>);zTyY+MQ9;6I0h1ZEijO`mL zRUqC*Zc0r-zQt6!b6HJgFvPWm%2-HX4=Yi|9gC4{R>qCHGn}CTs}bP!Q`rvD;~SF` z@!t^q=|mZKC8xbNeIUyfB+sN$2;x~}h_Q3a@tDO_8ba(ZX;vGE6xM_^IRN7S!Vsg* zD2StQBqfbgJe6M{Hs&nrZkV7c^np)!K>3=Aa z1kyp?{%l4$cY`7pCk=kdgHy%aFc*7S&OJN5936(g@U4B-75WR`wdL^^h+}qeGYdG& z_^}`6(B3tM$aAR-hS||v=krJC49}MW2fbT}Oq$DTcUadL&N&hY7Vh<8|c;3)kdE=_!{i^NwE!!CM zCR5emxv6Yb9K}itGna4QuQxDC3YC8#)>JVEOlSYA>Yg3(FDh;>Iwg_yySwu^*z1o#Jwo%3X+llFEl$P0*uDlyclgke^C1i0?6# znh?uVDy<+AdtM9k$I5csaOKoWHVYnE#+Yuv<6c3$kboekA=Xkf>pnyg@e5KFVkt{2w}9BnHlxqIdVw55&^HiGknbQKK~_Qhf^3IaWZKwqh)s~| z5C_DG;SIe}^%|rLL7DGi4+#p=n)sMsO4%2WnIbU`LU{9LT5%`=cSfu?PN zxY+4B_$Y#ZJ$qNjJs|zB`S?Zg@*a2SqBy;-I|;WYI#m~^3QJ-${@FLyrJlPAK8wKW zVQC@Pqy@X)M_&aQ4v}qU%<$0_Ds~%;?;vNn>f;EJSe5$jhKYJp^KpLuK93AvGb#^x zjTTfsLA-s~_WJGy;ocGR8{q0{%=J8%YDb6J2b~9WAr@DgMBSt7&+d&W)9yC6(F{J zrkGW5N2=z0tgK<|=_^+uHlaoEdby&7JFc-5V?-M#y4uKBtW*?;r4W^Fyw#8x8#NT- zi)C39cWe<~3A1(HpYQRAwY({5{b{3M7bdd3_z@wOH#Wz)4Z&I{*yzq*5L*S>_<4vf z$bE>V290^cr52U10_a9i`$@S4f*(BVIfwcEheYD&e)r5Zd-R%^zL|Dgd9Rha2eLQ9YSv6 zx8QQ{5PriUnyo#SgW5);ys_gWpP|8@sT6=nzfdUyv9p2gF$fA<(H~gU{=S*xfe%(N=xlg;v+?T@iF7DVEZTo*)MTyW}Dji|mdj+-ljeu%*#VJPGnbtsU_N2n(jO=As z>_zVU1XlbihDF&)2kJE+I^Tbrky!U`7_(nv=YN4A3v@#d9X{jql{@}94)N>%&2X?L zc5Lt^Y{!c0*xwiI$g$lB?eCcG?kIecuTppH4~Y%zjuG|T{ci~y{xlsWq_|KCxd+B9 za1YJmFV>5{KtJ!(o<~D;K}tjX57@pQ?gp4#U-smm$9u-g^uz})1Mg|77lB$z&z|m4 z;poo!-Z-D*_7}ae#esWlKp*#j$ildkWxzQq0{1^C)DR2oH+^vEWGoz-oYVVa&~ej= zzV59Ng@LEMm`iK>VUw-RTNr2grf>LR__QBR=GN9N$XR{?9#GnuVjeH}Tm1g+fst}y zv)v^|yNCLtrDH7H0E~>qZq#=Ei4sz8vjjhvUVzvKP&W5FWep&(fgr5QiYMc%kz&W(7pLKqUoY zyF}$A#4pHgh~+trdH22;8j}<<-Lri_hccLA4y>ImABwBI#v&cq-M&c0cmZL!!(G*B z$z?A(DhLy(mo6bR0bgyF`5XM5gB4|hfAg~F8!1gQk^eM7Ta@^78-PoUHn;&4()hDcMWEP{BaQ%Qj+v#Feb*ymAs zz+)Ct$q<$cw1`rnuy7n9xyIv_7l%$CXom-EtEdcs_^(d8Sh<1WX8Hjv|N?nNU29@>@>m6Yq3<3Gx z(x7A>6wxwx@->dE1rRwSl}!*WH zxExd(L;R^?o(B}x&56@~V(H*2`>_+}_khEwI-n;q^pUj2C@$YnnFf(uRF*&-)2VFb zF*8juTShaXYrxWcsn-D9N(oySJj+=pqc7Ubmd48-M^Hm%{U_sU=9_Pp3a)JMfQy-8 z7T4J3$r!cmtiTkEn!KQ;@p239BF=x0E)#m8p?Wf2Xu$mllJR7~xB9%Y~(V` zaoQcnimBKg0Ulh?X-kiZzs5)~rg=MvXC0Lx5N!h$H^kwgvIL@Rp|TYs|4QWu#J7#g zH77{lN$Cy5wVR4113I*yN<74Wm`VafIYA`}Vi%+X#36_y117A-2D~aS1XH;uB;o#QsP)WA5bim=-z-aXg`N1L6_n4J05)<}a~j0h(0^ z;t-@V#0PPvoiSU1^rtkfAH?>IiW_2mPGtqp5@bI_enDf-K{P>LK%|$5ai(4`qB5b6 zoKhto;uE9>#P*8Dw1RjA=?AgDrZG;4F39%~=?#xb{hZJyUMNWB1#CYr^p+O73X$JY zc?an*(U_AE zEhK0b|L#GopN$x&L76gRJ3?egVTfO9MRrF;h&7B#eTXJVJBUw^{t!8wW{rc`O))+v zG=mp1DcHwF5U(H`AeIPP=y!-ikn<3~AOVP!o@RaV73zFpO0fMXPG6eD+pi4qWTMgz z;>b#6G(@pbnGcb2P}vR9b5gklvFAw@-hN~j?AN@h1St;*wVU5}6a5 z;cQI{l>q7OsMLgb1Zf44+S8c65Q`uaAa+4kL3~|k)?tXp?xb{+7wS&sGej07FP?sD zf>eU|1yLXYK?Xu>J!s{rJgY}5`iyY}$kmeu?Sfc)Q8^3o3i1qM>rG?6ib9Ma@eo@d z8dI0YK*;*1E6CE9291L_1ep)f1la-!2yz0V^rLm|L+pZN$c^T?q^*BqLH7PMttLbo zK&2zZBgkl;HIT;4h4=;8#A620m?JzUD5>k8+dOD64GND&V}j&|NJD5$Wr!k(0?`B+ z0Pzc=LaalBb!R(FI9__ylPQ zkw(%E4S?7LNrt!tSpv~gCD{INAYUr+=1)K@qiE?n5St)UK9m+D55yx#c}PHzCJ=da zYGvMjFOVaRAWn!^kVO#7nA9}H{0313@j-M!9zX(uWXO-r7@JlH?H2-Rge0jtBp^sT zp7u>z8g42F(FK{svjkZSQO41%{XC0`Q@R3@#?zp;5W65b3t&71DFg8dk_3?^&^kRJ zHbEvp9D+FKgFFIxAbvrPK&%sK>6;L{AfF(*Aki_XEJ%4sK#-Zz zt4hUN5bK|SKsOK+m`Q^otk{dQs1$|x1*rpZd`DxtL!{YMk|7?A%1Ve+noDUf$ScSV zi1s~=$xsL#T0o^JL=&VDL|#Z^dP97IBtsPEA{z7~$iJA%K8R&06+bT|NLVcP>oOV> z$K@v~bszyjdO@@`!k%`5tZQl7Qiw;8KOpw?H0BbI*+AtT#Icb|zPNDwX)=`>5dUUj z{nHsFZ=pexAU;7BLL6IZ%uX)bsa$|~1^EE6{Xt{$6~@*>$oi)S$i9aL*&)`wRGbjM zAS)o=eKh6(#C3qm4T$YeDjy*lm$day?jqP{LQpw~SCA$UpCG*<0YRJ)+d^x=BuGApOOVPC+aX$~B}5Tq5X51Kx&E03@(V#LA<|)5 zXg4n;$T^5dkmo$>2+hh;44oDv9^wf}X#GUD#7+WASIP} z^GA6hL2g6*f`k=Ep%b)peuySW0>m#!D~Ro6Y8G#QAWusphzijKSqkwAvJK)B5UM(AO|51LHwnhXkMUqywF)% zC}(MmhahDj4ndM2K0$i$taG%^1c*zJ`K7V`v7M(u9t0_Z9ELaqxxotw@)6<_BzGC? zvJ13wIfzS;CJ?7zpx!*~B29BbG(i?Z{DN$S*e=nm;}E+bcOVWy!pfquQ=t4Hk01#U z>t$NH6~rdUAc$R%sSt-CIz$s>C&Y7ESpS>>S+CH>o^Tga6AJSKJh(;q?FW16Nx0#B)|hghFcIRJ49as}cS)^{}K0z?T(X#MjN(Iz$(w zI>eGIEe$s^fVc!13h@gv9il|htQ8P16{oZVB?LT{ZHP}0sVde#wvsd`Z&freNPUQ0j>dF_*aaC2(FFMs z;!U7ge?S6)oU4lUkCI4(p7At6GFLsYZh~ zfLwz72?+>t6=JVWv)=t*S$6{7M78z-e3BHXQXt4GB8CDgUc?|(Rxy>O6cDD+ma-HA z7R9m!WK#-Bg-lo~1Y0?vAVIl;T$G4h$E&ERh_V|Lp$JG=6cCgkh%8mV|H&luef@kM zA3DGJzh`F7tl4HDVI~c_V)BpCOghBhoysss$jxXvD9Yq5h^GfF`wS9hQUS5`q?sF# z5R>|kVbkkHGi@QxUT#V%NXej52vM2Lg9Mno1#$GIRUbowOu`UbCe8c^ab*sopMTu| zg;=OgH_UY(TGkTcWRf8>eQ9R2%rKb^2{I{#*!vBl*FSH|5UA<`ky(AX9bylMPZO-Mapn28l9R3~{J5vku~CvIAnzqM4(R0Fx-h zI#6bAUH>FG&}lJBeE+90B*>%WYzc0g1nqajfyMG!|ety%{08tw*ry< zSqV``QTYH8WfF$?N5?b9^^fudI`%1A)&!z5NrMEKjDgq-Xq6k{VX^`eX0j9F7?Y@q zP5&gwe~WN!q1=Q-nAGo%vZoVeGV>tB$)pz~$YdnM`V6g_32{}4oc>Z!xQZYfAhxlz zY?~}&augC`^1G~hmR8m2fhs1gA@;(m45r^5q!Ln;d`N)F42UwWsthv?aWeT2B*bJp z#5$f<9hX&9+{$%XMoFpH6U#AymbHOInDm4w6KQ4yL}fAq5@6zoM47nXmSvM@L!U!} zOpZXTE}FRlaWbjZ3yZybo~{(ac^*gvlA1nN2fE znV6wDRBRB1U2SxRxZI2eOY+dNDYBtrDlb98OxDS&7ip#(Vx3Fnn3Q=`euFsYvB}r& zgDszhQXz_$mOTbhnGA*mn7ANOCUa#*qwOq*C_Z-mvl-;{(a;WvZ9bJ#kO-6OkiY_( zsn-|Fx{yj+NQ6lyB)EuO|BMFNN@&>(S;oW=aR zUH{bVhqWl_*7Z*-h`N-@;}HAHRB|BJQYw=mekKcKri^CRLX=me+`9hx3>1w~;`-+R zB(jW_{Q_|cD%GDvhKWtea+>KZWd#*g%BwL+T>lh;T(8m4JczQA%4&#p6_t-5w%4hI zWjm{>{0IpJsN96u*BBDN{%PDF8&RB$>z@Z9);DNbCd9*}01{;~2jYB_R{3Q+YpJY- zxDsMq|9k=pCrDmfDBnOl|E6UZAojPY)EI!tGr1cQT1PYOA^!DLG9l{Q35iXAB*?lU zL2~lbWZ8eHERvabsH~Bhcd6(y6Qr^iqP$1t6eLbwQ7MGjzM$fUDBG!&K_X1vhJ?PP8TY4>zM}N4 zlpR#gLc%+#{0WKdqH@PTRPCm6A0)7cN;<^3m&!0V$hMEtG)RQWLfO#QG_zVZ6sEF8 zwzHqgPT3BVA0Xl(*9)<)fsANF=hp7yQxW1<{8KNGc zq79Po{~V?CnhYJI5|r`-mF*DcaVpf5x zrjiE?6B~8jDcKy>^(r+|091>yTf`l&9%mRq#3Y9k?j^7PIi}>$Th@Z*#kl@w$^^Xzy z17!PymetQiLpQ0kh4`6dLZVDY%c@FRRRjq#Sq2IG8NdE9Ccg<30m%yxLw3rB{-SaU zV*Q)SpAZ+5#)GjKN;YYyJ;Y_A(jO9%(&N^|o|R>08kz?QGFdGfvLrHz-;=sTtIzOz z(l5kP{9_4q$d3Igwg0yWtDO>IxfaesoJ=fv=msWDAoebas>CEh9YkTsyV$ZmD|T;> z=AvmienROH>E-xwYP9b^;~p`i9J6u(>DY}XJ!d?(i5j1KGtA*9h5ETSwWB@Ts4*@! z3gv8!r1Ap9IpLq}qI$#U^2PuI<9AK!xJ~{JcY?9R&EG&#^#2uMG}eWJTh%NVYvy`K znexQn+i?2@`^4 z(d8N{0#gzdvW@CPu=b`>sSgR=l0>UcQNA60Rf0vjB=0Y#ekp(EJS{u+qhND%nt1g~ zEb&^5j@@*r^;fvXggVn$;%WoYq+d*ixuY|UX&F7b9wWlDsC)p4zDVT&BvL}0F7Fa^Wwx;Q^EQb+ z4)x63YGVH`^iszhY$aJQriwdv<3?3Z{Pq{Wk#-0#{>ii+qf?I#!+v$v5M$TBZ8&!Q zb5tIHC>N-7ml<(MwyKB*dvG7F=i^_Kpzd45-8qPtiV$vS(`*oa$WK?da zXEO1eR<16I6c>DuAgEfq);Fdg-zVmLk zL^|h)tU7qC=a7S#iX4jFx$M`&xIN;phrAu)_aHxn?NE-CcNc3^ipe;-CMF{nelkqa*jC30H>EsIh8}L!wO1Lu|ci<_|ex zCP_}rTqey}Apz0oFmC*9>rY4Y!iewyD%lX5YKXA|je-Q3OoLdnXvPO|F?myFh9)wJ z6=4&*597YYN6`z$ZTh~KNByDL?(@CP#J2Cf`SsM%i6YspwMNM~Z+`?w6Tf)&2v*Sg zJRDvd;wEI*j$j=IMfy=3GM$r*BBR^p$|5FjK~xvb?1m_lsYD=lCVxR(Oqz{GUodG8 ziL_)i5M-N@Sc=4=2StrznEf4?{n%q~mmR~RN2cT$XNSlX5jlplL)wt|$z$RV810!8 z-w!tb;BDx(dFbrEgQhBq5geGJqCA2y{AX={H&qD-0mwkMyIP;xqU`;hlemZ^1RLUXFLsU*eqKBy@KaCyW2$g?9{BA}LkQ$+( zTq!?OnFw)QpyGoBE>n3OV!uk|BS`QXmHo0xapz*|NxULB19DoZn4ZDXCsRpfA4_;chk^rh|-G6DTx0*D#})rqbGHl)rF0BpA4cUGB+8^_AtpbZ zW|~2Q`BXZ|%m^yk5dTOjlM3CKBPXQ=vW&@_kiaOK`2=DcP2~_I!sH^v`V`H`d%UYm zYK$|Bo#(xoZf5}v&Krjnz~nVZfXQY^h{;Y!lt~0)8$(R28lB12eB2>i4{OpCPffW zVG9~60|n!us*{^Ty!It(0ckLsTZ25D$})5OOm0Fv?pJ6-cTB;=n6!pCm(h#^5@s?O;t(`5QMSXx3kfWznUxTAg(&$=-s)d$ z`VD8)6mi#OoDMsVir-Or!)09KDdOwP-WJ3BD{1jn+1x5BDbJzjn505%uhUE?h?9v5 z35X}J;5slEpivDYl(ke=LR@cA*$nY-pz|F8#u0gBh3@sOlR7 zZ6K~+sC0(}n2d!uF4N2$NSH|(#Ce5gHbDGRs=lxg0@;42p@WbhlM4{XRhlu+#Kf31 zhB*JAnYNH9lO7P;HJQ2fg@r;Hic#VV3&jx6b=uH!i1h}QO%Ml@FCk$j#~{v|wCV~Z zYKT34dy<;ZV`7ywlnSx_Nu?7cAogC1y+L~E8V+DRME-Rgz`_Ob1K5S@IMs*$G*0z- zQ)Qdg2a^>#A7ZORWhKPbh)NI=yvLBLs|z%WcI3OM52Om$RlMxqbkqCbvdi8kmZO+@ z)$_0HH}R4JPfU%yi7KYv#9N1oSacI}X&n=P)zPF9a~VQJzKiFMVtS#LbPlS&fcd_c zN>fOvHI+1(X+xzS#M+KZ0VLd>N)g1?kxHo>imCqo~C#W2fRXwR(lvRDG z)R=|IKS|{tNMIn9M`z)JBs7@P09nRlEF{9D7!qajDn!Yn?Ys}MGT8&MG5K*8E=U}V z{zAyfq)`#Nnu#3}VA2O-9YQBxAgh?nfkc@shq#?XY1w8_n8_Z9V;If+Br{C@hD4Y& zo{fnyX$Mh;({}nmtZqh6fox2QAa*9NKvX90LR?I~g7}$4AVDTKAhvuroum45P?k@n zEkqeXr8mUIWHcngqzIypq*cpghRJ4#{i(t97X!ONj;CnZkB}e}6E;};Sej`9aWF}P z1es(()CsgozT9>~+*PNWd7v;0t${eE(6WzYLre}pLQF0}tTSlU?H+VBla>&_l&TX@ zI>0C{4RI04l!Mng>6LBfk@ zLwz6-CIt|+gl38%)}>Tlh1d*9d}D44$j?IiWawpDb`}y~Vtx@@Ln+NPg#?*A3UQRt zj0y?I#(pRyYA0!hmgUdJp3sHo@FZz?-+YfT8lP?5R!zgF0vLPg2tG4jUQKIh z4($=2R?`;u{bP@u2b}rjJBG^rbIpoxFO@7vjeS&JfCwgQAd!8>39rj$45(qcVA~+h z{ZtM>Jl`Z_%9shGTo2pv(bmQ4S_`~-saHd5(IHro7%yk+;d!VyNhK2!JWXW`#3?4! z(8iep`r#Vduq1P2pLjGyE5w6P)}(+x6t!w;ODxv(Jmd4XP%Uk|#WpT>d66ozYHKZG z<63G|ndw6_=VgXT@FQv88k)$3{aq}x^R2Ixk|s66>HM zm;Y2-L>l@Ui=rn`A3?^{QopC6Ho$6Xqffe5d(doAWqad_Q}y!uwFQmMkx3#l*q5qL zOxIp8S?0T9pEAe31Y+HS=Rwx$j`ey)Z`WPhWHQYYCwgcZ<^z*s&xzCf_0-0iEVe1e zgW2_pUfM>pr3izjyYV^i`b@2*X{)|BQ@h7x+4x-i33k@LIE(GTkbIPzUes4xSltrF z;L@)>&GiQcYF$$-l^B$dV%Har&}y43ZKlQtw~o}THp}q%poqHBQVE7)-{u(Z(YD}| z{<_85Aciqj#zT<%ysTAP zJk#SdR#>WiWHHa5E}CBUrs}{oVsbs^ zH?UH(nQ)paU!`?OGOgFIuhF*EHaYcAg4#55&5rXE=lyH3k8t(e_qEQ+CcD1$V=cY9 zd2ETeu|`YPua;}UdKTMalW+&o=C1G12j=;UMi=xv&f=5-#aHa4XZxtyc`~@ z7hlk7$xUU+FSwj3D~o@mcjFiBXY=~9*kUAK)OwiA;WGJ!tyJ9=#S)rQboV7~mC53K zB|iU-%aYgY1FmQ}Cd-Fl`Q;6L$M15RsK8+CDI7PhVwvsB;v5Z8!@h)9@trlmIq<&!J*u3craz({%?LlfhTzXRPc z>8VC@D<4O9S&C$h{HWKJj#!Bi^FM)DnGq}L?kh2wRvH6cd&(|eYox3hNNqI!PU(%m zw-|pXXX5Xz^6#7YlB}HdWql!gjIovS?*p;F^=tiPe;>sx$n8t--{0r7n9}r3S-w{+ zH65=dc46a@hx*tY-*hup$MM0wXH1qoD`VSBsu(xKcg|9Yq1a-~9E#>sMAk6$xNTLu z7hS{ASsfEY)Ip|RI!uqF9* zRD6R2-KM9|c2f+=Cu!>Y3gqhEP~f{=T)XON^1;)-CcP{jWmc|E`fW{Xp&cZ{26I>9Zc4|DYM)!F;>p{55z<;p^9FKK@^T{}z>%