//CVG_LicenseBegin==============================================================
//
// Copyright@ GET 2005 (Groupe des Ecoles de Telecom)
// http://www.get-telecom.fr/
//
// This software is a GPU accelerated library for computer-vision. It
// supports an OPENCV-like extensible interface for easily porting OPENCV
// applications.
//
// Contacts:
// GpuCV core team: gpucv@picoforge.int-evry.fr
// GpuCV developers newsgroup: gpucv-developers@picoforge.int-evry.fr
//
// Project's Home Page:
// https://picoforge.int-evry.fr/cgi-bin/twiki/view/Gpucv/Web/WebHome
//
// This software is governed by the CeCILL license under French law and
// abiding by the rules of distribution of free software. You can use,
// modify and/ or redistribute the software under the terms of the CeCILL
// license as circulated by CEA, CNRS and INRIA at the following URL
// "http://www.cecill.info".
//
//================================================================CVG_LicenseEnd
#include <GPUCV/toolscvg.h>
#include <GPUCVCore/fps.h>
#include <GPUCVCore/tools.h>
#include <GPUCV/cvgArr.h>
#if _GPUCV_DEBUG_MEMORY_LEAK
#include "SugoiTools/debug_new.h"
#endif
//=================================================
void truc()
{
glutSwapBuffers();
}
//=================================================
GLuint GetDepth(const CvArr * arr)
{
SG_Assert(arr, "Array empty");
if(CV_IS_IMAGE_HDR(arr))
return ((IplImage*)arr)->depth;
else if (CV_IS_MAT(arr))
//SG_Assert(0, "Depth format for Matrix not manage yet");
return ((CvMat*)arr)->type;
else
SG_Assert(0, "GetDepth()Unknown type");
return 0;
}
//=================================================
GLuint GetWidth(const CvArr * arr)
{
SG_Assert(arr, "Array empty");
if(CV_IS_IMAGE_HDR(arr))
return cvGetSize(arr).width;
else if (CV_IS_MAT(arr))
//SG_Assert(0, "Depth format for Matrix not manage yet");
return ((CvMat*)arr)->width;
return 0;
}
//=================================================
GLuint GetHeight(const CvArr * arr)
{
SG_Assert(arr, "Array empty");
if(CV_IS_IMAGE_HDR(arr))
return cvGetSize(arr).height;
else if (CV_IS_MAT(arr))
//SG_Assert(0, "Depth format for Matrix not manage yet");
return ((CvMat*)arr)->height;
return 0;
}
//=================================================
GLuint GetnChannels(const CvArr * arr)
{
SG_Assert(arr, "Array empty");
if(CV_IS_IMAGE_HDR(arr))
return ((IplImage*)arr)->nChannels;
else if (CV_IS_MAT(arr))
SG_Assert(0, "GetnChannels() for Matrix not manage yet");
else
SG_Assert(0, "GetnChannels()Unknown type");
return 0;
}
//=================================================
const char * GetChannelSeq(const CvArr * arr)
{
SG_Assert(arr, "Array empty");
if(CV_IS_IMAGE_HDR(arr))
return ((IplImage*)arr)->channelSeq;
else if (CV_IS_MAT(arr))
SG_Assert(0, "GetChannelSeq for Matrix not manage yet");
else
SG_Assert(0, "GetChannelSeq()Unknown type");
return NULL;
}
//=================================================
#if _GPUCV_DEVELOP_BETA
void cvgShowFrameBufferImage(const char* name, GLuint width, GLuint height, GLuint Format, GLuint PixelType)
{
//DebugImgData = new unsigned char[3*width*height];
int FormatCV = cvgConvertGLTexFormatToCV(Format);
int TypeCV = cvgConvertGLPixTypeToCV(PixelType);
IplImage* test_debug = cvgCreateImage(cvSize(width, height),TypeCV,FormatCV);
cvgReadPixels(0,0,width, height,Format,PixelType,test_debug->imageData);
// memcpy(test_debug->imageData,DebugImgData,3*width*height*sizeof(unsigned char));
cvNamedWindow(name,1);
cvShowImage(name,test_debug);
cvWaitKey();
cvgReleaseImage(&test_debug);
cvDestroyWindow(name);
//delete DebugImgData;
}
#endif
//=================================================
int cvgConvertGLPixTypeToCV(GLuint PixelType)
{
int PixelFormat;
switch (PixelType)
{
case GL_UNSIGNED_BYTE : PixelFormat = IPL_DEPTH_8U; break;
case GL_BYTE : PixelFormat = IPL_DEPTH_8S; break;
case GL_UNSIGNED_SHORT: PixelFormat = IPL_DEPTH_16U;break;
case GL_SHORT: PixelFormat = IPL_DEPTH_16S;break;
case GL_UNSIGNED_INT : //PixelFormat = IPL_DEPTH_32U;
GPUCV_WARNING("IPL_DEPTH_32U does not exist in OpenCV => converting GL_UNSIGNED_INT into IPL_DEPTH_32S instead of IPL_DEPTH_32U");
case GL_INT : PixelFormat = IPL_DEPTH_32S;break;
case GL_FLOAT : PixelFormat = IPL_DEPTH_32F;break;
case GL_RGBA_FLOAT32_ATI : PixelFormat = IPL_DEPTH_32F;break;
case GL_RGBA_FLOAT16_ATI : PixelFormat = IPL_DEPTH_32F;break;
// case : PixelFormat =IPL_DEPTH_64F ;break;
// case : PixelFormat =IPL_DEPTH_32S ; break;
default : GPUCV_ERROR("Critical : cvgConvertGLPixTypeToCV()=> Unknown pixel type...Using GL_UNSIGNED_INT...");
PixelFormat = GL_INT;
break;
}
return PixelFormat;
}
//=================================================
GLuint cvgConvertCVPixTypeToGL(CvArr * image)
{
return cvgConvertCVPixTypeToGL(GetDepth(image));
}
//=================================================
GLuint cvgConvertCVPixTypeToGL(int format)
{
GLuint PixelFormat;
switch (format)
{
case IPL_DEPTH_8U: PixelFormat = GL_UNSIGNED_BYTE;break;
case IPL_DEPTH_8S: PixelFormat = GL_BYTE;break;
case IPL_DEPTH_16U: PixelFormat = GL_UNSIGNED_SHORT;break;
case IPL_DEPTH_16S: PixelFormat = GL_SHORT;break;
//case IPL_DEPTH_32 U: PixelFormat = GL_UNSIGNED_INT; break;
// GPUCV_WARNING("IPL_DEPTH_32U does not exist in OpenCV => converting GL_UNSIGNED_INT into IPL_DEPTH_32S instead of IPL_DEPTH_32U");
// break;
case IPL_DEPTH_32S: PixelFormat = GL_INT; break;
case IPL_DEPTH_32F: PixelFormat = GL_FLOAT; break;
// case IPL_DEPTH_64F: PixelFormat = GL_UNSIGNED_BYTE;break;
default : GPUCV_ERROR("Critical : cvgConvertCVPixTypeToGL()=> Unknown pixel type...Using GL_UNSIGNED_INT...");
PixelFormat = GL_INT;
break;
}
return PixelFormat;
}
//=================================================
const char * cvgGetStrCVTextureFormat(GLuint format, char * seq/*=NULL*/)
{
string FormatStr;
switch (format)
{
case 1: FormatStr = "CV_nChannels = 1, eq = ...";break;//GL_RED
case 3: if (seq!=NULL)
if ((seq[0] == 'B') && (seq[1] == 'G') && (seq[2] == 'R'))
FormatStr ="CV_nChannels = 3, seq = BGR";
else FormatStr ="CV_nChannels = 3, seq = RGB";
else FormatStr="CV_nChannels = 3, seq = ...";
break;
case 4: if (seq!=NULL)
if ((seq[0] == 'B') && (seq[1] == 'G') && (seq[2] == 'R'))
FormatStr ="CV_nChannels = 4, seq = BGRA";
else FormatStr ="CV_nChannels = 4, seq = RGBA";
else FormatStr="CV_nChannels = 4, seq = ...";
break;
default: FormatStr = "Unknown CV texture format"; break;
}
return FormatStr.data();
}
//=================================================
int cvgConvertGLTexFormatToCV(GLuint format, char * _seq/*=" "*/)
{
//Yann.A 18/11/05 : ?? cvgConvertGLTexFormatToCV should be compatible with channelSeq ??TODO
int FormatCV = 0;
char seq[5];
switch(format)
{
case GL_GREEN: FormatCV = 1; if (seq!=NULL)strcpy(seq,"G");break;
case GL_BLUE: FormatCV = 1; if (seq!=NULL)strcpy(seq,"B");break;
case GL_RED: FormatCV = 1; if (seq!=NULL)strcpy(seq,"R");break;
case GL_LUMINANCE: FormatCV = 1; if (seq!=NULL)strcpy(seq,"R");break;//???is it correct for luminance?
case GL_RGB : FormatCV = 3; if (seq!=NULL)strcpy(seq,"RGB");break;
case GL_BGR : FormatCV = 3; if (seq!=NULL)strcpy(seq,"BGR");break;
case GL_RGBA : FormatCV = 4; if (seq!=NULL)strcpy(seq,"RGBA");break;
case GL_BGRA : FormatCV = 4; if (seq!=NULL)strcpy(seq,"BGRA");break;
default : GPUCV_ERROR("Critical : cvgConvertGLTexFormatToCV()=> Unknown texture format...Using GL_RGBA");
FormatCV = 4;
break;
}
return FormatCV;
}
//=================================================
GLuint cvgConvertCVTexFormatToGL(CvArr * image)
{
return cvgConvertCVTexFormatToGL(GetnChannels(image), GetChannelSeq(image));
}
//=================================================
GLuint cvgConvertCVTexFormatToGL(int format, const char * _seq/*=" "*/)
{
GLuint FormatGL;
switch (format)
{
case 1: FormatGL = GL_LUMINANCE;break;//GL_LUMINANCE;break;//GL_RED
case 3:
#if 1
if (_seq!=NULL)
if ((_seq[0] == 'B') && (_seq[1] == 'G') && (_seq[2] == 'R'))
FormatGL = GL_BGR;
else
FormatGL = GL_RGB;
else
#endif
FormatGL = GL_RGB;
break;
case 4:
#if 1
if (_seq!=NULL)
if ((_seq[0] == 'B') && (_seq[1] == 'G') && (_seq[2] == 'R'))
FormatGL = GL_BGRA;
else
FormatGL = GL_RGBA;
else
#endif
FormatGL = GL_RGBA;
break;
default:
GPUCV_ERROR("Critical : cvgConvertCVTexFormatToGL()=> Unknown texture format...Using GL_RGBA");
FormatGL = GL_RGBA;
break;
}
return FormatGL;
}
//=================================================
GLuint cvgConvertCVInternalTexFormatToGL(CvArr * image)
{
return cvgConvertCVInternalTexFormatToGL(GetDepth(image), GetnChannels(image), GetChannelSeq(image));
}
//=================================================
GLuint cvgConvertCVInternalTexFormatToGL(int pixType, int format, const char * _seq/*=" "*/)
{
GLuint GLTexFormat = cvgConvertCVTexFormatToGL(format, _seq);
GLuint GLPixType = cvgConvertCVPixTypeToGL(pixType);
return MainGPU()->ConvertGLFormatToInternalFormat(GLTexFormat, GLPixType);
}
//=================================================
void cvgConvertCVMatrixFormatToGL(CvMat * _mat, GLuint & _internal_format, GLuint & _format, GLuint &_pixtype)
{
SG_Assert(_mat, "No input matrix");
cvgConvertCVMatrixFormatToGL(_mat->type, _internal_format, _format, _pixtype);
}
//=================================================
void cvgConvertCVMatrixFormatToGL(int _type, GLuint & _internal_format, GLuint & _format, GLuint & _pixtype)
{
GLuint Depth;
GLuint Type;
GLuint Channel;
Type = CV_MAT_TYPE(_type);
Depth = CV_MAT_DEPTH(_type);//not working..???
Channel = CV_MAT_CN(_type);
switch(Type)
{
case CV_8U : _pixtype=GL_UNSIGNED_BYTE;break;
case CV_16U : _pixtype=GL_UNSIGNED_SHORT;break;
case CV_16S : _pixtype=GL_SHORT;break;
case CV_32S :
SG_Assert(0, "cvgConvertCVMatrixFormatToGL(), type CV_32S not managed correctly on GPU");
//_pixtype=GL_UNSIGNED_BYTE;
break;
case CV_32F : _pixtype=GL_FLOAT;break;
case CV_64F :
SG_Assert(0, "cvgConvertCVMatrixFormatToGL(), type CV_64F not managed correctly on GPU");
//_pixtype=GL_UNSIGNED_BYTE;
break;
case CV_USRTYPE1 : //_pixtype=GL_UNSIGNED_BYTE;break;
default:
SG_Assert(0, "cvgConvertCVMatrixFormatToGL() type "<< Type <<" is unkown");
}
switch (Channel)
{
case 1: _format = GL_LUMINANCE; break;
case 2: _format = GL_LUMINANCE_ALPHA; break;
case 3: _format = GL_BGR; break;
case 4: _format = GL_BGRA; break;
default:
SG_Assert(0, "cvgConvertCVMatrixFormatToGL() nChannel "<< Channel <<"=> case not done yet.");
}
_internal_format = ProcessingGPU()->ConvertGLFormatToInternalFormat(_format, _pixtype);
}
//=================================================
GPUCV_TEXT_TYPE GetTextureId(CvArr *img)
{
SetThread();
GPUCV_TEXT_TYPE ret = GPUCV_GET_TEX(img);
UnsetThread();
return ret;
}
//=================================================
GpuFilter::FilterSize GetSize(const CvArr * arr)
{
CvSize Size = cvGetSize(arr);
return GpuFilter::FilterSize (Size.width, Size.height);
}
//=================================================
GpuFilter::FilterSize *GetSize(const DataContainer * tex)
{
return (GpuFilter::FilterSize *) tex;
//return GpuFilter::FilterSize (size->_GetWidth(), size->_GetHeight());
}
//=================================================
bool TestDstPointer(const IplImage* dst,const IplImage* src1)
{
if (dst == src1)// && dst!=NULL)
{
GPUCV_WARNING("Warning : TestDstPointer(), both image pointer are equal.");
return false;
}
return true;
}
//=======================================================
#if _GPUCV_DEBUG_MEMORY_LEAK
#include "SugoiTools/debug_new_off.h"
#endif
|
