P << zNear, 0, 0, 0,
    0, zNear, 0, 0,
    0, 0, zNear + zFar, -zNear * zFar,
    0, 0, 1, 0;

f = -zNear;
n = -zFar;

#include "Triangle.hpp"
#include "rasterizer.hpp"
#include <eigen3/Eigen/Eigen>
#include <iostream>
#include <opencv2/opencv.hpp>

constexpr double MY_PI = 3.1415926;
bool ProjectMode=true;

Eigen::Matrix4f get_view_matrix(Eigen::Vector3f eye_pos)
{
    Eigen::Matrix4f view = Eigen::Matrix4f::Identity();

    Eigen::Matrix4f translate;
    translate << 1, 0, 0, -eye_pos[0], 0, 1, 0, -eye_pos[1], 0, 0, 1,
        -eye_pos[2], 0, 0, 0, 1;

    view = translate * view;

    return view;
}

Eigen::Matrix4f get_model_matrix(float rotation_angle)
{
    Eigen::Matrix4f model = Eigen::Matrix4f::Identity();
    rotation_angle = rotation_angle / 180.0f * MY_PI;
    // TODO: Implement this function
    // Create the model matrix for rotating the triangle around the Z axis.
    // Then return it.
    model << cos(rotation_angle), -sin(rotation_angle), 0, 0,
        sin(rotation_angle), cos(rotation_angle), 0, 0,
        0, 0, 1, 0,
        0, 0, 0, 1;
    return model;
}

// Rodrigues rotation formula
Eigen::Matrix4f get_rotation(Vector3f axis, float angle)
{
    angle = angle / 180.0f * MY_PI;
    Eigen::Matrix4f Result = Eigen::Matrix4f::Identity();
    Eigen::Matrix3f E = Eigen::Matrix3f::Identity();
    Eigen::Matrix3f N = Eigen::Matrix3f::Identity();
    Eigen::Matrix3f ResultMat3 = Eigen::Matrix3f::Identity();
    N << 0, -axis[2], axis[1],
        axis[2], 0, -axis[0],
        -axis[1], axis[0], 0;
    ResultMat3 = E * cos(angle) + (1 - cos(angle)) * axis * axis.transpose() + sin(angle) * N;
    Result << ResultMat3(0, 0), ResultMat3(0, 1), ResultMat3(0, 2), 0,
        ResultMat3(1, 0), ResultMat3(1, 1), ResultMat3(1, 2), 0,
        ResultMat3(2, 0), ResultMat3(2, 1), ResultMat3(2, 2), 0,
        0, 0, 0, 1;

    return Result;
}


Eigen::Matrix4f get_projection_matrix(float eye_fov, float aspect_ratio,
                                      float zNear, float zFar)
{
    // Students will implement this function

    Eigen::Matrix4f projection = Eigen::Matrix4f::Identity();

    // TODO: Implement this function
    // Create the projection matrix for the given parameters.
    // Then return it.
    if (!ProjectMode)
    {
        std::cout<<"Protable answer"<<std::endl;
        Eigen::Matrix4f S, M, P;
        eye_fov = eye_fov / 180 * MY_PI;
        float l, r, b, t, n, f;
        //注意这里的f和n代表的意义
        f = -zNear;
        n = -zFar;
        t = -zNear * tan(eye_fov/2);
        b = -t;
        r = t * aspect_ratio;
        l = -r;
        S << 2 / (r - l), 0, 0, 0,
            0, 2 / (t - b), 0, 0,
            0, 0, 2 / (n - f), 0,
            0, 0, 0, 1;
        M << 1, 0, 0, -(r + l) / 2,
            0, 1, 0, -(t + b) / 2,
            0, 0, 1, -(n + f) / 2,
            0, 0, 0, 1;
        P << zNear, 0, 0, 0,
            0, zNear, 0, 0,
            0, 0, zNear + zFar, -zNear * zFar,
            0, 0, 1, 0;
        return S * M * P;
    }
    else
    {
        std::cout<<"true answer"<<std::endl;
        eye_fov = eye_fov / 180 * MY_PI;
        projection << 1 / (aspect_ratio * tan(eye_fov / 2.0f)), 0, 0, 0,
            0, 1 / tan(eye_fov / 2.0f), 0, 0,
            0, 0, -(zFar + zNear) / (zFar - zNear), 2 * zFar * zNear / (zNear - zFar),
            0, 0, -1, 0;
        return projection;
    }
}
int main(int argc, const char **argv)
{
    float angle = 0;
    bool command_line = false;
    Eigen::Vector3f axis = Eigen::Vector3f(0.f, 1.f, 0.f);
    std::string filename = "output.png";
    if(argc>=2){
        std::cout<<argv[1]<<std::endl;
        if(argv[1][1]=='m')//使用精简版本
            ProjectMode=true;
        else if(argv[1][1]=='p')//使用便阅读版本
            ProjectMode=false;
        std::cout<<ProjectMode<<std::endl;
    }
    
    if (argc >= 3)
    {
        std::cout<<argc<<std::endl;

        angle = std::stof(argv[2]); // -r by default
        if (argc == 4)
        {
            command_line = true;
            filename = std::string(argv[3]);
        }
        else if(argc==6){//DIY(
        axis.x()=std::stof(argv[3]);
        axis.y()=std::stof(argv[4]);
        axis.z()=std::stof(argv[5]);
        axis.normalize();
        }
        //
    }

    rst::rasterizer r(700, 700);

    Eigen::Vector3f eye_pos = {0, 0, 5};

    std::vector<Eigen::Vector3f> pos{{2, 0, -2}, {0, 2, -2}, {-2, 0, -2}};

    std::vector<Eigen::Vector3i> ind{{0, 1, 2}};

    auto pos_id = r.load_positions(pos);
    auto ind_id = r.load_indices(ind);

    int key = 0;
    int frame_count = 0;

    if (command_line)
    {
        r.clear(rst::Buffers::Color | rst::Buffers::Depth);

        r.set_model(get_model_matrix(angle));
        r.set_view(get_view_matrix(eye_pos));
        r.set_projection(get_projection_matrix(45, 1, 0.1, 50));

        r.draw(pos_id, ind_id, rst::Primitive::Triangle);
        cv::Mat image(700, 700, CV_32FC3, r.frame_buffer().data());
        image.convertTo(image, CV_8UC3, 1.0f);

        cv::imwrite(filename, image);

        return 0;
    }
 

    while (key != 27)
    {
        r.clear(rst::Buffers::Color | rst::Buffers::Depth);


        r.set_model(get_model_matrix(angle));
        //DIY
        if (argc == 6){
            r.set_model(get_rotation(axis, angle));
            std::cout<<"axis x:"<<axis.x()<<" y:"<<axis.y()<<" z:"<<axis.z()<<std::endl<<"angle:"<<angle<<std::endl;
        }
        //
        r.set_view(get_view_matrix(eye_pos));
        r.set_projection(get_projection_matrix(45, 1, 0.1, 50));

        r.draw(pos_id, ind_id, rst::Primitive::Triangle);

        cv::Mat image(700, 700, CV_32FC3, r.frame_buffer().data());
        image.convertTo(image, CV_8UC3, 1.0f);
        cv::imshow("image", image);
        key = cv::waitKey(10);

        std::cout << "frame count: " << frame_count++ << '\n';

        if (key == 'a')
        {
            angle += 10;
        }
        else if (key == 'd')
        {
            angle -= 10;
        }
    }

    return 0;
}

---------------------------------------------
//main
#include "Triangle.hpp"
#include "rasterizer.hpp"
#include <eigen3/Eigen/Eigen>
#include <iostream>
#include <opencv2/opencv.hpp>
---------------------------------------------

//raserizer.hpp
#include "Triangle.hpp"
#include <algorithm>
#include <eigen3/Eigen/Eigen>
using namespace Eigen;
---------------------------------------------

//Triangle.hpp
#include <eigen3/Eigen/Eigen>
using namespace Eigen;
---------------------------------------------

//访问顶点坐标
Eigen::Vector3f a() const { return v[0]; }
Eigen::Vector3f b() const { return v[1]; }
Eigen::Vector3f c() const { return v[2]; }
//设置顶点坐标、法线、颜色、纹理坐标
void setVertex(int ind, Vector3f ver); /*set i-th vertex coordinates */
void setNormal(int ind, Vector3f n);   /*set i-th vertex normal vector*/
void setColor(int ind, float r, float g, float b); /*set i-th vertex color*/
void setTexCoord(int ind, float s,
float t); /*set i-th vertex texture coordinate*/
//到Vec4的转化，方便进行矩阵计算
std::array<Vector4f, 3> toVector4() const;

std::array<Vector4f, 3> Triangle::toVector4() const
{
    std::array<Vector4f, 3> res;
    std::transform(std::begin(v), std::end(v), res.begin(), [](auto& vec) {
        return Vector4f(vec.x(), vec.y(), vec.z(), 1.f);
    });
    return res;
}

class rasterizer
{
  private:
	//三个投影矩阵
    Eigen::Matrix4f model;
    Eigen::Matrix4f view;
    Eigen::Matrix4f projection;
	
	//顶点缓存
    std::map<int, std::vector<Eigen::Vector3f>> pos_buf;
	std::map<int, std::vector<Eigen::Vector3i>> ind_buf;
	
	//颜色缓存
    std::vector<Eigen::Vector3f> frame_buf;
    //深度缓存 暂未使用
    std::vector<float> depth_buf;
	
	//显示区域参数
    int width, height;
	//工具
    int next_id = 0;
};

//raterizer.cpp
rst::rasterizer::rasterizer(int w, int h) : width(w), height(h)
{
    frame_buf.resize(w * h);
    depth_buf.resize(w * h);
}

void rst::rasterizer::set_model(const Eigen::Matrix4f& m){
    model = m;
}
void rst::rasterizer::set_view(const Eigen::Matrix4f& v){
    view = v;
}
void rst::rasterizer::set_projection(const Eigen::Matrix4f& p){
    projection = p;
}
//导入顶点坐标和顶点索引
rst::pos_buf_id rst::rasterizer::load_positions(const std::vector<Eigen::Vector3f> &positions){
    auto id = get_next_id();
    pos_buf.emplace(id, positions);
    return {id};
}
rst::ind_buf_id rst::rasterizer::load_indices(const std::vector<Eigen::Vector3i> &indices){
    auto id = get_next_id();
    ind_buf.emplace(id, indices);
    return {id};
}

/*
 For the curious : The draw function takes two buffer id's as its arguments.
 These two structs make sure that if you mix up with their orders, the
 compiler won't compile it. Aka : Type safety
*/
/*
对于感兴趣的人 : draw 函数接受两个缓冲区ID作为参数。
这些两个结构体确保如果将它们顺序混乱，编译器不会编译它。
又名 : 类型安全
*/
struct pos_buf_id{
    int pos_id = 0;
};
struct ind_buf_id{
    int ind_id = 0;
};

if (point.x() < 0 || point.x() >= width ||
        point.y() < 0 || point.y() >= height) return;
    auto ind = (height-point.y())*width + point.x();
    frame_buf[ind] = color;

//鼠标点击回调函数
glutMouseFunc(onMouse);
//鼠标移动回调函数
glutPassiveMotionFunc(onMouseMove);
typedef enum {
	MOVE,
	NONE
}MOUSEMODE;

/*这里是onMouse(GLint button, GLint state, GLint x, GLint y)*/

//如果点击状态是按下
if (state == GLUT_DOWN) {
	//如果是鼠标左键
	if (button == GLUT_LEFT_BUTTON) {
		//如果是第一个点，多创建一个顶点
		if (!Vertex.size())
			Vertex.push_back(make_pair(x, y));
		Vertex.push_back(make_pair(x, y));
		//设置控制点的位置
		ctrlPoint = Vertex.size();
		//修改控制模式
		MouseMode = MOVE;
	}
}

/*这里是onMouseMove(GLint xMouse, GLint yMouse)*/

//如果控制装填是移动
if (MouseMode == MOVE) {
	Vertex[ctrlPoint - 1].first = xMouse, Vertex[ctrlPoint - 1].second = yMouse;
	//发送重绘信息
	glutPostRedisplay();
}

/*这里是onMouse(GLint button, GLint state, GLint x, GLint y)*/

//如果按下的是右键
else if (button == GLUT_RIGHT_BUTTON) {
	//如果正在进行橡皮筋操作
	if (MouseMode == MOVE) {
		//停止橡皮筋操作（停止实时绘画）
		MouseMode = NONE;
		return;
	}
	//否则为删除模式，判断顶点位置
	auto ibeg = Vertex.begin();
	while (ibeg != Vertex.end()) {
		//模糊搜索，先绘制的顶点先删除（距离都满足条件的话）
		if (((x - ibeg->first) * (x - ibeg->first)) + ((y - ibeg->second) * (y - ibeg->second)) < 400) {
			//找到了，删除该顶点
			Vertex.erase(ibeg);
			break;
		}
		ibeg++;
	}
}

/*
你可以使用左键绘制顶点
你可以使用右键删除顶点
直线的绘制沿着顶点顺序
*/
#include <gl/glut.h>
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include "DrawLine.hpp"
#include "DrawRound.hpp"

using namespace std;

#define m_POINT_SIZE 10
#define m_LINE_SIZE 2
typedef enum {
	MOVE,
	NONE
}MOUSEMODE;

vector<pair<GLint, GLint >>Vertex;
MOUSEMODE MouseMode = NONE;
GLint ctrlPoint = 0;

void onDisplay();
void onReshape(GLint w, GLint h);
void onMouse(GLint button, GLint state, GLint x, GLint y);
void onMouseMove(GLint xMouse, GLint yMouse);

void onReshape(GLint w, GLint h)
{
	// 设置视口大小
	glViewport(0, 0, w, h);
	// 切换矩阵模式为投影矩阵
	glMatrixMode(GL_PROJECTION);
	// 载入单位矩阵
	glLoadIdentity();
	// 进行二维平行投影
	gluOrtho2D(0, w, h, 0);
	// 切换矩阵模式为模型矩阵
	glMatrixMode(GL_MODELVIEW);
	// 发送重绘
	glutPostRedisplay();
}
void onMouse(GLint button, GLint state, GLint x, GLint y){
	if (state == GLUT_DOWN) {
		if (button == GLUT_LEFT_BUTTON) {
			if(!Vertex.size())
			Vertex.push_back(make_pair(x, y));
			Vertex.push_back(make_pair(x, y));
			ctrlPoint = Vertex.size();
			MouseMode = MOVE;
		}
		else if (button == GLUT_RIGHT_BUTTON) {
			if (MouseMode == MOVE) {
				MouseMode = NONE;
				return;
			}
			auto ibeg = Vertex.begin();
			while (ibeg != Vertex.end()) {
				if (((x - ibeg->first) * (x - ibeg->first)) + ((y - ibeg->second) * (y - ibeg->second)) < 400) {
					Vertex.erase(ibeg);
					break;
				}
				ibeg++;
			}
		}
	}
	glutPostRedisplay();
}
void onMouseMove(GLint xMouse, GLint yMouse) {
	if (MouseMode == MOVE) {
		Vertex[ctrlPoint-1].first = xMouse, Vertex[ctrlPoint-1].second = yMouse;
		glutPostRedisplay();
	}
}
void onDisplay() {
	glClearColor(224 / 255.0, 237 / 255.0, 253 / 255.0,1.0);
	glClear(GL_COLOR_BUFFER_BIT);

	glColor3f(1.0f, 0, 0);
	auto ibeg = Vertex.begin(),jbeg=ibeg;
	GLint VertexNum = Vertex.size();
	while (ibeg != Vertex.end()) {
		glPointSize(m_POINT_SIZE);
		glBegin(GL_POINTS);
		glVertex2i(ibeg->first, ibeg->second);
		glEnd();
		glPointSize(m_LINE_SIZE);
		if(VertexNum>=2) {
			//这里可以选择直线绘制方式
			BRESENHAM_Line(ibeg->first, ibeg->second, jbeg->first, jbeg->second);
			//TMP_Line(ibeg->first, ibeg->second, jbeg->first, jbeg->second);
			//DDA_Line(ibeg->first, ibeg->second, jbeg->first, jbeg->second);

			//这里是绘制圆形
			//Mid_Circle( jbeg->first, jbeg->second,ibeg->first, ibeg->second);
			//BRESENHAM_Circle(jbeg->first, jbeg->second, ibeg->first, ibeg->second);

		}
		jbeg = ibeg;
		ibeg++;
	}
	//这里是绘制圆弧（只绘制前三个点，可以自己DIY）
	if (VertexNum >= 3) {
		cout << "Draw CircleArc" << endl;
		DrawCircleArc(Vertex[0].first, Vertex[0].second, Vertex[1].first, Vertex[1].second, Vertex[2].first, Vertex[2].second);
	}

	glutSwapBuffers();
	cout << "Once" << endl;
}

GLint main(GLint argc, char* argv[])
{

	// 初始化 glut
	glutInit(&argc, argv);
	// 设置 OpenGL 显示模式(双缓存, RGB 颜色模式)
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
	// 设置窗口初始尺寸
	glutInitWindowSize(1000,800);
	// 设置窗口初始位置
	glutInitWindowPosition(0, 0);
	// 设置窗口标题
	glutCreateWindow("Terix");
	glutReshapeFunc(onReshape);
	glutDisplayFunc(onDisplay);
	glutMouseFunc(onMouse);
	glutPassiveMotionFunc(onMouseMove);
	// 设置菜单
	// 进入 glut 事件循环
	glutMainLoop();
	return 0;
}

class Ellipt {
public:
	Ellipt(GLint P1x=0,GLint P1y=0,GLint P2x=0,GLint P2y=0)
	{
		m_a = abs(static_cast<GLint>(P1x - P2x)/2);
		m_b= abs(static_cast<GLint>(P1y - P2y)/2);
		//四舍五入
		m_R.x = static_cast<GLint>(((P1x + P2x) / 2.0 + 0.5));
		m_R.y = static_cast<GLint>(((P1y + P2y) / 2.0 + 0.5));
	}
	void setData(GLint P1x, GLint P1y, GLint P2x, GLint P2y) {
		m_a = abs(static_cast<GLint>(P1x - P2x)/2);
		m_b = abs(static_cast<GLint>(P1y - P2y)/2);
		//四舍五入
		m_R.x = static_cast<GLint>(((P1x + P2x) / 2.0 + 0.5));
		m_R.y = static_cast<GLint>(((P1y + P2y) / 2.0 + 0.5));
	}
	void Draw(){
		MidPt_Elliptse(m_R, m_a, m_b);
	}
private:
	myPoint m_R;
	GLint m_a,m_b;
	void MidPt_Elliptse(myPoint cPt, GLint a, GLint b) {
		glBegin(GL_POINTS);
		GLint x, y, temp = a * 7 / 10, dir[4][2] = {
		{ 1, 1 }, { 1,-1 },
		{ -1,1}, {-1,-1 }
		};
		double d;
		x = 0, y = b;
		d = b * b + a * a * (-b + 0.25);
		for (int i = 0; i < 4; i++) {
			glVertex2i(cPt.x + x * dir[i][0], cPt.y + y * dir[i][1]);
		}
		while ((b * b * (x + 1)<a * a * (y + 0.5))) {
			if (d > 0)
			{
				x += 1;
				y -= 1;
				d += b * b * (2 * x + 3) + a * a * (-2 * y + 2);
			}
			else {
				x += 1;
				d += b * b * (2 * x + 3);
			}
			for (int i = 0; i < 4; i++) {
				glVertex2i(cPt.x + x * dir[i][0], cPt.y + y * dir[i][1]);
			}
		}
		while (y > 0) {
			if (d >= 0) {
				y -= 1;
				d += a * a * (-2 * y + 3);
			}
			else {
				x += 1;
				y -= 1;
				d += a * a * (-2 * y + 3) + b * b * (2 * x + 2);
			}
			for (int i = 0; i < 4; i++) {
				glVertex2i(cPt.x + x * dir[i][0], cPt.y + y * dir[i][1]);
			}
		}
		glFlush();
		glEnd();
	}
};
``` 其中用到的myPoint类

```cpp
class myPoint;

//A point or a vector in R^2
class myPoint {
public:
	myPoint(GLint X=0,GLint Y=0 ):x(X),y(Y){}
	GLint x, y;
};
myPoint operator+(const myPoint& a, const myPoint& b) {
	return myPoint(a.x + b.x, a.y + b.y);
}
myPoint operator-(const myPoint& a, const myPoint& b) {
	return myPoint(a.x - b.x, a.y - b.y);
}
GLint operator*(const myPoint& a, const myPoint& b) {
	return a.x * b.x + a.y * b.y;
}

double x, y;
double k;			//斜率
k = (static_cast<float>(endy - starty) / static_cast<float>(endx - startx));
x = (double)startx, y = (double)starty;
if (abs(k) < 1.0) {
	for (int i = 0; i < abs(endx - startx); i++) {
		if (endx > startx) {
			x += 1;
			y += k;
		}
		else {
			x -= 1;
			y -= k;
		}
		glVertex2d(static_cast<int>(x), static_cast<int>(y + 0.5));		//y四舍五入
	}
}
else if (abs(k) > 1.0) {
	for (int i = 0; i < abs(endy - starty); i++) {
		if (endy > starty) {
			y += 1;
			x += 1.0 / k;
		}
		else {
			y -= 1;
			x -= 1.0 / k;
		}
		glVertex2d(static_cast<int>(x + 0.5), static_cast<int>(y));		//x四舍五入
	}
}

void DDA_Line(int startx, int starty, int endx, int endy) {
	glBegin(GL_POINTS);
	if (startx != endx && starty != endy)
	{
		double x, y;
		double k;			//斜率
		k = (static_cast<float>(endy - starty) /static_cast<float>(endx - startx));
		x = (double)startx, y = (double)starty;
		if (abs(k)<1.0) {
			for (int i = 0; i < abs(endx - startx); i++) {
				if (endx > startx) {
					x += 1;
					y += k;
				}
				else {
					x -= 1;
					y -= k;
				}
				glVertex2d(static_cast<int>(x), static_cast<int>(y+0.5));		//y四舍五入
			}
		}
		else if (abs(k) > 1.0) {
			for (int i = 0; i < abs(endy - starty); i++) {
				if (endy > starty) {
					y += 1;
					x += 1.0/k;
				}
				else {
					y -= 1;
					x -= 1.0/k;
				}
				glVertex2d(static_cast<int>(x + 0.5), static_cast<int>(y));		//x四舍五入
			}
		}
	}
	else if (startx == endx) {//垂直画线
		if (starty < endy) {
			for (int i = starty; i < endy; i++) {
				glVertex2d(startx, i);
			}
		}
		else if (starty > endy) {
			for (int i = endy; i < starty; i++) {
				glVertex2d(startx, i);
			}
		}
	}
	else if (starty == endy) {//水平画线
		if (startx < endx) {
			for (int i = startx; i < endx; i++) {
				glVertex2d(i, starty);
			}
		}
		else if (startx > endx) {
			for (int i = endx; i < startx; i++) {
				glVertex2d(i, starty);
			}
		}
	}
	glFlush();
	glEnd();
}

if (startx != endx && starty != endy)
{
	bool kFlag = 0;		//斜率是否大于1
	int sFlag = 1;			//斜率的正负
	if (startx > endx) {		//因为算法是x递增的，所以要保持起点x在终点左边
		int tempx = startx, tempy = starty;
		startx = endx, starty = endy;
		endx = tempx, endy = tempy;
	}
	if (abs(starty - endy) > abs(startx - endx)) {
		kFlag = true;
	}
	if (starty > endy) {		//标记斜率小于零
		sFlag = -1;
	}
	int a, b, TA, TAB, d, x, y;
	if (sFlag == -1)
		endy = starty + (starty - endy);

	a = starty - endy;
	b = endx - startx;
	TA = 2 * a;					//twoA
	TAB = 2 * (a + b);		//twoAB
	d = 2 * a + b;
	x = startx, y = starty;
	if (!kFlag) {
		for (int i = 0; i < (endx - startx); i++) {
			if (d >= 0) {
				glVertex2i(++x, y);
				d += TA;
			}
			else {
				glVertex2i(++x, y += sFlag);
				d += TAB;
			}
		}
	}
	else if (kFlag) {
		if (kFlag == 1) {
			TA = 2 * b;
			d = 2 * b + a;
		}
		for (int i = 0; i < abs(endy - starty); i++) {
			if (d >= 0) {
				glVertex2i(++x, y += sFlag);
				d += TAB;
			}
			else {
				glVertex2i(x, y += sFlag);
				d += TA;
			}
		}
	}
}

void TMP_Line(int startx, int starty, int endx, int endy) {
	glBegin(GL_POINTS);
	if (startx != endx && starty != endy)
	{
		bool kFlag = 0;		//斜率是否大于1
		int sFlag = 1;			//斜率的正负
		if (startx > endx) {		//因为算法是x递增的，所以要保持起点x在终点左边
			int tempx = startx, tempy = starty;
			startx = endx, starty = endy;
			endx = tempx, endy = tempy;
		}
		if (abs(starty - endy) > abs(startx - endx)) {
			kFlag = true;
		}
		if (starty > endy) {		//标记斜率小于零
			sFlag = -1;
		}
		int a, b, TA, TAB, d, x, y;
		if (sFlag == -1)
			endy = starty + (starty - endy);

		a = starty - endy;
		b = endx - startx;
		TA = 2 * a;					//twoA
		TAB = 2 * (a + b);		//twoAB
		d = 2 * a + b;
		x = startx, y = starty;
		if (!kFlag) {
			for (int i = 0; i < (endx - startx); i++) {
				if (d >= 0) {
					glVertex2i(++x, y);
					d += TA;
				}
				else {
					glVertex2i(++x , y +=sFlag);
					d += TAB;
				}
			}
		}
		else if (kFlag) {
			if (kFlag == 1) {
				TA = 2 * b;
				d = 2 * b + a;
			}
			for (int i = 0; i < abs(endy - starty); i++) {
				if (d >= 0) {
					glVertex2i(++x , y +=sFlag);
					d += TAB;
				}
				else {
					glVertex2i(x, y+=sFlag);
					d += TA;
				}
			}
		}
	}
	else if (startx == endx) {//垂直画线
		if (starty < endy) {
			for (int i = starty; i < endy; i++) {
				glVertex2i(startx, i);
			}
		}
		else if (starty > endy) {
			for (int i = endy; i < starty; i++) {
				glVertex2i(startx, i);
			}
		}
	}
	else if (starty == endy) {//水平画线
		if (startx < endx) {
			for (int i = startx; i < endx; i++) {
				glVertex2i(i, starty);
			}
		}
		else if (startx > endx) {
			for (int i = endx; i < startx; i++) {
				glVertex2i(i, starty);
			}
		}
	}
	glFlush();
	glEnd();
}

if (startx != endx && starty != endy) {
	bool kFlag = 0;		//斜率是否大于1
	int sFlag = 1;			//斜率的正负
	if (startx > endx) {		//因为算法是x递增的，所以要保持起点x在终点左边
		int tempx = startx, tempy = starty;
		startx = endx, starty = endy;
		endx = tempx, endy = tempy;
	}
	if (abs(starty - endy) > abs(startx - endx)) {
		kFlag = true;
	}
	if (starty > endy) {		//标记斜率小于零
		sFlag = -1;
	}
	int x, y;
	int dx, dy, p;
	if (sFlag == -1)
		endy = starty + (starty - endy);
	dx = endx - startx;
	dy = endy - starty;
	x = startx, y = starty;
	if (!kFlag) {
		p = 2 * dy - dx;
		for (int i = 0; i < (endx - startx); i++) {
			if (p <= 0) {
				glVertex2i(++x, y);
				p += 2 * dy;
			}
			else {
				glVertex2i(++x, y += sFlag);
				p += 2 * dy - 2 * dx;
			}
		}
	}
	else {
		p = 2 * dx - dy;
		for (int i = 0; i < (endy - starty); i++) {
			if (p <= 0) {
				glVertex2i(x, y += sFlag);
				p += 2 * dx;
			}
			else {
				glVertex2i(++x, y += sFlag);
				p += 2 * dx - 2 * dy;
			}
		}
	}
}

void BRESENHAM_Line(int startx, int starty, int endx, int endy) {
	glBegin(GL_POINTS);
	if (startx != endx && starty != endy) {
		bool kFlag = 0;		//斜率是否大于1
		int sFlag = 1;			//斜率的正负
		if (startx > endx) {		//因为算法是x递增的，所以要保持起点x在终点左边
			int tempx = startx, tempy = starty;
			startx = endx, starty = endy;
			endx = tempx, endy = tempy;
		}
		if (abs(starty - endy) > abs(startx - endx)) {
			kFlag = true;
		}
		if (starty > endy) {		//标记斜率小于零
			sFlag = -1;
		}
		int x, y;
		int dx, dy, p;
		if (sFlag == -1)
			endy = starty + (starty - endy);
		dx = endx - startx;
		dy = endy - starty;
		x = startx, y = starty;
		if (!kFlag) {
			p = 2 * dy - dx;
			for (int i = 0; i < (endx - startx); i++) {
				if (p <= 0) {
					glVertex2i(++x, y);
					p += 2 * dy;
				}
				else {
					glVertex2i(++x, y += sFlag);
					p += 2 * dy - 2 * dx;
				}
			}
		}
		else {
			p = 2 * dx - dy;
			for (int i = 0;i < (endy - starty); i++) {
				if (p <= 0) {
					glVertex2i(x, y += sFlag);
					p += 2 * dx;
				}
				else {
					glVertex2i(++x, y += sFlag);
					p += 2 * dx - 2 * dy;
				}
			}
		}
	}
	else if (startx == endx) {//垂直画线
		if (starty < endy) {
			for (int i = starty; i < endy; i++) {
				glVertex2i(startx, i);
			}
		}
		else if (starty > endy) {
			for (int i = endy; i < starty; i++) {
				glVertex2i(startx, i);
			}
		}
	}
	else if (starty == endy) {//水平画线
		if (startx < endx) {
			for (int i = startx; i < endx; i++) {
				glVertex2i(i, starty);
			}
		}
		else if (startx > endx) {
			for (int i = endx; i < startx; i++) {
				glVertex2i(i, starty);
			}
		}
	}
	glFlush();
	glEnd();
}