openGL shader实现DCT变换

最新推荐文章于 2023-06-11 11:10:15 发布
最新推荐文章于 2023-06-11 11:10:15 发布
阅读量468 收藏
点赞数
分类专栏： OpenGL 文章标签： openGL shader DCT opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiechaoyi123/article/details/86600931
版权

目标：实现图像的DCT变换

过程：

        1）通过opencv读取图像；

        2） 构建openGL窗口及初始化着色器程序；

        3） 通过DCT原理编写shader脚本

        4） 通过FBO离屏渲染得到DCT图像；

        5） 和opencv自带的DCT函数结果对比。

        4）在窗口中显示图像。

 

上代码：

#include<glad/glad.h>
#include<GLFW/glfw3.h>

#include<iostream>

#include<opencv2/opencv.hpp>

#include"shader.h"
#include"openGLinit.h"

using namespace std;
using namespace cv;
void processInput(GLFWwindow *window)
{
	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
		glfwSetWindowShouldClose(window, true);
}
int main()
{
	int w= 800, h= 600;
	GLFWwindow*window = init(w, h);
	std::string imName = "F:/chess.jpg";
	cv::Mat im = cv::imread(imName);

    //resize image and calculate dct image
	cv::resize(im,im,cv::Size(w,h));
	cv::Mat dctSrc;
	im.convertTo(dctSrc, CV_32F);
	std::vector<cv::Mat> vImgs;
	cv::split(dctSrc,vImgs);
	for (int i = 0; i < vImgs.size(); ++i)
	{
		cv::dct(vImgs[i], vImgs[i]);
	}
	cv::merge(vImgs,dctSrc);

    //init VAO,VBO
	unsigned int Texture;
	glGenTextures(1, &Texture);
	GenTextureByMat(Texture, im);
	
	float vertices[] = {
		1.0f,  1.0f,  1.0f, 1.0f, // top right
		1.0f, -1.0f, 1.0f, 0.0f, // bottom right
		-1.0f,  1.0f,  0.0f, 1.0f,  // top left

		1.0f, -1.0f, 1.0f, 0.0f, // bottom right
		-1.0f, -1.0f,0.0f, 0.0f, // bottom left
		-1.0f,  1.0f,0.0f, 1.0f  // top left 
	};
	std::vector<int> params(2, 2);
	unsigned int VAO1, VBO1;
	initVAO(VAO1, VBO1, vertices, 6, params);

    //init shader program
	time_t t0 = clock();
	Shader dctshader2("dct.vs", "dctRow.fs");
	Shader dctshader3("dct.vs", "dct2.fs");
	Shader screenShader("5.1.framebuffers_screen.vs", "5.1.framebuffers_screen.fs");
	dctshader2.use();
	dctshader2.setInt("src", 0);
	dctshader2.setVec2("textureSize", w, h);
	dctshader3.use();
	dctshader3.setInt("src", 0);
	dctshader3.setVec2("textureSize", w, h);
	screenShader.use();
	screenShader.setInt("image", 0);
	
    //init FBO
	GLuint textures[1];
	GLuint FBO1;
	initFBO32F(FBO1, textures, 1, w, h);
	GLuint dcttextures[1];
	GLuint FBO2;
	initFBO32F(FBO2, dcttextures, 1, w, h);

	//first step for dct
	glViewport(0, 0, w, h);
	glBindFramebuffer(GL_FRAMEBUFFER, FBO1);
	glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT);
	{
		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, Texture);
		glDrawBuffer(GL_COLOR_ATTACHMENT0);
		dctshader2.use();
		glBindVertexArray(VAO1);
		glDrawArrays(GL_TRIANGLES, 0, 6);
		glBindVertexArray(0);
	}
	glBindFramebuffer(GL_FRAMEBUFFER, 0);

    //second step for dct
	glBindFramebuffer(GL_FRAMEBUFFER, FBO2);
	glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT);
	{
		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, textures[0]);
		glDrawBuffer(GL_COLOR_ATTACHMENT0);
		dctshader3.use();
		glBindVertexArray(VAO1);
		glDrawArrays(GL_TRIANGLES, 0, 6);
		glBindVertexArray(0);
	}
	cv::Mat DCTYImage2 = cv::Mat(cv::Size(w, h),CV_32FC3);
	glReadBuffer(GL_COLOR_ATTACHMENT0);
	glReadPixels(0, 0, w, h, GL_RGB, GL_FLOAT, DCTYImage2.data);
	DCTYImage2 *= 255.0f;
	cv::Mat diff = DCTYImage2 - dctSrc;
 	glBindFramebuffer(GL_FRAMEBUFFER, 0);
	time_t t1 = clock();
	std::cout << "total time:" << t1 - t0 << std::endl;

    //show in the openGL windows
	while (!glfwWindowShouldClose(window))
	{
		processInput(window);
		glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		screenShader.use();
		glBindVertexArray(VAO1);
		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, Texture);
		glDrawArrays(GL_TRIANGLES, 0, 6);
		glfwSwapBuffers(window);
		glfwPollEvents();
	}


    //delete all the malloc
	glDeleteVertexArrays(1, &VAO1);
	glDeleteBuffers(1, &VBO1);
	glDeleteTextures(1, &Texture);
	glDeleteTextures(1, textures);
	glDeleteTextures(1, dcttextures);
	glDeleteFramebuffers(1, &FBO1);
	glDeleteFramebuffers(1, &FBO2);
	glfwTerminate();
	return 0;
}

其中include的几个程序中shader.h代码如下：

#ifndef SHADER_H
#define SHADER_H

#include <glad/glad.h>

#include <glm/glm.hpp>
#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

class Shader
{
public:
	unsigned int ID;//着色器程序对象id
	// constructor generates the shader on the fly
	Shader(const char* vertexPath, const char* fragmentPath, const char* geometryPath = nullptr)
	{
		// 1. retrieve the vertex/fragment source code from filePath
		std::string vertexCode;
		std::string fragmentCode;
		std::string geometryCode;
		std::ifstream vShaderFile;
		std::ifstream fShaderFile;
		std::ifstream gShaderFile;
		// ensure ifstream objects can throw exceptions:
		vShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
		fShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
		gShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
		try
		{
			// open files
			vShaderFile.open(vertexPath);
			fShaderFile.open(fragmentPath);
			std::stringstream vShaderStream, fShaderStream;
			// read file's buffer contents into streams
			vShaderStream << vShaderFile.rdbuf();
			fShaderStream << fShaderFile.rdbuf();
			// close file handlers
			vShaderFile.close();
			fShaderFile.close();
			// convert stream into string
			vertexCode = vShaderStream.str();
			fragmentCode = fShaderStream.str();
			// if geometry shader path is present, also load a geometry shader
			if (geometryPath != nullptr)
			{
				gShaderFile.open(geometryPath);
				std::stringstream gShaderStream;
				gShaderStream << gShaderFile.rdbuf();
				gShaderFile.close();
				geometryCode = gShaderStream.str();
			}
		}
		catch (std::ifstream::failure e)
		{
			std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl;
		}
		const char* vShaderCode = vertexCode.c_str();
		const char * fShaderCode = fragmentCode.c_str();


		// 2. compile shaders
		unsigned int vertex, fragment;
		// vertex shader
		vertex = glCreateShader(GL_VERTEX_SHADER);
		glShaderSource(vertex, 1, &vShaderCode, NULL);
		glCompileShader(vertex);
		checkCompileErrors(vertex, "VERTEX");
		// fragment Shader
		fragment = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(fragment, 1, &fShaderCode, NULL);
		glCompileShader(fragment);
		checkCompileErrors(fragment, "FRAGMENT");
		// if geometry shader is given, compile geometry shader
		unsigned int geometry;
		if (geometryPath != nullptr)
		{
			const char * gShaderCode = geometryCode.c_str();
			geometry = glCreateShader(GL_GEOMETRY_SHADER);
			glShaderSource(geometry, 1, &gShaderCode, NULL);
			glCompileShader(geometry);
			checkCompileErrors(geometry, "GEOMETRY");
		}
		// shader Program
		ID = glCreateProgram();
		glAttachShader(ID, vertex);
		glAttachShader(ID, fragment);
		if (geometryPath != nullptr)
			glAttachShader(ID, geometry);
		glLinkProgram(ID);
		checkCompileErrors(ID, "PROGRAM");
		// delete the shaders as they're linked into our program now and no longer necessery
		glDeleteShader(vertex);
		glDeleteShader(fragment);
		if (geometryPath != nullptr)
			glDeleteShader(geometry);

	}
	// activate the shader
	// ------------------------------------------------------------------------
	void use()
	{
		glUseProgram(ID);
	}
	// utility uniform functions
	// ------------------------------------------------------------------------
	void setBool(const std::string &name, bool value) const
	{
		glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value);
	}
	// ------------------------------------------------------------------------
	void setInt(const std::string &name, int value) const
	{
		glUniform1i(glGetUniformLocation(ID, name.c_str()), value);
	}
	// ------------------------------------------------------------------------
	void setFloat(const std::string &name, float value) const
	{
		glUniform1f(glGetUniformLocation(ID, name.c_str()), value);
	}
	// ------------------------------------------------------------------------
	void setVec2(const std::string &name, const glm::vec2 &value) const
	{
		glUniform2fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
	}
	void setVec2(const std::string &name, float x, float y) const
	{
		glUniform2f(glGetUniformLocation(ID, name.c_str()), x, y);
	}
	// ------------------------------------------------------------------------
	void setVec3(const std::string &name, const glm::vec3 &value) const
	{
		glUniform3fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
	}
	void setVec3(const std::string &name, float x, float y, float z) const
	{
		glUniform3f(glGetUniformLocation(ID, name.c_str()), x, y, z);
	}
	// ------------------------------------------------------------------------
	void setVec4(const std::string &name, const glm::vec4 &value) const
	{
		glUniform4fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
	}
	void setVec4(const std::string &name, float x, float y, float z, float w)
	{
		glUniform4f(glGetUniformLocation(ID, name.c_str()), x, y, z, w);
	}
	// ------------------------------------------------------------------------
	void setMat2(const std::string &name, const glm::mat2 &mat) const
	{
		glUniformMatrix2fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
	}
	// ------------------------------------------------------------------------
	void setMat3(const std::string &name, const glm::mat3 &mat) const
	{
		glUniformMatrix3fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
	}
	// ------------------------------------------------------------------------
	void setMat4(const std::string &name, const glm::mat4 &mat) const
	{
		glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
	}

private:
	// utility function for checking shader compilation/linking errors.
	// ------------------------------------------------------------------------
	void checkCompileErrors(GLuint shader, std::string type)
	{
		GLint success;
		GLchar infoLog[1024];
		if (type != "PROGRAM")
		{
			glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
			if (!success)
			{
				glGetShaderInfoLog(shader, 1024, NULL, infoLog);
				std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
			}
		}
		else
		{
			glGetProgramiv(shader, GL_LINK_STATUS, &success);
			if (!success)
			{
				glGetProgramInfoLog(shader, 1024, NULL, infoLog);
				std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
			}
		}
	}
};
#endif

openGLinit.h 代码：

#include<GLFW\glfw3.h>
#include<glad\glad.h>
#include<iostream>
#include<vector>
#include<opencv2/opencv.hpp>
static int index = 0, nextIndex = 1;
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
	glViewport(0, 0, width, height);
}

//init windows
GLFWwindow* init(int width, int height)
{
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);//主版本号
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);//次版本号
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//使用核心模式

#ifdef __APPLE__
	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // uncomment this statement to fix compilation on OS X
#endif
	GLFWwindow*window = glfwCreateWindow(width, height, "LearnOpenGL", NULL, NULL);//创建窗口，设置窗口大小
	if (window == NULL)
	{
		std::cout << "Failed to create GLFW window" << std::endl;
		glfwTerminate();
		return NULL;
	}
	glfwMakeContextCurrent(window);//将窗口的上下文设置为当前线程的主上下文

								   //视口回调函数,这样OpenGL才知道怎样根据窗口大小显示数据和坐标
	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))//初始化GLAD
	{
		std::cout << "Failed to initialize GLAD" << std::endl;
		return NULL;
	}
	return window;
}

//init VAo
void initVAO(unsigned int& VAO, unsigned int& VBO, float* vertextices, const int& num, std::vector<int>& vertexParams)
{
	glGenVertexArrays(1, &VAO);
	glGenBuffers(1, &VBO);
	glBindVertexArray(VAO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);


	int numPart = vertexParams.size();
	int numAll = 0;
	for (int i = 0; i < numPart; ++i)
		numAll += vertexParams[i];
	glBufferData(GL_ARRAY_BUFFER, sizeof(float)*numAll*num, vertextices, GL_STATIC_DRAW);
	int offset = 0;
	for (int i = 0; i < numPart; ++i)
	{
		if (i != 0)
			offset += vertexParams[i - 1];
		glVertexAttribPointer(i, vertexParams[i], GL_FLOAT, GL_FALSE, numAll * sizeof(float), (void*)(offset * sizeof(float)));
		glEnableVertexAttribArray(i);
	}
}

//generate texture by opencv Mat
void GenTextureByMat(unsigned int& texture, const cv::Mat& img)
{
	int cn = img.channels();
	assert(!img.empty() && (cn == 1 || cn == 2 || cn == 3) && (img.type() == CV_8U || img.type() == CV_32F));
	glBindTexture(GL_TEXTURE_2D, texture);
	// set the texture wrapping parameters
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
	// set texture filtering parameters
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	//std::cout << "glGenTextures error:" << glGetError() << std::endl;
	if (cn == 1)
	{
		if (img.type() == CV_8UC1)
		{
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, img.cols, img.rows, 0, GL_RED,
				GL_UNSIGNED_BYTE, img.data);
		}
		else
		{
			glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, img.cols, img.rows, 0, GL_RED,
				GL_FLOAT, img.data);
		}
	}
	else if (cn == 2)
	{
		if (img.type() == CV_8UC2)
		{
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RG, img.cols, img.rows, 0, GL_RG,
				GL_UNSIGNED_BYTE, img.data);
		}
		else
		{
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RG32F, img.cols, img.rows, 0, GL_RG,
				GL_FLOAT, img.data);
		}
	}
	else {
		if (img.type() == CV_8UC3)
		{
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, img.cols, img.rows, 0, GL_RGB,
				GL_UNSIGNED_BYTE, img.data);
		}
		else
		{
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, img.cols, img.rows, 0, GL_RGB,
				GL_FLOAT, img.data);
		}
	}
	glGenerateMipmap(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, 0);
}


//init FBO
void initFBO(unsigned int& FBO, unsigned int* textures,/*, GLuint& rbo,*/
	const int& numColorTexture, const int& width, const int& height)
{
	//frame buffer
	glGenFramebuffers(1, &FBO);
	glBindFramebuffer(GL_FRAMEBUFFER, FBO);
	//color buffer
	glGenTextures(numColorTexture, textures);
	for (int i = 0; i < numColorTexture; ++i)
	{
		glBindTexture(GL_TEXTURE_2D, textures[i]);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, textures[i], 0);
		glBindTexture(GL_TEXTURE_2D, 0);
	}

	// render buffer object
	GLuint rbo;
	glGenRenderbuffers(1, &rbo);
	glBindRenderbuffer(GL_RENDERBUFFER, rbo);
	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
	glBindRenderbuffer(GL_RENDERBUFFER, 0);
	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo);
	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
		std::cout << "setup texture framebuffer failed" << glCheckFramebufferStatus(GL_FRAMEBUFFER) << std::endl;
	}
	glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

//init float FBO
void initFBO32F(unsigned int& FBO, unsigned int* textures,/*, GLuint& rbo,*/
	const int& numColorTexture, const int& width, const int& height)
{
	//frame buffer
	glGenFramebuffers(1, &FBO);
	glBindFramebuffer(GL_FRAMEBUFFER, FBO);
	//color buffer
	glGenTextures(numColorTexture, textures);
	for (int i = 0; i < numColorTexture; ++i)
	{
		glBindTexture(GL_TEXTURE_2D, textures[i]);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, width, height, 0, GL_RGB, GL_FLOAT, NULL);
		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, textures[i], 0);
		glBindTexture(GL_TEXTURE_2D, 0);
	}

	// render buffer object
	GLuint rbo;
	glGenRenderbuffers(1, &rbo);
	glBindRenderbuffer(GL_RENDERBUFFER, rbo);
	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
	glBindRenderbuffer(GL_RENDERBUFFER, 0);
	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo);
	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
		std::cout << "setup texture framebuffer failed" << glCheckFramebufferStatus(GL_FRAMEBUFFER) << std::endl;
	}
	glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

 时间是注释了将openGL中的纹理下载到本地的那几行代码运行时间，注释掉的代码如下：

cv::Mat DCTYImage2 = cv::Mat(cv::Size(w, h), CV_32FC3);
glReadBuffer(GL_COLOR_ATTACHMENT0);
glReadPixels(0, 0, w, h, GL_RGB, GL_FLOAT, DCTYImage2.data);
DCTYImage2 *= 255.0f;
cv::Mat diff = DCTYImage2 - dctSrc;

测试结果如下：

 opencv的dct结果：

openGL的dct结果：

 

两者之差为：

 

基本上都是等于0，存在1e-5的量级误差，可能是GPU运算和CPU运算保留精度不同造成，但是可以基本上认定实现了图像的dct变换过程的openGL版本

 

 

 

xiechaoyi123
关注
专栏目录
dct.rar_DCT变换_dct_dct 变换_fft实现dct
09-20
标题中的“dct.rar_DCT变换_dct_dct 变换_fft实现dct”表明这个压缩包文件包含了关于DCT变换的源代码或资料，并且是通过快速傅里叶变换（FFT）来实现的。 DCT变换的核心是将一个离散的时间序列转换成频域表示，它...
GeForce GTX 965M显卡运行OpenGL程序卡在glGetProgramiv函数的问题
zhouschina的专栏
02-16 881
出现问题电脑：雷神 G150T-D1a 问题显卡：GeForce GTX 965M官方驱动 程序运行到glGetProgramiv函数时，卡在glGetProgramiv函数里面出不来了。 glGetProgramiv(shader, GL_LINK_STATUS, &success); if(!success) { glGetProgramInfoLog(shad...
OpenGL学习之着色器详解
Estelle
06-23 2646
OpenGL着色器语言（GLSL）看上去很像C语言，它由OpenGL实现进行编译和连接，并且（经常是）完全在图形硬件中运行。 我们有顶点着色器、片段着色器和几何着色器，前两种是必需的，后一种是可选的。 有三种向顶点着色器传递数据的方式：（1）参数，是对每个顶点而言； （2）统一值，是针对整个顶点数据批次的常量（所以是一致的） （3）加载和使用纹理数据 可以为片段着色器设置统一值和纹理数据...
OpenGL之坐标系统练习
yangchunnoodles的博客
11-16 2283
/************************************************************/ /***************in cpp***************************************/ /************************************************************/ // build and compile our shader zprogram // -------------------.
opengl之几何着色器（2D房子）
wqdqwass的博客
09-09 691
官方文章 opengl之及和着色器 概念 在顶点和片段着色器之间有一个可选的几何着色器(Geometry Shader)，几何着色器的输入是一个图元（如点或三角形）的一组顶点。几何着色器可以在顶点发送到下一着色器阶段之前对它们随意变换。然而，几何着色器最有趣的地方在于，它能够将（这一组）顶点变换为完全不同的图元，并且还能生成比原来更多的顶点。 用于传递的接口块： in gl_Vertex { vec4 gl_Position; float gl_PointSize; floa
QT中学习Opengl---（QOpenGLShaderProgram简化的使用）
比卡丘不皮的博客
02-07 3473
前言： 本文的代码是 LearnOpenGL 中对应代码，这里提供学习，大家喜欢的可去官方网站去看看: LearnOpenGL-CNhttps://learnopengl-cn.readthedocs.io/zh/latest/本章是简化使用shader的使用，让代码更加简单。 最初着色器写法 unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertexShader,1,&am
dct.rar_DCT变换_ccs实现dct变换_dct in c
09-24
该压缩包中的dct.txt文件可能包含了DCT变换的C语言实现代码，或者是关于如何在CCS中设置和编译DCT程序的说明。通过阅读这个文件，我们可以深入理解DCT的具体实现细节，包括函数定义、数据结构以及算法流程。 总之，...
基于DCT变换实现的图像数字编码
04-25
### 基于DCT变换实现的图像数字编码 #### 一、引言 随着信息技术的发展，图像处理技术在各个领域发挥着越来越重要的作用。在众多图像处理技术中，基于离散余弦变换（Discrete Cosine Transform, DCT）的图像编码...
matlab实现彩色图像DCT变换
01-12
本话题将深入探讨如何在MATLAB环境下实现彩色图像的DCT变换。MATLAB是一个强大的数值计算软件，拥有丰富的图像处理函数库，非常适合进行此类操作。 一、DCT基本概念 DCT是一种线性正交变换，能够将图像数据从空间域...
基于FPGA的DCT变换verilog设计+word版论文。
05-14
首先对整数DCT变换常见快速算法进行了分析，得出了基于类DCT矩阵进行变换的DCT变换较其它的快速算法更适合硬件实现，并利用Verilog HDL硬件描述语言开发了RTL级代码，并进行了功能仿真，仿真结果证实了设计的正确性...
IDCT变换(JAVA)
tina的博客
06-04 944
IDCT变换(JAVA)主要代码：public static double[][] inverseDCTconvertion(double[][] Fp) { // IDCT int sizeX = Fp.length; int sizeY = Fp[0].length; double[][] fp = new double[
光照贴图
linuxheik的专栏
10-17 1712
光照贴图 原文 Lighting maps 作者 JoeyDeVries 翻译 Meow J 校对 暂未校对 在上一节中，我们讨论了让每个物体都拥有自己独特的材质从而对光照做出不同的反应的方法。这样子能够很容易在一个光照的场景中给每个物体一个独特的外观，但是这仍不能对一个物体的视觉输出提供
DCT算法的原理和优化
热门推荐
qq_20613513的博客
12-07 5万+
未经博主允许，禁止转载! 离散余弦变换（DCT for Discrete Cosine Transform）是与傅里叶变换相关的一种变换，它与离散傅里叶变换类似，但是只使用实数。 这种变化经常被信号处理和图像处理使用，用于对信号和图像（包括静止图像和运动图像）进行有损压缩。在压缩算法中，现将输入图像划分为8*8或16*16的图像块，对每个图像块作DCT变换；然后舍弃高频的系数，并对余下...
OpenGL光照之光照贴图
最新发布
一个小菜鸡的学习之路
06-11 1358
每个物体都拥有自己独特的材质从而对光照做出不同的反应的方法。这样子能够很容易在一个光照的场景中给每个物体一个独特的外观，但是这仍不能对一个物体的视觉输出提供足够多的灵活性。我们将整个物体的材质定义为一个整体，但现实世界中的物体通常并不只包含有一种材质，而是由多种材质所组成。想想一辆汽车：它的外壳非常有光泽，车窗会部分反射周围的环境，轮胎不会那么有光泽，所以它没有镜面高光，轮毂非常闪亮（如果你洗车了的话）。
OpenGL如何处理多个纹理
AplusX
06-20 1338
在主程序中我们先设置3个采样器名称 pbrShader.use(); pbrShader.setInt("irradianceMap", 0); pbrShader.setInt("prefilterMap", 1); pbrShader.setInt("brdfLUT", 2); 其中setint是封装函数： void setInt(const std::string &name, int value) const { g
std::ifstream vShaderfile & vShaderfile.ifstream.exceptions(std::ifstream::badbit)
D20152107的博客
10-12 1538
一、利用“fstream”ifstream类打开文件，“string”stringstream类读入流，写入string类 二、try{}catch(){}检测异常 // 1. Retrieve the vertex/fragment source code from filePath std::string vertexCode; std::stri
二维DCT变换的实现
【黑键】
11-01 5121
DCT原理参考离散余弦变换原理与应用 JPEG压缩原理 JPEG压缩原理与DCT离散变换 JPEG图像压缩算法流程详解JPEG压缩算法流程二维DCT变换实现代码#include <iostream> #include <memory.h> #include <stdio.h> #include <math.h> #include <time.h> #include <iomanip> usin
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值