北邮计算机图形学作业一

#include 
#include 
#include
void DDA（HDC hdcint x0int y0int xnint yn）
{
	/*确定增量dxdy*/
	int max;
	double dxdy;
	int d_x=abs（xn-x0）;
	int d_y=abs（yn-y0）;
	if（d_x>=d_y）
		max=d_x;
	else
		max=d_y;
	dx=（xn-x0）/max;
	dy=（yn-y0）/max;
	/*绘点*/
	double xi=x0yi=y0;
	int pix_x=floor（xi）pix_y=floor（yi）;
    SetPixel（hdcpix_xpix_yRGB（232423））;
    for（int i=0;i!=max;++i）{
		xi+=dx;
		yi+=dy;
        pix_x=floor（xi）;
		pix_y=floor（yi）;
        SetPixel（hdcpix_xpix_yRGB（232423））;
	}

}

void Bresenham（HDC hdc int x1 int y1 int x2 int y2）
{
	int x y dx dy e;
	dx = abs（x2 - x1）;
	dy = abs（y2 - y1）;
	e = 2 * dy - dx;
	x = x1;
	y = y1;
	for （int i = 0; i < dx; i++） {
		SetPixel（hdc x y RGB（0 0 0））;
		if （e >= 0） {
			y++;
			e = e - 2 * dx;
		}
		x++;
		e = e + 2 * dy;
	}

	return;
}

void RoundArc（HDC hdc int x int y int r）
{
	int X Y d;
	X = x;
	Y = y - r;
	d = （y - Y）*（y - Y） + （Y + 1 -y）*（Y + 1 -y） - 2 * r * r ;
	
    while（（X - x） <= （y - Y））
	{
		if（d >= 0）
		{
		    Y++;
			d = d + 4*（X + Y）-4*（x + y） + 10;
        }
		else
		{
			d = d + 4*X - 4*x +6;
		}
		
		SetPixel（hdc X Y RGB（0 0 0））;
		SetPixel（hdc （2 * x - X） YRGB（0 0 0））;
		SetPixel（hdc X （2 * y - Y） RGB（0 0 0））;
		SetPixel（hdc （2 * x - X） （2 * y - Y） RGB（0 0 0））;
		SetPixel（hdc （x + （y - Y）） （y -（X - x））RGB（0 0 0））;
		SetPixel（hdc （x + （y - Y）） （y +（X - x））RGB（0 0 0））;
		SetPixel（hdc （x - （y - Y）） （y -（X - x））RGB（0 0 0））;
		SetPixel（hdc （x - （y - Y）） （y +（X - x））RGB（0 0 0））;

		X++;
	}
}


void EllipseArc（HDC hdc int x int y int a int b）
{
	float t = 0 dt = 0.001;
	int x1 = x + a y1 = y x2 y2;
	while （t < 2 * 3.14159） {
		t += dt;
		x2 = x + （int）（a * cos（t））;
		y2 = y + （int）（b * sin（t））;
		Bresenham（hdc x1 y1 x2 y2）;
		x1 = x2;
		y1 = y2;
	}
}

void bubbleSort（double array[][2]int size）
{
	bool changed=true;
	int n=0;
	do{
		changed=false;
		for（int i=0;i			if（array[i][0]>array[i+1][0]）{
				int temp;
				temp=array[i][0];
				array[i][0]=array[i+1][0];
				array[i+1][0]=temp;
				temp=array[i][1];
				array[i][1]=array[i+1][1];
				array[i+1][1]=temp;
				changed=true;
			}
		}
		n++;
	}while（changed）;
}


void shadowFill（HDC hdcint P[][2]int mnint mdouble hdouble a）
{
	const double k=1.0;
	const double db=3.0;
	double B[8][2];
	int ij;
	for（i=0;（i+1）<=（m-1）;++i）{
		B[i][0]=（double）（P[i][1]-k*P[i][0]）;
		B[i][1]=（double）（P[i+1][1]-k*P[i+1][0]）;
		if（B[i][0]>B[i][1]）{
			double temp=B[i][0];
			B[i][0]=B[i][1];
			B[i][1]=temp;
		}
	}
	B[m-1][0]=（double）（P[m-1][1]-k*P[m-1][0]）;
	B[m-1][1]=（double）（P[0][1]-k*P[0][0]）;
	if（B[m-1][0]>B[m-1][1]）{
		double temp=B[m-1][0];
	    B[m-1][0]=B[m-1][1];
		B[m-1][1]=temp;
	}
	for（i=m;（i+1）<=（mn-1）;++i）{
		B[i][0]=（double）（P[i][1]-k*P[i][0]）;
		B[i][1]=（double）（P[i+1][1]-k*P[i+1