从0开发游戏引擎之纹理管理器实现 纹理数据绑定OpenGL滤波方式选择线性滤波

已于 2022-12-29 16:19:33 修改
阅读量514 收藏
点赞数
分类专栏： 从0开发游戏引擎 文章标签： 游戏引擎 游戏程序 图形渲染 c++
于 2022-09-07 19:50:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33531923/article/details/126742444
版权

         这一章主要是讲如何把一张图片加载进内存中转换BGR->RGB格式，然后和OpenGL做绑定渲染出来。

        这一章讲解的顺序完全反过来了。基础好的读者也可以反过来看，先看重点，然后再回过头来看源码。没接触过的读者可以先简单的读一遍源码，然后再看重点分析，这样看重点分析的话会更有感觉。源码的话文章写的差不多了，我再整理一下会放到群里。

先贴出完整代码

 TextureManager.h

#pragma once
#include <list>

struct  textureHeight
{
public:
	GLfloat m_iLowHeight=0;//最低高度
	GLfloat	m_iHighHeight=0;//最高高度
	GLfloat m_iOptimalHeight=0;//最佳高度
};

class CCTexture
{
	friend class CTextureManager;
private:
	char name[255]; //纹理路径
	GLuint type;	//类型，保存了一个16进制数
	GLuint texID;	//纹理ID
	UINT  width;     //图片的宽
	UINT height;	//图片的高
	UINT uReference; //引用计数
	int bytesPerPixel; //每个像素的位(Bit)
	GLubyte *imageData;//纹理数据(unsigned char)
	Vector3D centerPos ={0,0,1};

public:
	textureHeight *Tex=new textureHeight;
	CCTexture();
	CCTexture(const char *fileName,float width=1,float height=1);
	CCTexture(const char * name, int wid, int hei, int BitCount);
	int getbyte() { return bytesPerPixel; }
	GLuint getType() { return type; }
	char *getName() { return name; }
	GLuint getTextureID() { return texID; }
	UINT getWidth() { return width; }
	UINT getHeight() { return height; }
	BOOL saveBmp(const char * fileName);
	GLubyte *getImageData() { return imageData; }
	void setImageData(GLubyte *data) { this->imageData = data; }
	void setCenterPos(Vector3D centerPoint);
	void draw();

	~CCTexture() ;

public:
	
	
};

class CTextureManager
{
private:
	std::list<CCTexture*> textureList;
	static CTextureManager*instance;

public:
	static CTextureManager*getInstance();
	CCTexture* addTexture(char *fileName,float width=1,float height=1);
	CCTexture *addTexture(const char*fileName);
	CCTexture * addTexture(char *name, int width, int height, int pixelFormat);
	void resetRef();//把引用计数全都归零
	void releaseRef();//把引用计数全都归零
	void CreateGLTextures(int wid, int hei, int biBitCount, OUT GLuint &texture, OUT GLubyte*&textureData);

	CTextureManager();
	~CTextureManager();
};

TextureManager.cpp

#include "Engine.h"

CTextureManager*CTextureManager::instance = NULL;


CCTexture::CCTexture()
{
	texID = 0;
	uReference = 1;
	imageData = NULL;
}


CCTexture::CCTexture(const char* fileName,float wid,float hei)
{
	texID = 0;
	CImage img;
	HRESULT hr = img.Load(CUser::getInstance()->CharToWchar(fileName));
	if (FAILED(hr))
	{
		char temp[256];
		sprintf_s(temp, 256, "%s打开失败", fileName);
		MessageBox(NULL, CUser::getInstance()->CharToWchar(temp), L"错误", 0);
		return;
	}

	strcpy(name, fileName);
	HBITMAP hbmp = img;
	BITMAP bm;
	GetObject(hbmp, sizeof(bm), &bm);

	if (wid > 1 && hei > 1)
	{
		width = wid;	height = hei;
	}
	else 
	{
		width = bm.bmWidth;	height = bm.bmHeight;
	}
	
	bytesPerPixel = bm.bmBitsPixel / 8;

	if (bytesPerPixel == 3)
	{
		type = GL_RGB;
	}
	else if (bytesPerPixel == 4)
	{
		type = GL_RGBA;
	}
	else if (bytesPerPixel == 1)
	{
		type = GL_LUMINANCE;
	}
		
	imageData = new GLubyte[width*height*bytesPerPixel];
	memcpy(imageData, bm.bmBits, width*height*bytesPerPixel);
	// Convert From BGR To RGB Format And Add An Alpha Value Of 255
	if (bytesPerPixel != 1)
	{
		for (long i = 0; i < width * height; i++)
		{
			GLubyte temp = imageData[0 + i*bytesPerPixel];
			imageData[0 + i*bytesPerPixel] = imageData[2 + i*bytesPerPixel];
			imageData[2 + i*bytesPerPixel] = temp;
		}
	}
	else //等于8位时处理的
	{
		for (int i = 0; i < height; i++)
		{
			memcpy(imageData + i*width, img.GetPixelAddress(0, i), width);
		}
	}
	glGenTextures(1, (GLuint*)&texID);
	glBindTexture(GL_TEXTURE_2D, texID);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);//纹理过滤模式
	gluBuild2DMipmaps(GL_TEXTURE_2D, type, width, height, type, GL_UNSIGNED_BYTE, imageData);
	
	
	/*glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		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_MIPMAP_NEAREST);
		glTexImage2D(GL_TEXTURE_2D, 0, type, width, height, 0, type, GL_UNSIGNED_BYTE, imageData);*/
}
	

CCTexture::CCTexture(const char *name, int wid, int hei, int BitCount)
{
	uReference =1;
	strcpy(this->name,name);
	bytesPerPixel = BitCount / 8;
	this->width = wid;
	this->height = hei;
	glGenTextures(1, &texID);
	glBindTexture(GL_TEXTURE_2D, texID);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	imageData = new GLubyte[width*height*bytesPerPixel];
	//memset(imageData, 0, width*height*bytesPerPixel);


	if (bytesPerPixel == 1)
	{
		for (int i = 0; i < width*height; ++i)
		{
			imageData[i] = 0;
		}
		type = GL_LUMINANCE;
	}
	else if (bytesPerPixel == 3)
	{
		for (int i = 0; i < width*height; ++i)
		{
			imageData[i * 3 + 0] = 0;
			imageData[i * 3 + 1] = 0;
			imageData[i * 3 + 2] = 0;
		}
		type = GL_RGB;
	}
	else if (bytesPerPixel == 4)
	{
		for (int i = 0; i < width*height; ++i)
		{
			imageData[i * 4 + 0] = 0;
			imageData[i * 4 + 1] = 0;
			imageData[i * 4 + 2] = 0;
			imageData[i * 4 + 3] = 0;
		}
		type = GL_RGBA;
	}

	glTexImage2D(GL_TEXTURE_2D, 0, type, wid, hei, 0, type, GL_UNSIGNED_BYTE, imageData);

}

BOOL CCTexture::saveBmp(const char *fileName)
{
	//如果位图数据指针为0,则没有数据传入,函数返回
	if (!imageData)
		return 0;

	//灰度图
	static RGBQUAD *pColorTable = NULL;
	if (pColorTable == NULL)
	{
		pColorTable = new RGBQUAD[256];
		for (int i = 0; i < 256; i++)
		{
			pColorTable[i].rgbBlue = i;
			pColorTable[i].rgbGreen = i;
			pColorTable[i].rgbRed = i;
			pColorTable[i].rgbReserved = 0;
		}
	}

	//颜色表大小,以字节为单位,灰度图像颜色表为1024字节,彩色图像颜色表大小为0
	int colorTablesize = 0;
	if (bytesPerPixel == 1)
		colorTablesize = 1024;
	
	//待存储图像数据每行字节数为4的倍数
	int lineByte = (width * bytesPerPixel + 3) / 4 * 4;

	//以二进制写的方式打开文件
	FILE *fp = fopen(fileName, "wb");
	if (fp == 0) return 0;

	//申请位图文件头结构变量，填写文件头信息
	BITMAPFILEHEADER fileHead;
	fileHead.bfType = 0x4D42;//bmp类型

							 //bfSize是图像文件4个组成部分之和
	fileHead.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER)
		+ colorTablesize + lineByte*height;
	fileHead.bfReserved1 = 0;
	fileHead.bfReserved2 = 0;

	//bfOffBits是图像文件前三个部分所需空间之和
	fileHead.bfOffBits = 54 + colorTablesize;

	//写文件头进文件
	fwrite(&fileHead, sizeof(BITMAPFILEHEADER), 1, fp);

	//申请位图信息头结构变量，填写信息头信息
	BITMAPINFOHEADER head;
	head.biBitCount = bytesPerPixel * 8;
	head.biClrImportant = 0;
	head.biClrUsed = 0;
	head.biCompression = 0;
	head.biHeight = height;
	head.biPlanes = 1;
	head.biSize = 40;
	head.biSizeImage = lineByte*height;
	head.biWidth = width;
	head.biXPelsPerMeter = 0;
	head.biYPelsPerMeter = 0;
	//写位图信息头进内存
	fwrite(&head, sizeof(BITMAPINFOHEADER), 1, fp);

	//如果灰度图像,有颜色表,写入文件
	if (bytesPerPixel == 1)
		fwrite(pColorTable, sizeof(RGBQUAD), 256, fp);

	//写位图数据进文件
	if (bytesPerPixel == 1)
	{
		fwrite(imageData, height*lineByte, 1, fp);
	}
	else
	{
		GLubyte *newData = new GLubyte[width * height*bytesPerPixel];
		memcpy(newData, imageData, width * height*bytesPerPixel);

		for (long i = 0; i < width * height; i++)
		{
			GLubyte temp = newData[0 + i*bytesPerPixel];
			newData[0 + i*bytesPerPixel] = newData[2 + i*bytesPerPixel];
			newData[2 + i*bytesPerPixel] = temp;
		}
		fwrite(newData, height*lineByte, 1, fp);
		delete[]newData;
	}

	//关闭文件
	fclose(fp);
	return 1;
}

void CCTexture::setCenterPos(Vector3D center)
{
	this->centerPos = center;
}


void CCTexture::draw()
{
	float halfWid = width / 2;
	float halfHei = height / 2;
	Vector3D temp = centerPos;
	glEnable(GL_TEXTURE_2D);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glBindTexture(GL_TEXTURE_2D, texID);
	glBegin(GL_QUADS);
	glTexCoord2f(0, 0);	glVertex3f(centerPos.x- halfWid, centerPos.y+halfHei, 1);
	glTexCoord2f(1, 0);	glVertex3f(centerPos.x+ halfWid, centerPos.y+halfHei, 1);
	glTexCoord2f(1, 1); glVertex3f(centerPos.x + halfWid, centerPos.y-halfHei, 1);
	glTexCoord2f(0, 1); glVertex3f(centerPos.x -halfWid, centerPos.y-halfHei, 1);
	glEnd();
	glDisable(GL_TEXTURE_2D);
	glDisable(GL_BLEND);
}


CCTexture::~CCTexture()
{
	glDeleteTextures(1,&texID);
	delete imageData;
}


CTextureManager::CTextureManager()
{
}


CTextureManager*CTextureManager::getInstance()
{
	if (instance == NULL)
	{
		instance = new CTextureManager;
	}
	return instance;
}


CCTexture* CTextureManager::addTexture(char *filename,float width, float height)
{
	list<CCTexture*>::iterator iter;
	for (iter = textureList.begin(); iter != textureList.end(); iter++)
	{
		if (strcmp((*iter)->getName(), filename) == 0)
		{
			(*iter)->uReference++;
			return *iter;
		}
	}
	textureList.push_back(new CCTexture(filename));
	return textureList.back();
}


CCTexture* CTextureManager::addTexture(const char *filename)
{
	const char*lp = strrchr(filename, '.');
	char temp[255];
	if(strcmp(lp,".bmp")==0||strcmp(lp,".jpg")==0)
	{
		strcpy(temp, filename);
	}
	else 
	{
		memset(temp, 0, 255);
		strncpy(temp,filename,lp-filename);
		strcat(temp, ".png");
	}



	list<CCTexture*>::iterator iter;
	for (iter = textureList.begin(); iter != textureList.end(); iter++)
	{
		if (strcmp((*iter)->getName(), filename) == 0)
		{
			(*iter)->uReference++;
			return *iter;
		}
	}
	textureList.push_back(new CCTexture(temp));
	return textureList.back();

}


CCTexture* CTextureManager::addTexture(char *name, int width, int height, int BitCount)
{
	list<CCTexture*>::iterator iter;
	for (iter = textureList.begin(); iter != textureList.end(); iter++)
	{
		if (strcmp((*iter)->getName(), name) == 0)
		{
			(*iter)->uReference++;
			return *iter;
		}
	}
	textureList.push_back(new CCTexture(name, width, height, BitCount));
	return textureList.back();
}


void CTextureManager::releaseRef()
{
	for (auto iter = textureList.begin(); iter != textureList.end();)
	{
		if ((*iter)->uReference == 0)
		{
			delete(*iter);
			textureList.erase(iter++);
		}
		else
			iter++;
	}

}



void CTextureManager::resetRef()
{
	for (auto iter = textureList.begin(); iter != textureList.end(); iter++)
	{
		(*iter)->uReference = 0;
	}
}




void CTextureManager::CreateGLTextures(int wid, int hei, int biBitCount, OUT GLuint &texture, OUT GLubyte*&textureData)
{
	glGenTextures(1, &texture);
	glBindTexture(GL_TEXTURE_2D, texture);
	if (biBitCount == 8)
	{
		textureData = new GLubyte[wid*hei];
		memset(textureData, 0, wid*hei);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);		// 设置过滤器为线性过滤
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexImage2D(GL_TEXTURE_2D, 0, 1, wid, hei, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, textureData);
	}
	else if (biBitCount == 24)
	{
		textureData = new GLubyte[wid*hei * 3];
		memset(textureData, 0, wid*hei * 3);

		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);		// 设置过滤器为线性过滤
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexImage2D(GL_TEXTURE_2D, 0, 3, wid, hei, 0, GL_RGB, GL_UNSIGNED_BYTE, textureData);
	}

}

CTextureManager::~CTextureManager()
{
	for (auto iter = textureList.begin();iter != textureList.end();)
	{
		delete (*iter);
		textureList.erase(iter++);
	}
	textureList.clear();
}

保存BMP格式图片（只能保存BMP）

这个函数当时主要是能把编辑器里刷的地形保存出去使用的。

BOOL CCTexture::saveBmp(const char *fileName)
{
	//如果位图数据指针为0,则没有数据传入,函数返回
	if (!imageData)
		return 0;

	//灰度图
	static RGBQUAD *pColorTable = NULL;
	if (pColorTable == NULL)
	{
		pColorTable = new RGBQUAD[256];
		for (int i = 0; i < 256; i++)
		{
			pColorTable[i].rgbBlue = i;
			pColorTable[i].rgbGreen = i;
			pColorTable[i].rgbRed = i;
			pColorTable[i].rgbReserved = 0;
		}
	}

	//颜色表大小,以字节为单位,灰度图像颜色表为1024字节,彩色图像颜色表大小为0
	int colorTablesize = 0;
	if (bytesPerPixel == 1)
		colorTablesize = 1024;
	
	//待存储图像数据每行字节数为4的倍数
	int lineByte = (width * bytesPerPixel + 3) / 4 * 4;

	//以二进制写的方式打开文件
	FILE *fp = fopen(fileName, "wb");
	if (fp == 0) return 0;

	//申请位图文件头结构变量，填写文件头信息
	BITMAPFILEHEADER fileHead;
	fileHead.bfType = 0x4D42;//bmp类型

							 //bfSize是图像文件4个组成部分之和
	fileHead.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER)
		+ colorTablesize + lineByte*height;
	fileHead.bfReserved1 = 0;
	fileHead.bfReserved2 = 0;

	//bfOffBits是图像文件前三个部分所需空间之和
	fileHead.bfOffBits = 54 + colorTablesize;

	//写文件头进文件
	fwrite(&fileHead, sizeof(BITMAPFILEHEADER), 1, fp);

	//申请位图信息头结构变量，填写信息头信息
	BITMAPINFOHEADER head;
	head.biBitCount = bytesPerPixel * 8;
	head.biClrImportant = 0;
	head.biClrUsed = 0;
	head.biCompression = 0;
	head.biHeight = height;
	head.biPlanes = 1;
	head.biSize = 40;
	head.biSizeImage = lineByte*height;
	head.biWidth = width;
	head.biXPelsPerMeter = 0;
	head.biYPelsPerMeter = 0;
	//写位图信息头进内存
	fwrite(&head, sizeof(BITMAPINFOHEADER), 1, fp);

	//如果灰度图像,有颜色表,写入文件
	if (bytesPerPixel == 1)
		fwrite(pColorTable, sizeof(RGBQUAD), 256, fp);

	//写位图数据进文件
	if (bytesPerPixel == 1)
	{
		fwrite(imageData, height*lineByte, 1, fp);
	}
	else
	{
		GLubyte *newData = new GLubyte[width * height*bytesPerPixel];
		memcpy(newData, imageData, width * height*bytesPerPixel);

		for (long i = 0; i < width * height; i++)
		{
			GLubyte temp = newData[0 + i*bytesPerPixel];
			newData[0 + i*bytesPerPixel] = newData[2 + i*bytesPerPixel];
			newData[2 + i*bytesPerPixel] = temp;
		}
		fwrite(newData, height*lineByte, 1, fp);
		delete[]newData;
	}

	//关闭文件
	fclose(fp);
	return 1;
}

加载文件&绑定纹理选择滤波类型

因为使用的是Windows的图像API加载的，加载进来的图像格式是BGR格式的，要从BGR转换成OpenGL需要的RGB格式。图片过滤方式选择 GL_LINEAR（也叫线性过滤，(Bi)linear Filtering）它会基于纹理坐标附近的纹理像素，计算出一个插值，近似出这些纹理像素之间的颜色。

使用线性过滤的优点与缺点
  优点:
        1.质量高：避免了在远距离情况下的采样频率低和数据频率高造成的失真和摩尔纹，效果比无Mipmap好得多。

        2.性能好：避免了不使用Mipmap下距离远时采样频率低和数据频率高而照成texture cache命中率不高(相邻Pixel采样Texel时uv相差比较大)使性能下降。

  缺点：
         1.占用显存，可使用ue的纹理流缓存优化（IO换显存）。

CCTexture::CCTexture(const char* fileName,float wid,float hei)
{
	texID = 0;
	CImage img;
	HRESULT hr = img.Load(CUser::getInstance()->CharToWchar(fileName));
	if (FAILED(hr))
	{
		char temp[256];
		sprintf_s(temp, 256, "%s打开失败", fileName);
		MessageBox(NULL, CUser::getInstance()->CharToWchar(temp), L"错误", 0);
		return;
	}

	strcpy(name, fileName);
	HBITMAP hbmp = img;
	BITMAP bm;
	GetObject(hbmp, sizeof(bm), &bm);

	if (wid > 1 && hei > 1)
	{
		width = wid;	height = hei;
	}
	else 
	{
		width = bm.bmWidth;	height = bm.bmHeight;
	}
	
	bytesPerPixel = bm.bmBitsPixel / 8;

	if (bytesPerPixel == 3)
	{
		type = GL_RGB;
	}
	else if (bytesPerPixel == 4)
	{
		type = GL_RGBA;
	}
	else if (bytesPerPixel == 1)
	{
		type = GL_LUMINANCE;
	}
		
	imageData = new GLubyte[width*height*bytesPerPixel];
	memcpy(imageData, bm.bmBits, width*height*bytesPerPixel);
	// Convert From BGR To RGB Format And Add An Alpha Value Of 255
	if (bytesPerPixel != 1)
	{
		for (long i = 0; i < width * height; i++)
		{
			GLubyte temp = imageData[0 + i*bytesPerPixel];
			imageData[0 + i*bytesPerPixel] = imageData[2 + i*bytesPerPixel];
			imageData[2 + i*bytesPerPixel] = temp;
		}
	}
	else //等于8位时处理的
	{
		for (int i = 0; i < height; i++)
		{
			memcpy(imageData + i*width, img.GetPixelAddress(0, i), width);
		}
	}
	glGenTextures(1, (GLuint*)&texID);
	glBindTexture(GL_TEXTURE_2D, texID);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);//纹理过滤模式
	gluBuild2DMipmaps(GL_TEXTURE_2D, type, width, height, type, GL_UNSIGNED_BYTE, imageData);
}

天才小熊猫oo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
learnOpenGL笔记——基础篇（4）
giraffe1997的博客
06-06 181
纹理坐标(Texture Coordinate)：纹理坐标属于二维坐标系，范围通常是从(0, 0)到(1, 1)，图形的每个顶点绑定一个纹理坐标，用来标明该从纹理图像的哪个部分采样，也就是映射（Map）。 一个三角形在纹理坐标系中三个顶点对应的纹理坐标如下： float texCoords[] = { 0.0f, 0.0f, // 左下角顶点 1.0f, 0.0f, // 右下角 0.5f, 1.0f // 上中 }; 贴图效果如下： 纹理过滤（纹理滤波） GL_
自动纹理管理
cainiao_liu的专栏
02-11 791
d3d中的自动纹理管理    纹理管理是在给定的时间确定哪些纹理需要渲染并保证那些纹理被加载到显存的过程。纹理管理算法可能非常复杂，但是它基本上都会包含下面三个主要步骤：1. 跟踪可以获取到的显存的总量；2.计算哪些纹理是渲染所必须的，哪些不是；3.确定哪些显存中的纹理资源需要被另外的纹理图片替换；     d3d实现了系统支持的纹理管理，保证了纹理加载的性能很快。d3
OpenGL(四)——纹理
GZ的博客
05-04 2406
为每个顶点添加颜色可以增加图形的细节，但是更多的点会导致运行效率下降。使用纹理可以增加细节，又不用指定额外的顶点。纹理是一个2D图片（也有1D和3D纹理）。除了图像外纹理也可以用来存储大量的数据，这些数据可以发送给着色器。要想把纹理映射到三角形上，必须指定三角形的每个顶点各自对应纹理的哪个部分。这样每个顶点就会关联一个纹理坐标（Texture Coordinate），表明该纹理图像的哪个片段采样，之后在图形的其它片段进行片段插值（Fragment interpolation）。
cocos2dx：CCTexture2D注解
孙君的空间站
07-27 1242
加载图片后，图片是以Texture2D存储在内存当中的，这个Texture2D包含了显示图片所有的数据，包含像素纹理信息等等,所以每张图片被加载到内存后都会生成一个Texture2DQQ交流群该群为CSDN博主Chinar所创，推荐一下！我也在群里！本文属于原创文章，转载请著名作者出处并置顶！！...
导向滤波算法——OpenGL实现
q345911572的博客
01-30 2264
导向滤波算法——OpenGL实现
OpenGL.rar_OPENGL 纹理
09-23
6. **纹理滤波**：当纹理被放大或缩小显示时，OpenGL提供了几种滤波模式，如GL_NEAREST（最近邻插值）和GL_LINEAR（线性插值），以平滑图像边缘。 7. **MIP贴图**：为优化性能，OpenGL支持MIP贴图，即预先计算出...
OpenGL中纹理贴图、滤波、光照和雾化效果编程初步
07-04
在OpenGL中，我们可以使用`glBindTexture`函数绑定纹理，`glTexImage2D`来加载纹理数据，并通过坐标映射将它们应用到顶点上。 其次，**滤波（Filtering）**用于处理纹理采样时的像素细节，包括了近似处理和抗锯齿。...
7-纹理滤波、光源和键盘控制1
08-03
在OpenGL中，纹理的加载通常涉及读取图像文件，然后使用`glGenTextures`生成纹理ID，最后通过`glTexImage2D`将图像数据绑定到纹理对象。在给出的代码片段中，`loadGLTextures()`函数负责这个过程。它可能首先使用...
基于Android平台的纹理映射分析与实现.docx
10-13
3. **纹理滤波设置**：为了确保在纹理缩放时保持平滑效果，通常会设置线性滤波，如`GL_TEXTURE_MIN_FILTER`和`GL_TEXTURE_MAG_FILTER`，以确保无论纹理如何缩放，其显示质量都不会明显下降。 4. **纹理启用与坐标...
opengl创建动态场景
08-22
6. **纹理滤波**：为了处理纹理放大或缩小时的模糊问题，OpenGL提供了多种纹理滤波方式，如`GL_NEAREST`（最近邻插值）和`GL_LINEAR`（线性插值）。`glTexParameter()`函数可以设置纹理过滤选项。 7. **图形变换**...
OpenGL超级宝典学习笔记：纹理
孙君的空间站
03-10 787
本篇章记录对OpenGL中纹理使用的学习
基于边缘检测的磨皮算法实现——OpenGL版
q345911572的博客
03-06 904
基于边缘检测的磨皮算法实现——OpenGL版
《Cocos2D权威指南》——3.5　CCTexture纹理类
weixin_34288121的博客
08-01 136
3.5　CCTexture纹理类 游戏运行中，所有图像文件（PNG、PVR）都被加载成GPU可以理解的OpenGL ES纹理，而精灵则对应着这些纹理图。Cocos2D内置一个纹理缓存管理器（CCTextureCache）来保存这些纹理图，这样可以极大加速创建新精灵，并充分利用已有的纹理图。不利的是，如果收到内存警报，Cocos2D会将当前未使用的纹理图（...
纹理缓存CCTextureCache
WandingPace
05-18 1771
使用CCTexture2D加载图片 ，用CCTexture2D生成对应的CCSpriteFrame（对应的就是帧），将CCSpriteFrame添加到CCAnimation生成动画数据，用CCAnimation生成CCAnimate（就是最终的动画动作），最后用CCSprite执行这个动作。
游戏中的资源管理-纹理
blanc的博客
08-20 1488
纹理资源 简述： 游戏中的图片资源，需要根据不同的情况将其规划成几张大图，有针对性的加载纹理，可以减少纹理的内存占用，减少绘制的批次（cocos中的自动批量绘制功能）。 资源打包 在资源编辑工具的文件夹下，使用ruby脚本调用TexturePacker 和 pngquanti工具提供的命令行（需要安装这两个软件并将运行目录添加到环境变量中） 将资源进行打包成大图与对图片进行压缩。...
纹理管理
icebergliu1234的博客
06-13 200
如果显卡中只有64MB的视频内存，就应该考虑将哪些纹理加载和保留在内存中。可以编写一个算法让计算机来自动考虑这些问题，那么这个算法的任务是什么呢？它需要跟踪可用的纹理内存总数，并了解哪些纹理是经常用到的，而哪些纹理是很少用到的。至少，这个纹理管理算法必须能决定哪些现有的纹理资源可以通过一张纹理图来重新加载，以及应该销毁哪些表面，然后由新的纹理资源取而代之。Direct3D有一个自动的纹理管理系统，...
OpenGL学习十六：纹理绑定
StarFlex
01-21 3749
前面介绍的都是给图元添加颜色，纹理绑定介绍的是如果把图片绑定到图元，主要步骤如下：（这里这是简单介绍，后续详细说明） 1.生成纹理ID glGenTextures(1, &texture[0]); 2.创建纹理对象 glBindTexture(GL_TEXTURE_*D, texture[0]); 3.指定纹理内容 glTexImage*D(); 4.指定纹理属性 glTexPar
OpenGL纹理详解（上）
lhd_ustc的博客
04-09 7008
转载自http://www.jianshu.com/p/1829b4acc58d，感谢原博主的指点，个人觉得这篇博文很适合初学者，特此转发。     写在前面的话     现实生活中，纹理最通常的作用是装饰我们的物体模型，它就像是贴纸一样贴在物体表面，使得物体表面拥有图案。但实际上在OpenGL中，纹理的作用不仅限于此，它可以用来存储大量的数据，一个典型的例子就是利用纹理存储地形信息
pyton实现gabor滤波纹理提取
最新发布
06-28
### 回答1： Gabor滤波器是一种用于纹理分析的滤波器，它可以提取图像中的纹理特征。Python中可以使用OpenCV库实现Gabor滤波器。具体实现步骤如下： 1. 导入OpenCV库和numpy库。 2. 定义Gabor滤波器的参数，包括方向、频率、相位等。 3. 使用cv2.getGaborKernel()函数生成Gabor滤波器核。 4. 对输入图像进行Gabor滤波，可以使用cv2.filter2D()函数。 5. 可以将滤波后的图像进行二值化或者进行其他后续处理。 以上就是Python实现Gabor滤波器进行纹理提取的基本步骤。 ### 回答2： Gabor滤波器是一种常用的纹理特征提取方法，可以通过在多个方向和不同频率上对图像进行过滤，以便提取出不同的特征。在Python中，可以使用SciPy库和OpenCV库实现Gabor滤波。 首先，导入所需的库: ``` import numpy as np from scipy import ndimage from scipy import signal import cv2 ``` 然后定义Gabor滤波器: ``` def build_filters(): filters = [] ksize = 9 for theta in np.arange(0, np.pi, np.pi / 4): for frequency in (0.1, 0.3, 0.6): kernel = cv2.getGaborKernel((ksize, ksize), 4.0, theta, frequency, 0.5, 0, ktype=cv2.CV_32F) kernel /= 1.5 * kernel.sum() filters.append(kernel) return filters ``` 在此示例中，我们定义了3个不同的频率和4个不同的方向。在每个方向和频率上，我们使用OpenCV库中提供的cv2.getGaborKernel()函数创建一个Gabor核。然后，每个核都被缩放，并将所有核附加到滤波器数组中。 接下来，我们可以使用这些核滤波输入图像: ``` def process(image, filters): accum = np.zeros_like(image) for kernel in filters: filtered = ndimage.convolve(image, kernel, mode='wrap') np.maximum(accum, filtered, accum) return accum ``` 在此函数中，我们遍历每个核并将其应用于输入图像。我们使用SciPy库的ndimage.convolve()函数来实现卷积，然后将获得的过滤结果与之前的结果进行比较。在这里，我们使用函数np.maximum()选择较大的值，从而获取具有更强纹理特征的像素。 最后，我们加载图像并运行这些函数: ``` # load image image = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE) # build filters filters = build_filters() # apply filters result = process(image, filters) # show result cv2.imshow('Result', result) cv2.waitKey(0) cv2.destroyAllWindows() ``` 在这个例子中，我们使用OpenCV库加载了一个灰度图像，并将其输入到我们之前定义的函数中。然后，在应用了所有Gabor核之后，我们将最终结果显示在屏幕上。 总之，Python可以实现Gabor滤波纹理提取，只需要使用SciPy和OpenCV库即可。通过处理输入图像，在不同方向和频率处卷积图像，可以提取不同的纹理特征。 ### 回答3： Gabor滤波器是用于纹理提取的一种常见滤波器，它是基于Gabor函数的滤波器，在图像处理中被广泛应用于目标检测、人脸识别、纹理识别等领域。Python提供了多种实现库，如OpenCV、scikit-image和SciPy等。 下面以OpenCV为例介绍Python实现Gabor滤波纹理提取的步骤： 1. 导入库 ```python import cv2 import numpy as np ``` 2. 定义Gabor滤波器参数 ```python wavelength = 30 # 滤波器波长 theta = 0 # 滤波器角度 ksize = 31 # 滤波器大小 sigma = 5 # 高斯核标准差 gamma = 0.5 # 滤波器空间长宽比 psi = 0 # 相位偏移 ``` 3. 生成Gabor滤波器 ```python kernels = cv2.getGaborKernel((ksize, ksize), sigma, theta, wavelength, gamma, psi) ``` 4. 加载图像并进行Gabor滤波 ```python img = cv2.imread('test.jpg', cv2.IMREAD_GRAYSCALE) filtered_img = cv2.filter2D(img, cv2.CV_8UC3, kernels) ``` 5. 显示结果 ```python cv2.imshow('Original Image', img) cv2.imshow('Gabor Filtered Image', filtered_img) cv2.waitKey(0) cv2.destroyAllWindows() ``` 通过以上步骤，我们可以通过Python实现Gabor滤波器进行图像纹理提取。有关Gabor滤波器的更多信息，请参阅相关文献或文档。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值