头歌计算机图形学实验（图形几何变换和模型观察和视口变换）

已于 2023-10-27 23:06:25 修改
阅读量1k 收藏 6
点赞数 5
分类专栏： 头歌计算机图形学实验 文章标签： c++ 算法 计算机视觉
于 2023-10-23 10:41:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanlepeng/article/details/133984295
版权

1. 平移、缩放、旋转正方体

#include <vector>
#include <cmath>
#include <algorithm>
#include <iostream>
#include "model.h"
#include "geometry.h"
#include "pngimage.h"

using namespace std;
const double PI = acos(-1.0);

void line(Vec3i p0, Vec3i p1, PNGImage  &image, PNGColor color)
{
	bool steep = false;
	if (std::abs(p0.x - p1.x) < std::abs(p0.y - p1.y))
	{
		std::swap(p0.x, p0.y);
		std::swap(p1.x, p1.y);
		steep = true;
	}
	if (p0.x > p1.x)
	{
		std::swap(p0.x, p1.x);
		std::swap(p0.y, p1.y);
	}

	int dx = p1.x - p0.x;
	int dy = std::abs(p1.y - p0.y);

	int y = p0.y;
	int d = -dx;
	for (int x = p0.x; x <= p1.x; x++)
	{
		if (steep)
			image.set(y, x, color);
		else
			image.set(x, y, color);

		d = d + 2 * dy;
		if (d > 0)
		{
			y += (p1.y > p0.y ? 1 : -1);
			d = d - 2 * dx;
		}
	}
}

Matrix viewport(int x, int y, int w, int h, int depth) {
	Matrix m = Matrix::identity(4);
	m[0][3] = x + w / 2.f;
	m[1][3] = y + h / 2.f;
	m[2][3] = depth / 2.f;

	m[0][0] = w / 2.f;
	m[1][1] = h / 2.f;
	m[2][2] = depth / 2.f;
	return m;
}

Matrix translation(Vec3f v) {
	Matrix Tr = Matrix::identity(4);
    // Please add the code here
    /********** Begin ********/

Tr[0][3] = v[0];
    Tr[1][3] = v[1]; 
    Tr[2][3] = v[2];
    /********** End *********/
	return Tr;
}

Matrix scale(float factorX, float factorY, float factorZ)
{
	Matrix Z = Matrix::identity(4);
    /********** Begin ********/

 Z[0][0] = factorX;
    Z[1][1] = factorY;
    Z[2][2] = factorZ;
    /********** End *********/
	return Z;
}

Matrix rotation_x(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);
	Matrix R = Matrix::identity(4);
    /********** Begin ********/
R[1][1] = cosangle;
  R[1][2] = -sinangle;
  R[2][1] = sinangle;
  R[2][2] = cosangle;

    /********** End *********/
	return R;
}

Matrix rotation_y(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);

	Matrix R = Matrix::identity(4);
    /********** Begin ********/

   R[0][0] = cosangle;
   R[0][2] = sinangle;
    R[2][0] = -sinangle;
   R[2][2] = cosangle;
    /********** End *********/
	return R;
}

Matrix rotation_z(float angle) {
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);

	Matrix R = Matrix::identity(4);
    /********** Begin ********/
    R[0][0] = cosangle; 
    R[0][1] = -sinangle;
    R[1][0] = sinangle;
    R[1][1] = cosangle;

    /********** End *********/
	return R;
}

int main(int argc, char** argv)
{
	const PNGColor white = PNGColor(255, 255, 255, 255);
	const PNGColor black = PNGColor(0, 0, 0, 255);
	const PNGColor red = PNGColor(255, 0, 0, 255);
	const PNGColor green = PNGColor(0, 255, 0, 255);
	const PNGColor blue = PNGColor(0, 0, 255, 255);
	const PNGColor yellow = PNGColor(255, 255, 0, 255);

	Model *model = NULL;
	const int width = 500;
	const int height = 500;
	const int depth = 255;

	//generate some image
	PNGImage image(width, height, PNGImage::RGBA); //Error when RGB because lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size() in encode
	image.init(black);
	model = new Model("../step3/cube.obj");
	Matrix VP = viewport(width / 4, width / 4, width / 2, height / 2, depth);

	{ // draw the axes
		Vec3f x(1.f, 0.f, 0.f), y(0.f, 1.f, 0.f), o(0.f, 0.f, 0.f);
		o = VP*o;
		x = VP*x;
		y = VP*y;
		line(o, x, image, red);
		line(o, y, image, green);
	}

	for (int i = 0; i < model->nfaces(); i++) {
		std::vector<int> face = model->face(i);
		for (int j = 0; j < (int)face.size(); j++) {
			Vec3f wp0 = model->vert(face[j]);
			Vec3f wp1 = model->vert(face[(j + 1) % face.size()]);
       
			// draw the original model
			Vec3f op0 = VP*wp0;
			Vec3f op1 = VP*wp1;
			line(op0, op1, image, white);

			// draw the translated model
            // Please add the code here
            /********** Begin ********/
			Matrix T = translation(Vec3f( 0.5 ,0.5  ,0.5   ));
            /********** End *********/
			Vec3f tp0 = VP*T*wp0;
			Vec3f tp1 = VP*T*wp1;
			line(tp0, tp1, image, red);

			// draw the scaled model
            // Please add the code here
            /********** Begin ********/            
			Matrix S = scale( 0.5 , 0.5 , 0.5 );
            /********** End *********/
			Vec3f sp0 = VP*S*wp0;
			Vec3f sp1 = VP*S*wp1;
			line(sp0, sp1, image, green);

			// draw the rotated model
            // Please add the code here
            /********** Begin ********/   
			Matrix R = rotation_z(45 );
            /********** End *********/
			Vec3f rp0 = VP*R*wp0;
			Vec3f rp1 = VP*R*wp1;
			line(rp0, rp1, image, yellow);
		}
	}
	image.flip_vertically(); // i want to have the origin at the left bottom corner of the image
	image.write_png_file("../img_step3/test.png");
	delete model;
	return 0;
}

2. 图形的平移与缩放

#include <vector>
#include <cmath>
#include <algorithm>
#include <iostream>
#include "model.h"
#include "geometry.h"
#include "pngimage.h"

using namespace std;
const double PI = acos(-1.0);

void line(Vec3i p0, Vec3i p1, PNGImage  &image, PNGColor color)
{
	bool steep = false;
	if (std::abs(p0.x - p1.x) < std::abs(p0.y - p1.y))
	{
		std::swap(p0.x, p0.y);
		std::swap(p1.x, p1.y);
		steep = true;
	}
	if (p0.x > p1.x)
	{
		std::swap(p0.x, p1.x);
		std::swap(p0.y, p1.y);
	}

	int dx = p1.x - p0.x;
	int dy = std::abs(p1.y - p0.y);

	int y = p0.y;
	int d = -dx;
	for (int x = p0.x; x <= p1.x; x++)
	{
		if (steep)
			image.set(y, x, color);
		else
			image.set(x, y, color);

		d = d + 2 * dy;
		if (d > 0)
		{
			y += (p1.y > p0.y ? 1 : -1);
			d = d - 2 * dx;
		}
	}
}

Matrix viewport(int x, int y, int w, int h, int depth) {
	Matrix m = Matrix::identity(4);
	m[0][3] = x + w / 2.f;
	m[1][3] = y + h / 2.f;
	m[2][3] = depth / 2.f;

	m[0][0] = w / 2.f;
	m[1][1] = h / 2.f;
	m[2][2] = depth / 2.f;
	return m;
}

Matrix translation(Vec3f v) {
	Matrix Tr = Matrix::identity(4);
	Tr[0][3] = v.x;
	Tr[1][3] = v.y;
	Tr[2][3] = v.z;
	return Tr;
}

Matrix scale(float factorX, float factorY, float factorZ)
{
	Matrix Z = Matrix::identity(4);
	Z[0][0] = factorX;
	Z[1][1] = factorY;
	Z[2][2] = factorZ;
	return Z;
}

Matrix rotation_x(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);

	Matrix R = Matrix::identity(4);
	R[1][1] = R[2][2] = cosangle;
	R[1][2] = -sinangle;
	R[2][1] = sinangle;
	return R;
}

Matrix rotation_y(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);

	Matrix R = Matrix::identity(4);
	R[0][0] = R[2][2] = cosangle;
	R[0][2] = sinangle;
	R[2][0] = -sinangle;
	return R;
}

Matrix rotation_z(float angle) {
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);

	Matrix R = Matrix::identity(4);
	R[0][0] = R[1][1] = cosangle;
	R[0][1] = -sinangle;
	R[1][0] = sinangle;
	return R;
}

int main(int argc, char** argv)
{
    const PNGColor white = PNGColor(255, 255, 255, 255);
    const PNGColor black = PNGColor(0, 0, 0, 255);
    const PNGColor red = PNGColor(255, 0, 0, 255);
    const PNGColor green = PNGColor(0, 255, 0, 255);
    const PNGColor blue = PNGColor(0, 0, 255, 255);
    const PNGColor yellow = PNGColor(255, 255, 0, 255);
    Model *model = NULL;
    const int width = 500;
    const int height = 500;
    const int depth = 255;
    //generate some image
    PNGImage image(width, height, PNGImage::RGBA); //Error when RGB because lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size() in encode
    image.init(black);
    model = new Model("cube.obj");
    Matrix VP = viewport(width / 4, width / 4, width / 2, height / 2, depth);
    for (int i = 0; i < model->nfaces(); i++)
    {
        std::vector<int> face = model->face(i);
        for (int j = 0; j < (int)face.size(); j++)
        {
            Vec3f wp0 = model->vert(face[j]);
            Vec3f wp1 = model->vert(face[(j + 1) % face.size()]);
            Matrix S0 = scale(0.5, 0.5, 0.5);
            Vec3f swp0 = S0 * wp0;
            Vec3f swp1 = S0 * wp1;
            // draw the model after scaled
            Vec3f op0 = VP * swp0;
            Vec3f op1 = VP * swp1;
            line(op0, op1, image, white);
            Matrix T = translation(Vec3f(0.5, 0.5, 0.5));
            Matrix S = scale(0.5, 0.5, 0.5);
            // scaled then translated
            Vec3f tsp0 = VP*T*S*swp0;
            Vec3f tsp1 = VP*T*S*swp1;
            line(tsp0, tsp1, image, red);
            // translated then scaled
            Vec3f stp0 = VP*S*T*swp0;
            Vec3f stp1 = VP*S*T*swp1;
            line(stp0, stp1, image, green);
        }
    }
    image.flip_vertically(); // i want to have the origin at the left bottom corner of the image
    image.write_png_file("../img_step2/test.png");
    delete model;
    return 0;
}

3.图形的平移与旋转

#include <vector>
#include <cmath>
#include <algorithm>
#include <iostream>
#include "model.h"
#include "geometry.h"
#include "pngimage.h"

using namespace std;
const double PI = acos(-1.0);

void line(Vec3i p0, Vec3i p1, PNGImage  &image, PNGColor color)
{
	bool steep = false;
	if (std::abs(p0.x - p1.x) < std::abs(p0.y - p1.y))
	{
		std::swap(p0.x, p0.y);
		std::swap(p1.x, p1.y);
		steep = true;
	}
	if (p0.x > p1.x)
	{
		std::swap(p0.x, p1.x);
		std::swap(p0.y, p1.y);
	}

	int dx = p1.x - p0.x;
	int dy = std::abs(p1.y - p0.y);

	int y = p0.y;
	int d = -dx;
	for (int x = p0.x; x <= p1.x; x++)
	{
		if (steep)
			image.set(y, x, color);
		else
			image.set(x, y, color);

		d = d + 2 * dy;
		if (d > 0)
		{
			y += (p1.y > p0.y ? 1 : -1);
			d = d - 2 * dx;
		}
	}
}

Matrix viewport(int x, int y, int w, int h, int depth) {
	Matrix m = Matrix::identity(4);
	m[0][3] = x + w / 2.f;
	m[1][3] = y + h / 2.f;
	m[2][3] = depth / 2.f;

	m[0][0] = w / 2.f;
	m[1][1] = h / 2.f;
	m[2][2] = depth / 2.f;
	return m;
}

Matrix translation(Vec3f v) {
	Matrix Tr = Matrix::identity(4);
	Tr[0][3] = v.x;
	Tr[1][3] = v.y;
	Tr[2][3] = v.z;
	return Tr;
}

Matrix scale(float factorX, float factorY, float factorZ)
{
	Matrix Z = Matrix::identity(4);
	Z[0][0] = factorX;
	Z[1][1] = factorY;
	Z[2][2] = factorZ;
	return Z;
}

Matrix rotation_x(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);

	Matrix R = Matrix::identity(4);
	R[1][1] = R[2][2] = cosangle;
	R[1][2] = -sinangle;
	R[2][1] = sinangle;
	return R;
}

Matrix rotation_y(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);

	Matrix R = Matrix::identity(4);
	R[0][0] = R[2][2] = cosangle;
	R[0][2] = sinangle;
	R[2][0] = -sinangle;
	return R;
}

Matrix rotation_z(float angle) {
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);

	Matrix R = Matrix::identity(4);
	R[0][0] = R[1][1] = cosangle;
	R[0][1] = -sinangle;
	R[1][0] = sinangle;
	return R;
}

int main(int argc, char** argv)
{
	const PNGColor white = PNGColor(255, 255, 255, 255);
    const PNGColor black = PNGColor(0, 0, 0, 255);
    const PNGColor red = PNGColor(255, 0, 0, 255);
    const PNGColor green = PNGColor(0, 255, 0, 255);
    const PNGColor blue = PNGColor(0, 0, 255, 255);
    const PNGColor yellow = PNGColor(255, 255, 0, 255);
    Model *model = NULL;
    const int width = 500;
    const int height = 500;
    const int depth = 255;
    //generate some image
    PNGImage image(width, height, PNGImage::RGBA); //Error when RGB because lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size() in encode
    image.init(black);
    model = new Model("cube.obj");
    Matrix VP = viewport(width / 4, width / 4, width / 2, height / 2, depth);
    for (int i = 0; i < model->nfaces(); i++)
    {
        std::vector<int> face = model->face(i);
        for (int j = 0; j < (int)face.size(); j++)
        {
            Vec3f wp0 = model->vert(face[j]);
            Vec3f wp1 = model->vert(face[(j + 1) % face.size()]);
            Matrix S0 = scale(0.5, 0.5, 0.5);
            Vec3f swp0 = S0 * wp0;
            Vec3f swp1 = S0 * wp1;
            // draw the model after scaled
            Vec3f op0 = VP * swp0;
            Vec3f op1 = VP * swp1;
            line(op0, op1, image, white);
            Matrix T = translation(Vec3f(0.5, 0.5, 0.5));
            Matrix S = scale(0.5, 0.5, 0.5);
            Matrix R = rotation_z(45);
            // translated then rotated
            Vec3f rtp0 = VP*R*T*swp0;
            Vec3f rtp1 = VP*R*T*swp1;
            line(rtp0, rtp1, image, green);
            // rotated then translated
            Vec3f trp0 = VP*T*R*swp0;
            Vec3f trp1 = VP*T*R*swp1;
            line(trp0, trp1, image, red);
        }
    }
    image.flip_vertically(); // i want to have the origin at the left bottom corner of the image
    image.write_png_file("../img_step1/test.png");
    delete model;
    return 0;
}

4图形的旋转与缩放

#include <vector>
#include <cmath>
#include <algorithm>
#include <iostream>
#include "model.h"
#include "geometry.h"
#include "pngimage.h"

using namespace std;
const double PI = acos(-1.0);

void line(Vec3i p0, Vec3i p1, PNGImage  &image, PNGColor color)
{
	bool steep = false;
	if (std::abs(p0.x - p1.x) < std::abs(p0.y - p1.y))
	{
		std::swap(p0.x, p0.y);
		std::swap(p1.x, p1.y);
		steep = true;
	}
	if (p0.x > p1.x)
	{
		std::swap(p0.x, p1.x);
		std::swap(p0.y, p1.y);
	}

	int dx = p1.x - p0.x;
	int dy = std::abs(p1.y - p0.y);

	int y = p0.y;
	int d = -dx;
	for (int x = p0.x; x <= p1.x; x++)
	{
		if (steep)
			image.set(y, x, color);
		else
			image.set(x, y, color);

		d = d + 2 * dy;
		if (d > 0)
		{
			y += (p1.y > p0.y ? 1 : -1);
			d = d - 2 * dx;
		}
	}
}

Matrix viewport(int x, int y, int w, int h, int depth) {
	Matrix m = Matrix::identity(4);
	m[0][3] = x + w / 2.f;
	m[1][3] = y + h / 2.f;
	m[2][3] = depth / 2.f;

	m[0][0] = w / 2.f;
	m[1][1] = h / 2.f;
	m[2][2] = depth / 2.f;
	return m;
}

Matrix translation(Vec3f v) {
	Matrix Tr = Matrix::identity(4);
	Tr[0][3] = v.x;
	Tr[1][3] = v.y;
	Tr[2][3] = v.z;
	return Tr;
}

Matrix scale(float factorX, float factorY, float factorZ)
{
	Matrix Z = Matrix::identity(4);
	Z[0][0] = factorX;
	Z[1][1] = factorY;
	Z[2][2] = factorZ;
	return Z;
}

Matrix rotation_x(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);

	Matrix R = Matrix::identity(4);
	R[1][1] = R[2][2] = cosangle;
	R[1][2] = -sinangle;
	R[2][1] = sinangle;
	return R;
}

Matrix rotation_y(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);

	Matrix R = Matrix::identity(4);
	R[0][0] = R[2][2] = cosangle;
	R[0][2] = sinangle;
	R[2][0] = -sinangle;
	return R;
}

Matrix rotation_z(float angle) {
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);

	Matrix R = Matrix::identity(4);
	R[0][0] = R[1][1] = cosangle;
	R[0][1] = -sinangle;
	R[1][0] = sinangle;
	return R;
}

int main(int argc, char** argv)
{
    const PNGColor white = PNGColor(255, 255, 255, 255);
    const PNGColor black = PNGColor(0, 0, 0, 255);
    const PNGColor red = PNGColor(255, 0, 0, 255);
    const PNGColor green = PNGColor(0, 255, 0, 255);
    const PNGColor blue = PNGColor(0, 0, 255, 255);
    const PNGColor yellow = PNGColor(255, 255, 0, 255);
    Model *model = NULL;
    const int width = 500;
    const int height = 500;
    const int depth = 255;
    //generate some image
    PNGImage image(width, height, PNGImage::RGBA); //Error when RGB because lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size() in encode
    image.init(black);
    model = new Model("cube.obj");
    Matrix VP = viewport(width / 4, width / 4, width / 2, height / 2, depth);
    for (int i = 0; i < model->nfaces(); i++)
    {
        std::vector<int> face = model->face(i);
        for (int j = 0; j < (int)face.size(); j++)
        {
            Vec3f wp0 = model->vert(face[j]);
            Vec3f wp1 = model->vert(face[(j + 1) % face.size()]);
            Matrix S0 = scale(0.5, 0.5, 0.5);
            Vec3f swp0 = S0 * wp0;
            Vec3f swp1 = S0 * wp1;
            // draw the model after scaled
            Vec3f op0 = VP * swp0;
            Vec3f op1 = VP * swp1;
            line(op0, op1, image, white);
            Matrix T = translation(Vec3f(0.5, 0.5, 0.5));
            Matrix S = scale(1, 0.5, 0.5);
            Matrix R = rotation_z(45);
            // scaled then rotated
            Vec3f rsp0 = VP*R*S*swp0;
            Vec3f rsp1 = VP*R*S*swp1;
            line(rsp0, rsp1, image, green);
            // rotated then scaled
            Vec3f srp0 = VP*S*R*swp0;
            Vec3f srp1 = VP*S*R*swp1;
            line(srp0, srp1, image, red);
        }
    }
    image.flip_vertically(); // i want to have the origin at the left bottom corner of the image
    image.write_png_file("../img_step4/test.png");
    delete model;
    return 0;
}

5. 绘制三菱形状

#include <vector>
#include <cmath>
#include <algorithm>
#include <iostream>
#include "model.h"
#include "geometry.h"
#include "pngimage.h"

using namespace std;
const double PI = acos(-1.0);

void line(Vec3i p0, Vec3i p1, PNGImage  &image, PNGColor color)
{
	bool steep = false;
	if (std::abs(p0.x - p1.x) < std::abs(p0.y - p1.y))
	{
		std::swap(p0.x, p0.y);
		std::swap(p1.x, p1.y);
		steep = true;
	}
	if (p0.x > p1.x)
	{
		std::swap(p0.x, p1.x);
		std::swap(p0.y, p1.y);
	}

	int dx = p1.x - p0.x;
	int dy = std::abs(p1.y - p0.y);

	int y = p0.y;
	int d = -dx;
	for (int x = p0.x; x <= p1.x; x++)
	{
		if (steep)
			image.set(y, x, color);
		else
			image.set(x, y, color);

		d = d + 2 * dy;
		if (d > 0)
		{
			y += (p1.y > p0.y ? 1 : -1);
			d = d - 2 * dx;
		}
	}
}

Matrix viewport(int x, int y, int w, int h, int depth) {
	Matrix m = Matrix::identity(4);
	m[0][3] = x + w / 2.f;
	m[1][3] = y + h / 2.f;
	m[2][3] = depth / 2.f;

	m[0][0] = w / 2.f;
	m[1][1] = h / 2.f;
	m[2][2] = depth / 2.f;
	return m;
}

Matrix translation(Vec3f v) {
	Matrix Tr = Matrix::identity(4);
	Tr[0][3] = v.x;
	Tr[1][3] = v.y;
	Tr[2][3] = v.z;
	return Tr;
}

Matrix scale(float factorX, float factorY, float factorZ)
{
	Matrix Z = Matrix::identity(4);
	Z[0][0] = factorX;
	Z[1][1] = factorY;
	Z[2][2] = factorZ;
	return Z;
}

Matrix rotation_x(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);

	Matrix R = Matrix::identity(4);
	R[1][1] = R[2][2] = cosangle;
	R[1][2] = -sinangle;
	R[2][1] = sinangle;
	return R;
}

Matrix rotation_y(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);

	Matrix R = Matrix::identity(4);
	R[0][0] = R[2][2] = cosangle;
	R[0][2] = sinangle;
	R[2][0] = -sinangle;
	return R;
}

Matrix rotation_z(float angle) {
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);

	Matrix R = Matrix::identity(4);
	R[0][0] = R[1][1] = cosangle;
	R[0][1] = -sinangle;
	R[1][0] = sinangle;
	return R;
}

int main(int argc, char** argv)
{
    const PNGColor white = PNGColor(255, 255, 255, 255);
    const PNGColor black = PNGColor(0, 0, 0, 255);
    const PNGColor red = PNGColor(255, 0, 0, 255);
    const PNGColor green = PNGColor(0, 255, 0, 255);
    const PNGColor blue = PNGColor(0, 0, 255, 255);
    const PNGColor yellow = PNGColor(255, 255, 0, 255);
    Model *model = NULL;
    const int width = 800;
    const int height = 800;
    const int depth = 255;
    //generate some image
    PNGImage image(width, height, PNGImage::RGBA); //Error when RGB because lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size() in encode
    image.init(black);
    model = new Model("cube.obj");
    Matrix VP = viewport(width / 4, width / 4, width / 2, height / 2, depth);
    for (int i = 0; i < model->nfaces(); i++)
    {
        std::vector<int> face = model->face(i);
        for (int j = 0; j < (int)face.size(); j++)
        {
            Vec3f wp0 = model->vert(face[j]);
            Vec3f wp1 = model->vert(face[(j + 1) % face.size()]);
            Matrix S0 = scale(0.5, 0.5, 0.5);
            Vec3f swp0 = S0 * wp0;
            Vec3f swp1 = S0 * wp1;
            Matrix S = scale(1, 0.5, 0.5);
            Matrix R1 = rotation_z(45);
            Matrix T = translation(Vec3f(sqrt(2)/2, 0, 0));
            Matrix R2 = rotation_z(90);
            // 中间坚直的菱形
            Vec3f mp0 = VP*R2*T*S*R1*swp0;
            Vec3f mp1 = VP*R2*T*S*R1*swp1;
            line(mp0, mp1, image, red);
            // 左边的菱形
            Matrix R3 = rotation_z(120);
            Vec3f lp0 = VP * R3* R2*T*S*R1*swp0;
            Vec3f lp1 = VP * R3* R2*T*S*R1*swp1;
            line(lp0, lp1, image, green);
            // 右边的菱形
            Matrix R4 = rotation_z(-120);
            Vec3f rp0 = VP * R4* R2*T*S*R1*swp0;
            Vec3f rp1 = VP * R4* R2*T*S*R1*swp1;
            line(rp0, rp1, image, yellow);
        }
    }
    image.flip_vertically(); // i want to have the origin at the left bottom corner of the image
    image.write_png_file("../img_step5/test.png");
    delete model;
    return 0;
}

8视口变换

#include <vector>
#include <cmath>
#include <algorithm>
#include <iostream>
#include "model.h"
#include "geometry.h"
#include "pngimage.h"
 
using namespace std;
const double PI = acos(-1.0);
 
void line(Vec3i p0, Vec3i p1, PNGImage  &image, PNGColor color)
{
	bool steep = false;
	if (std::abs(p0.x - p1.x) < std::abs(p0.y - p1.y))
	{
		std::swap(p0.x, p0.y);
		std::swap(p1.x, p1.y);
		steep = true;
	}
	if (p0.x > p1.x)
	{
		std::swap(p0.x, p1.x);
		std::swap(p0.y, p1.y);
	}
 
	int dx = p1.x - p0.x;
	int dy = std::abs(p1.y - p0.y);
 
	int y = p0.y;
	int d = -dx;
	for (int x = p0.x; x <= p1.x; x++)
	{
		if (steep)
			image.set(y, x, color);
		else
			image.set(x, y, color);
 
		d = d + 2 * dy;
		if (d > 0)
		{
			y += (p1.y > p0.y ? 1 : -1);
			d = d - 2 * dx;
		}
	}
}
 
Matrix viewport(int x, int y, int w, int h, int depth) {
	Matrix m = Matrix::identity(4);
	// Please add the code here
    /********** Begin ********/
    m[0][0]=w/2;
    m[0][3]=x+(w/2);
    m[1][1]=h/2;
    m[1][3]=y+h/2;
    m[2][2]=255/2;
    m[2][3]=255/2;
    m[3][3]=1;
    
 
 
 
	/********** End **********/
	return m;
}
 
Matrix lookat(Vec3f eye, Vec3f center, Vec3f up) {
	Vec3f z = (eye - center).normalize();
	Vec3f x = (up^z).normalize();
	Vec3f y = (z^x).normalize();
	Matrix res = Matrix::identity(4);
	for (int i = 0; i < 3; i++) {
		res[0][i] = x[i];
		res[1][i] = y[i];
		res[2][i] = z[i];
		res[i][3] = -center[i];
	}
	return res;
}
 
Matrix translation(Vec3f v) {
	Matrix Tr = Matrix::identity(4);
	Tr[0][3] = v.x;
	Tr[1][3] = v.y;
	Tr[2][3] = v.z;
	return Tr;
}
 
Matrix scale(float factorX, float factorY, float factorZ)
{
	Matrix Z = Matrix::identity(4);
	Z[0][0] = factorX;
	Z[1][1] = factorY;
	Z[2][2] = factorZ;
	return Z;
}
 
Matrix rotation_x(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);
 
	Matrix R = Matrix::identity(4);
	R[1][1] = R[2][2] = cosangle;
	R[1][2] = -sinangle;
	R[2][1] = sinangle;
	return R;
}
 
Matrix rotation_y(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);
 
	Matrix R = Matrix::identity(4);
	R[0][0] = R[2][2] = cosangle;
	R[0][2] = sinangle;
	R[2][0] = -sinangle;
	return R;
}
 
Matrix rotation_z(float angle) {
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);
 
	Matrix R = Matrix::identity(4);
	R[0][0] = R[1][1] = cosangle;
	R[0][1] = -sinangle;
	R[1][0] = sinangle;
	return R;
}
 
int main(int argc, char** argv)
{
	const PNGColor white = PNGColor(255, 255, 255, 255);
	const PNGColor black = PNGColor(0, 0, 0, 255);
	const PNGColor red = PNGColor(255, 0, 0, 255);
	const PNGColor green = PNGColor(0, 255, 0, 255);
	const PNGColor blue = PNGColor(0, 0, 255, 255);
	const PNGColor yellow = PNGColor(255, 255, 0, 255);
 
	Model *model = NULL;
 
	Vec3f eye(0, 1.5, 4);
	Vec3f center(0, 0, 0);
 
	Matrix ModelView = lookat(eye, center, Vec3f(0, 1, 0));
	Matrix Projection = Matrix::projection(eye, center);
 
 
	const int width = 500;
	const int height = 500;
	const int depth = 255;
	// Please add the code here
    /********** Begin ********/
	Matrix ViewPort = viewport(width/4,width/4,width/2,height/2,depth);
 
	/********** End **********/
 
	//generate some image
	PNGImage image(width, height, PNGImage::RGBA); //Error when RGB because lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size() in encode
	image.init(black);
	model = new Model("cube.obj");
 
	for (int i = 0; i < model->nfaces(); i++)
	{
		std::vector<int> face = model->face(i);
		for (int j = 0; j < (int)face.size(); j++)
		{
			Vec3f wp0 = model->vert(face[j]);
			Vec3f wp1 = model->vert(face[(j + 1) % face.size()]);
 
			Matrix S0 = scale(0.5, 0.5, 0.5);
			Vec3f swp0 = S0 * wp0;
			Vec3f swp1 = S0 * wp1;
 
			Vec3f sp0 = ViewPort*Projection*ModelView*swp0;
			Vec3f sp1 = ViewPort*Projection*ModelView*swp1;
			line(sp0, sp1, image, red);
		}
	}
 
	image.flip_vertically(); // i want to have the origin at the left bottom corner of the image
	image.write_png_file("../img_step3/test.png");
	delete model;
	return 0;
}

7. 观察变换

#include <vector>
#include <cmath>
#include <algorithm>
#include <iostream>
#include "model.h"
#include "geometry.h"
#include "pngimage.h"
 
using namespace std;
const double PI = acos(-1.0);
 
void line(Vec3i p0, Vec3i p1, PNGImage  &image, PNGColor color)
{
	bool steep = false;
	if (std::abs(p0.x - p1.x) < std::abs(p0.y - p1.y))
	{
		std::swap(p0.x, p0.y);
		std::swap(p1.x, p1.y);
		steep = true;
	}
	if (p0.x > p1.x)
	{
		std::swap(p0.x, p1.x);
		std::swap(p0.y, p1.y);
	}
 
	int dx = p1.x - p0.x;
	int dy = std::abs(p1.y - p0.y);
 
	int y = p0.y;
	int d = -dx;
	for (int x = p0.x; x <= p1.x; x++)
	{
		if (steep)
			image.set(y, x, color);
		else
			image.set(x, y, color);
 
		d = d + 2 * dy;
		if (d > 0)
		{
			y += (p1.y > p0.y ? 1 : -1);
			d = d - 2 * dx;
		}
	}
}
 
 
Matrix lookat(Vec3f eye, Vec3f center, Vec3f up) {
    Matrix res = Matrix::identity(4);
	// Please add the code here
    /********** Begin ********/
    Vec3f z = (eye - center).normalize();
	Vec3f x = (up^z).normalize();
	Vec3f y = (z^x).normalize();
	for (int i = 0; i < 3; i++) {
		res[0][i] = x[i];
		res[1][i] = y[i];
		res[2][i] = z[i];
		res[i][3] = -center[i];
	}
 
 
	/********** End ********/
	return res;
}
 
Matrix translation(Vec3f v) {
	Matrix Tr = Matrix::identity(4);
	Tr[0][3] = v.x;
	Tr[1][3] = v.y;
	Tr[2][3] = v.z;
	return Tr;
}
 
Matrix scale(float factorX, float factorY, float factorZ)
{
	Matrix Z = Matrix::identity(4);
	Z[0][0] = factorX;
	Z[1][1] = factorY;
	Z[2][2] = factorZ;
	return Z;
}
 
Matrix rotation_x(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);
 
	Matrix R = Matrix::identity(4);
	R[1][1] = R[2][2] = cosangle;
	R[1][2] = -sinangle;
	R[2][1] = sinangle;
	return R;
}
 
Matrix rotation_y(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);
 
	Matrix R = Matrix::identity(4);
	R[0][0] = R[2][2] = cosangle;
	R[0][2] = sinangle;
	R[2][0] = -sinangle;
	return R;
}
 
Matrix rotation_z(float angle) {
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);
 
	Matrix R = Matrix::identity(4);
	R[0][0] = R[1][1] = cosangle;
	R[0][1] = -sinangle;
	R[1][0] = sinangle;
	return R;
}
 
int main(int argc, char** argv)
{
	const PNGColor white = PNGColor(255, 255, 255, 255);
	const PNGColor black = PNGColor(0, 0, 0, 255);
	const PNGColor red = PNGColor(255, 0, 0, 255);
	const PNGColor green = PNGColor(0, 255, 0, 255);
	const PNGColor blue = PNGColor(0, 0, 255, 255);
	const PNGColor yellow = PNGColor(255, 255, 0, 255);
 
	Model *model = NULL;
	const int width = 500;
	const int height = 500;
	const int depth = 255;
 
	// Please add the code here
    /********** Begin ********/
    Vec3f eye(0 ,1.5  ,4  );
	Vec3f center( 0, 0 ,0  );
	Matrix ModelView = lookat(eye, center, Vec3f( 0, 1 ,0  ));
	// Please add the code here
    /********** Begin ********/
 
	Matrix Projection = Matrix::projection(eye, center);
	Matrix ViewPort = Matrix::viewport(width / 4, width / 4, width / 2, height / 2, depth);
 
 
	//generate some image
	PNGImage image(width, height, PNGImage::RGBA); //Error when RGB because lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size() in encode
	image.init(black);
	model = new Model("cube.obj");
 
	for (int i = 0; i < model->nfaces(); i++)
	{
		std::vector<int> face = model->face(i);
		for (int j = 0; j < (int)face.size(); j++)
		{
			Vec3f wp0 = model->vert(face[j]);
			Vec3f wp1 = model->vert(face[(j + 1) % face.size()]);
 
			Matrix S0 = scale(0.5, 0.5, 0.5);
			Vec3f swp0 = S0 * wp0;
			Vec3f swp1 = S0 * wp1;
 
			Vec3f sp0 = ViewPort*Projection*ModelView*swp0;
			Vec3f sp1 = ViewPort*Projection*ModelView*swp1;
			line(sp0, sp1, image, red);
		}
	}
 
	image.flip_vertically(); // i want to have the origin at the left bottom corner of the image
	image.write_png_file("../img_step2/test.png");
	delete model;
	return 0;
}

6 模型变换

#include <vector>
#include <cmath>
#include <algorithm>
#include <iostream>
#include "model.h"
#include "geometry.h"
#include "pngimage.h"
 
using namespace std;
const double PI = acos(-1.0);
 
void line(Vec3i p0, Vec3i p1, PNGImage  &image, PNGColor color)
{
	bool steep = false;
	if (std::abs(p0.x - p1.x) < std::abs(p0.y - p1.y))
	{
		std::swap(p0.x, p0.y);
		std::swap(p1.x, p1.y);
		steep = true;
	}
	if (p0.x > p1.x)
	{
		std::swap(p0.x, p1.x);
		std::swap(p0.y, p1.y);
	}
 
	int dx = p1.x - p0.x;
	int dy = std::abs(p1.y - p0.y);
 
	int y = p0.y;
	int d = -dx;
	for (int x = p0.x; x <= p1.x; x++)
	{
		if (steep)
			image.set(y, x, color);
		else
			image.set(x, y, color);
 
		d = d + 2 * dy;
		if (d > 0)
		{
			y += (p1.y > p0.y ? 1 : -1);
			d = d - 2 * dx;
		}
	}
}
 
Matrix translation(Vec3f v) {//平移
	Matrix Tr = Matrix::identity(4);
	Tr[0][3] = v.x;
	Tr[1][3] = v.y;
	Tr[2][3] = v.z;
	return Tr;
}
 
Matrix scale(float factorX, float factorY, float factorZ)
{
	Matrix Z = Matrix::identity(4);
	Z[0][0] = factorX;
	Z[1][1] = factorY;
	Z[2][2] = factorZ;
	return Z;
}
 
Matrix rotation_x(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);
 
	Matrix R = Matrix::identity(4);
	R[1][1] = R[2][2] = cosangle;
	R[1][2] = -sinangle;
	R[2][1] = sinangle;
	return R;
}
 
Matrix rotation_y(float angle)
{
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);
 
	Matrix R = Matrix::identity(4);
	R[0][0] = R[2][2] = cosangle;
	R[0][2] = sinangle;
	R[2][0] = -sinangle;
	return R;
}
 
Matrix rotation_z(float angle) {
	angle = angle * PI / 180;
	float sinangle = sin(angle);
	float cosangle = cos(angle);
 
	Matrix R = Matrix::identity(4);
	R[0][0] = R[1][1] = cosangle;
	R[0][1] = -sinangle;
	R[1][0] = sinangle;
	return R;
}
 
int main(int argc, char** argv)
{
	const PNGColor white = PNGColor(255, 255, 255, 255);
	const PNGColor black = PNGColor(0, 0, 0, 255);
	const PNGColor red = PNGColor(255, 0, 0, 255);
	const PNGColor green = PNGColor(0, 255, 0, 255);
	const PNGColor blue = PNGColor(0, 0, 255, 255);
	const PNGColor yellow = PNGColor(255, 255, 0, 255);
 
	Model *model = NULL;
	const int width = 500;
	const int height = 500;
	const int depth = 255;
	Vec3f eye(0.5, 1.5, 4);
	Vec3f center(0, 0, 0);
 
	Matrix Projection = Matrix::projection(eye, center);
	Matrix ViewPort = Matrix::viewport(width / 4, width / 4, width / 2, height / 2, depth);
 
 
	//generate some image
	PNGImage image(width, height, PNGImage::RGBA); //Error when RGB because lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size() in encode
	image.init(black);
	model = new Model("cube.obj");
 
 
	for (int i = 0; i < model->nfaces(); i++)
	{
		std::vector<int> face = model->face(i);
		for (int j = 0; j < (int)face.size(); j++)
		{
			Vec3f wp0 = model->vert(face[j]);
			Vec3f wp1 = model->vert(face[(j + 1) % face.size()]);
 
			Matrix S0 = scale(0.5, 0.5, 0.5);
			Vec3f swp0 = S0 * wp0;
			Vec3f swp1 = S0 * wp1;
 
			// for comparing - draw the model after scaled 
			Vec3f op0 = ViewPort * Projection * swp0;
			Vec3f op1 = ViewPort * Projection * swp1;
			line(op0, op1, image, white);
 
			// Please add the code here
            /********** Begin ********/
 
 
            //3) 将白色立方体的顶点坐标向x轴正方向平移1.2个单位距离，然后绘制一个红色立方形
            Matrix S1 = translation(Vec3f(1.2,0.0,0.0));
 
            op0 = ViewPort * Projection *S1 * swp0;
			 op1 = ViewPort * Projection *S1 * swp1;
			line(op0, op1, image, red);
 
           
 
 
 
            // (4) 将白色立方体的顶点坐标沿y轴逆时针方向旋转30度，再向x轴负方向平移1.3个单位距离，然后绘制一个绿色正方形
        //    Matrix rotation_y(float angle)
             Matrix S3 = rotation_y(30.0);
             Matrix S4 = translation(Vec3f(-1.3,0.0,0.0));
             op0 = ViewPort * Projection *S4 *S3 * swp0;
             op1 = ViewPort * Projection *S4 *S3 * swp1;
             line(op0, op1, image,green );
            /********** End *********/
		}
	}
 
	image.flip_vertically(); // i want to have the origin at the left bottom corner of the image
	image.write_png_file("../img_step1/test.png");
	delete model;
	return 0;
}

程序员李知恩
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CG3-v2.0-图形几何变换
Junds0的博客
09-23 1723
(1) 理解几何变换基本原理, 掌握平移、旋转、缩放变换的方法; (2) 根据平移算法原理补全translation、scale、rotation_x、rotation_y和rotation_z函数; (3) 根据几何变换基本原理,将main函数中的translation、scale、rotation_z参数补充完整。 第2关：图形的平移与缩放 (1) 理解几何变换基本原理, 掌握平移和缩放变换的方法; (2) 根据几何变换基本原理,将main函数中的空白部分补充完整。 第3关：图形的平移与旋转 (1) 理
计算机图形学实验代码（全）
11-09
在这个"计算机图形学实验代码（全）"的压缩包中，我们将会深入探讨一系列与计算机图形学相关的实验，这些实验覆盖了从基础到进阶的多个主题。 首先，"OpenGL初识"部分引导我们进入OpenGL的世界。OpenGL是一个跨语言...
图像几何变换--缩放、平移、镜像、旋转
luran的博客
10-11 5896
目录一.图像几何变换基础二.平移三.缩放四.旋转五.镜像六.复合变换七.变换矩阵总结八.完整代码 一.图像几何变换基础 1.图像的几何变换是指原始图像按照需要产生大小、形状和位置的变化。 2.不改变图像的像素值，而是改变像素所在的几何位置。 3.对于原图像f(x,y)，坐标变换函数 4.唯一确定了几何变换： g(x,y)是目标图像。 5.图像是矩阵，图像的几何变换用矩阵运算来实现。 6.在数字图像处理中，几何变换由两个基本操作组成： （1）坐标的空间变换； 坐标变换可由下式表示： 其中，(v,w)是
计算机图形学头歌实训平台——二维几何变换
weixin_51329675的博客
01-05 2864
计算机图形学头歌实训平台——二维几何变换
头歌计算机图形学实验--二维几何变换
hanlepeng的博客
10-27 465
【代码】头歌计算机图形学实验--二维几何变换。
头歌实践教学平台：CG3-v2.0-图形几何变换
菜鸟的博客~
05-08 568
(2) 根据平移算法原理补全translation、scale、rotation_x、rotation_y和rotation_z函数;(3) 将立方体的顶点坐标分别向x,y,z轴正方向平移0.5个单位距离，然后绘制一个红色正方形；(4) 将立方体的顶点坐标分别沿x,y,z轴方向缩放0.5倍，然后绘制一个绿色正方形；时，物体x、y坐标改变，而z坐标值在该变换中不改变，即。时，物体y、z坐标改变，而x坐标值在该变换中不改变，即。时，物体x、z坐标改变，而y坐标值在该变换中不改变，即。开始你的任务吧，祝你成功！
山东大学计算机图形学实验.zip
03-20
山东大学提供的这个实验课程，旨在让学生通过实际操作来理解和掌握计算机图形学的基本原理和技术。课程可能涵盖OpenGL编程、几何变换、光照模型、纹理映射等核心概念。 OpenGL是一个跨语言、跨平台的编程接口，用于...
计算机图形学实验五（三维图形变换程序设计）
08-08
计算机图形学是信息技术领域的一个重要分支，主要研究如何在计算机中表示、处理和显示图形。在本实验"三维图形变换程序设计"中，我们将深入探讨计算机如何实现对三维图形的几何变换，包括平移、旋转、缩放等操作。...
【计算机图形学】2 三维模型读取与控制
10-31
总的来说，"三维模型读取与控制"涉及到了计算机图形学中的多个核心概念和技术，包括模型文件格式解析、几何变换、光照处理、纹理贴图、视口投影以及性能优化等。理解和掌握这些知识点对于从事相关领域的开发工作至关...
计算机图形学课件三维几何变换
08-04
计算机图形学是研究如何利用计算机生成和处理图形的科学，其中几何变换是核心内容之一。在本课件中，我们重点关注三维几何变换，包括变换的数学基础、图形显示中的基本概念以及几何变换的具体应用。 首先，我们要...
计算机图形学-二维变换
weixin_44049693的博客
12-02 1156
实验一 // 提示：写完代码请保存之后再进行评测 #include <GL/freeglut.h> #include<stdio.h> // 评测代码所用头文件-开始 #include<opencv2/core/core.hpp> #include<opencv2/highgui/highgui.hpp> #include<opencv2/imgproc/imgproc.hpp> // 评测代码所用头文件-结束 void init(void) {
openc中的图像的扩展缩放resize、图像的平移及旋转warpAffine、getRotationMatrix2D
weixin_45670380的博客
10-28 398
图像的扩展缩放 dst=cv2.resize(src，dsize[,dst[,fx[,fy[,interpation]]]]) dsize 目标图像的大小，如果后面有了比例因子fx,fy，就可以为None dst 一般放到前面去 interpation插值方法可以有在缩放时我们推荐使用 cv2.INTER_AREA,在扩展时我们推荐使用 v2.INTER_CUBIC(慢) 和 v2.INTER_L...
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
qq_19319481的博客
08-09 366
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1238
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
【C++】类的默认成员函数，构造函数、析构函数、拷贝构造函数、运算符重载
2402_82757055的博客
08-10 924
这篇我们继续学习C++类和对象部分，大概会说一下类的一些默认成员函数，构造函数、析构函数、拷贝构造函数、赋值运算符重载这些知识。
C语言断言进阶篇：全面总结与实战技巧
极客代码
08-10 483
断言是一种用于验证程序中某个条件是否为真的语句。如果条件为假，程序会触发一个错误，通常会导致程序终止。断言主要用于开发和测试阶段，以帮助开发者发现和修正错误。在某些情况下，默认的assert宏可能无法满足我们的需求。if (!abort();= NULL);在这个自定义断言宏中，我们输出了更多的错误信息，包括失败的断言表达式、函数名、文件名和行号，方便我们定位错误。本文系统且全面地总结了C语言中的断言机制，包括断言的定义、作用、实现以及在实战中的运用。
C++_基本语法笔记_模板
最新发布
qq_45629864的博客
08-14 282
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 505
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
C语言常用关键字
Fearlessness的博客
08-14 439
C语言中常用的关键字
计算机图形学：二维几何变换与矩阵应用
在计算机图形学中，变换矩阵是描述图形几何变换的重要工具。一个总的变换矩阵可以包括多个子变换，如平移、旋转、缩放和倾斜等，这些子变换通过矩阵乘法组合在一起，形成复合变换。在二维空间中，相对于任意参考点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值