计算机图形学——二维图形变换&裁剪

算法描述

1.基本变换矩阵

(1).缩放矩阵

void ScaleMatrix(float Sx, float Sy, float m[3][2])
{
    
    
	for (int i = 0; i < 3; i++) {
    
    
		m[i][0] *= Sx;
		m[i][1] *= Sy;
	}
}

(2).旋转矩阵

void RotateMatrix(float S, float C, float m[3][2])
{
    
    
	float temp;
	for (int i = 0; i < 3; i++) {
    
    
		temp = m[i][0];
		m[i][0] = temp * C - m[i][1] * S;
		m[i][1] = temp * S + m[i][1] * C;
	}
}

(3).平移矩阵

void TranslateMatrix(float Tx, float Ty, float m[3][2])
{
    
    
	// 矩阵平移变换的位移量
	m[2][0] += Tx;
	m[2][1] += Ty;
}

2.Cohn-Sutherland直线裁剪算法

Cohn-Sutherland直线裁剪算法即对直线段p1(x1 ,y1)、p2(x2 ,y2)进行裁剪

1.基本思想：对每条直线段p1(x1,y1)p2(x2,y2)分三种情况处理

直线段完全可见，“简取”之。
直线段完全不可见，“简弃”之。
直线段既不满足“简取”的条件，也不满足“简弃”的条件，需要对直线段按交点进行分段，分段后重复上述处理。

2 编码方法

编码： 对于任一端点(x,y)，根据其坐标所在的区域，赋予一个4位的二进制码D3D2D1D0。

编码规则如下：

若x<wxl，则D0=1，否则D0=0；
若x>wxr，则D1=1，否则D1=0；
若y<wyb，则D2=1，否则D2=0；
若y>wyt，则D3=1，否则D3=0。

裁剪一条线段时，先求出端点p1和p2的编码 code1和code2，然后：

若code1|code2=0，对直线段应简取之。
若code1&code2≠0，对直线段可简弃之。
若上述两条件均不成立。则需求出直线段与窗口边界的交点。在交点处把线段一分为二，其中必有一段完全在窗口外，可以弃之。再对另一段重复进行上述处理，直到该线段完全被舍弃或者找到位于窗口内的一段线段为止。

3.具体做法：

按左、下、右、上的顺序求出直线段与窗口边界的交点，分段处理

例：对于直线段P1P2

求出P1P2与左边界有实交点P3，一分为二，简弃直线段P1P3，处理P2P3
求出P2P3与下边界的实交点P4，一分为二，简弃P2P4，剩下的P3P4可以简取。

3. Liang-Barsky直线裁剪算法：

任意直线段I（X1 ,Y1）J(X2 ,Y2 )的参数方程：

x=x1+u•(x2 -x1)
y=y1+u•(y2 -y1)
（0 ≤ u ≤ 1）

给定裁剪窗口，如果任一点在窗口内则：

wxl≤ x1+u•(x2 -x1 )≤ wxr
wyb≤y1+u•(y2 -y1 ) ≤ wyt

u•(x1 -x2 )≤ x1 – wxl 左边界
u•(x2 -x1 )≤ wxr – x1 右边界
u•(y1 -y2 )≤ y1 – wyb 下边界
u•(y2 -y1 ) ≤ wyt – y1 上边界

（u•pk≤qk ，k=1,2,3,4）

令：
p1 = x1 -x2
p2 = x2 -x1
p3 = y1 -y2
p4 = y2 -y1

q1 = x1 – wxl
q2 = wxr – x1
q3 = y1 – wyb
q4 = wyt – y1
（u•pk≤qk，其中：k=1,2,3,4）

取“=”时求得的u对应的是直线不窗口边界的交点
1、2、3、4分别对应左、右、下、上边界
u=0和1时分别对应直线的起点和终点
Uone=max(0,uk|pk<0,uk|pk<0)
Utwo=min(1,uk|pk>0,uk|pk>0)

例如： 对于IJ P1、P4小于0 Uone在0、u1、u4取大者 P2、P3大于0 Utwo在1、u2、u3取小者
限制条件： 如果Uone≤ Utwo取可求得两端点

4. Sutherland-Hodgman多边形裁剪算法

1.基本思想：一次用窗口的一条边来裁剪多边形。

算法的输入是以顶点序列表示的多边形，输出也是一个顶点序列，这些顶点能够构成一个或多个多边形。

处理对象： 任意凸多边形。

窗口的任意一条边的所在直线（裁剪线）把窗口所在平面分成两部分：

可见一侧：包含窗口那部分
不可见一侧：不包含窗口那部分

2. 算法说明：

1、已知：多边形顶点数组src，顶点个数n，定义新多边形顶点数组dest。

2、赋初值：用变量flag来标识：0表示在内侧，1表示在外侧。

3、对多边形的n条边进行处理，对当前点号的考虑为：0～n-1。

for(i=0；i<n；i++)
{
    
    
　　if(当前第i个顶点是否在边界内侧？)
　　{
    
    
　　　　if(flag!=0) /*前一个点在外侧吗？*/
　　　　{
    
    
　　　　　　flag=0；/*从外到内的情况，将标志置0,作为下一次循环的前一点标志*/
　　　　　　(dest + j) =求出交点；　/*将交点dest放入新多边形*/
           j++；
       }
     　(dest + j)= (src + i)； /*将当前点srci放入新多边形*/
       j++；
	}
	else 
	{
    
    
		if(flag==0) /*前一个点在内侧吗？*/
　　　　	{
    
    
　　　　　　flag=1；/*从内到外的情况，将标志置1,作为下一次循环的前一点标志*/
　　　　　　(dest + j) =求出交点；　/*将交点dest放入新多边形*/
           j++；
		}
	}
	s= (src + i)； /*将当前点作为下次循环的前一点*/
}

3.算法特点：

Sutherland－Hodgeman多边形裁剪算法具有一般性，被裁剪多边形可以是任意凸多边形，裁剪窗口不局限于矩形。

上面的算法是多边形相对窗口的一条边界进行裁剪的实现，对于窗口的每一条边界依次调用该算法程序，并将前一次裁剪的结果多边形作为下一次裁剪时的被裁剪多边形，即可得到完整的多边形裁剪程序。

5. Weiler－Atherton多边形裁剪算法

一．Weiler－Atherton任意多边形裁剪算法思想：

假设被裁剪多边形和裁剪窗口的顶点序列都按顺时针方向排列。当两个多边形相交时，交点必然成对出现，其中一个是从被裁剪多边形进入裁剪窗口的交点，称为“入点”，另一个是从被裁剪多边形离开裁剪窗口的交点，称为“出点”。算法从被裁剪多边形的一个入点开始，碰到入点，沿着被裁剪多边形按顺时针方向搜集顶点序列；而当遇到出点时，则沿着裁剪窗口按顺时针方向搜集顶点序列。按上述规则，如此交替地沿着两个多边形的边线行进，直到回到起始点。这时，收集到的全部顶点序列就是裁剪所得的一个多边形。由于可能存在分裂的多边形，因此算法要考虑：将搜集过的入点的入点记号删去，以免重复跟踪。将所有的入点搜集完毕后算法结束。

二．Weiler－Atherton任意多边形裁剪算法步骤：

顺时针输入被裁剪多边形顶点序列Ⅰ放入数组1中。
顺时针输入裁剪窗口顶点序列Ⅱ放入数组2中。
求出被裁剪多边形和裁剪窗口相交的所有交点，并给每个交点打上“入”、“出”标记。然后将交点按顺序插入序列Ⅰ得到新的顶点序列Ⅲ，并放入数组3中；同样也将交点按顺序插入序列Ⅱ得到新的顶点序列Ⅳ，放入数组4中；
初始化输出数组Q，令数组Q为空。接着从数组3中寻找“入”点。如果“入”点没找到，程序结束。
如果找到“入”点，则将“入”点放入S中暂存。
将“入”点录入到输出数组Q中。并从数组3中将该“入”点的“入”点标记删去。
沿数组3顺序取顶点：如果顶点不是“出点”，则将顶点录入到输出数组Q中，流程转第7步。否则，流程转第8步。
沿数组4顺序取顶点：如果顶点不是“入点”，则将顶点录入到输出数组Q中，流程转第8步。否则，流程转第9步。
如果顶点不等于起始点S，流程转第6步，继续跟踪数组3。否则，将数组Q输出；流程转第4步，寻找可能存在的分裂多边形。算法在第4步：满足“入”点没找到的条件时，算法结束。算法的生成过程见下图所示。

三．Weiler－Atherton任意多边形裁剪算法特点：

裁剪窗口可以是矩形、任意凸多边形、任意凹多边形。
可实现被裁剪多边形相对裁剪窗口的内裁或外裁，即保留窗口内的图形或保留窗口外的图形，因此在三维消隐中可以用来处理物体表面间的相互遮挡关系。3、裁剪思想新颖，方法简洁，裁剪一次完成，与裁剪窗口的边数无关。

源码参考（C++）

1.基本变换矩阵

//计算变换矩阵
void CalculateMatrix(float transMatrix[3][2])
{
    
    
	Ccg2DTransDoc* pDoc = GetDocument();

	switch (pDoc->m_transDir) {
    
    
	case 0: // -X
		switch (pDoc->m_transMode) {
    
    
		case 0: // Move
			TranslateMatrix(-DELTAX, 0, transMatrix);
			break;
		case 1: // rotate
			RotateMatrix(-sin(DELTATHETA), cos(DELTATHETA), transMatrix);
			break;
		case 2: // Scale
			ScaleMatrix(SSCALEX, 1, transMatrix);
			break;
		}
		break;
	case 1: // +X
		switch (pDoc->m_transMode) {
    
    
		case 0: // Move
			TranslateMatrix(DELTAX, 0, transMatrix);
			break;
		case 1: // rotate
			RotateMatrix(sin(DELTATHETA), cos(DELTATHETA), transMatrix);
			break;
		case 2: // Scale
			ScaleMatrix(LSCALEX, 1, transMatrix);
			break;
		}
		break;
	case 2: // -Y
		switch (pDoc->m_transMode) {
    
    
		case 0: // Move
			TranslateMatrix(0, -DELTAY, transMatrix);
			break;
		case 1: // rotate
			RotateMatrix(-sin(DELTATHETA), cos(DELTATHETA), transMatrix);
			break;
		case 2: // Scale
			ScaleMatrix(1, SSCALEY, transMatrix);
			break;
		}
		break;
	case 3: // +Y
		switch (pDoc->m_transMode) {
    
    
		case 0: // Move
			TranslateMatrix(0, DELTAY, transMatrix);
			break;
		case 1: // rotate
			RotateMatrix(sin(DELTATHETA), cos(DELTATHETA), transMatrix);
			break;
		case 2: // Scale
			ScaleMatrix(1, LSCALEY, transMatrix);
			break;
		}
		break;
	}
}

//缩放矩阵
void Ccg2DTransView::ScaleMatrix(float Sx, float Sy, float m[3][2])
{
    
    
	for (int i = 0; i < 3; i++) {
    
    
		m[i][0] *= Sx;
		m[i][1] *= Sy;
	}
}

//旋转矩阵
void RotateMatrix(float S, float C, float m[3][2])
{
    
    
	float temp;
	for (int i = 0; i < 3; i++) {
    
    
		temp = m[i][0];
		m[i][0] = temp * C - m[i][1] * S;
		m[i][1] = temp * S + m[i][1] * C;
	}
}

//平移矩阵
void TranslateMatrix(float Tx, float Ty, float m[3][2])
{
    
    
	// 矩阵平移变换的位移量
	m[2][0] += Tx;
	m[2][1] += Ty;
}

2.绘制直线

//绘制直线
void DisplayLine(CDC* pDC, CPoint p1, CPoint p2, COLORREF rgbColor)
{
    
    
	CcgTransDoc* pDoc = GetDocument();

	CPen newPen;
	CPen* oldPen;
	CPoint VP1, VP2;

	newPen.CreatePen(PS_SOLID, 2, rgbColor);
	oldPen = (CPen*)pDC->SelectObject(&newPen);

	VP1.x = m_wndWidth / 2 + p1.x;
	VP1.y = m_wndHeight / 2 - p1.y;
	VP2.x = m_wndWidth / 2 + p2.x;
	VP2.y = m_wndHeight / 2 - p2.y;

	pDC->MoveTo(VP1);
	pDC->LineTo(VP2);

	pDC->SelectObject(oldPen);
	newPen.DeleteObject();
}

3.直线2D变换

//直线2D变换
void TransLine(CPoint p1, CPoint p2, CPoint* tp1, CPoint* tp2, float transMatrix[3][2])
{
    
    
	// 更改移动后的线段端点坐标p1, p2,利用矩阵乘法(x,y,1) * transMatrix[3][2]
	tp1->x = p1.x * transMatrix[0][0] +
			 p1.y * transMatrix[1][0] +
		            transMatrix[2][0];
	tp1->y = p1.x * transMatrix[0][1] +
			 p1.y * transMatrix[1][1] +
					transMatrix[2][1];
	tp2->x = p2.x * transMatrix[0][0] +
			 p2.y * transMatrix[1][0] +
					transMatrix[2][0];
	tp2->y = p2.x * transMatrix[0][1] +
			 p2.y * transMatrix[1][1] +
					transMatrix[2][1];
}

4.直线裁剪

1.Cohn-Sutherland Subdivision Line Clip

// Cohn-Sutherland Subdivision Line Clip
int  ClipLine(int* x1, int* y1, int* x2, int* y2)
{
    
    
	int visible, m_window[4];
	Ccg2DTransDoc* pDoc = GetDocument();
	//创建四条边
	m_window[0] = pDoc->m_wndLx;    m_window[1] = pDoc->m_wndRx;
	m_window[2] = pDoc->m_wndRy;    m_window[3] = pDoc->m_wndLy;
	for (int i = 0; i < 4; i++) {
    
     //沿着窗口四条边分别裁剪线段
		//先判断是否完全可见或完全不可见
		visible = LineVisible(x1, y1, x2, y2);
		if (visible == 1) return 1;         //整体完全可见
		if (visible == 0) return 0;         //整体完全不可见
		//其他情况：部分可见，且第一个点在窗口外
		if (LineCross(*x1, *y1, *x2, *y2, i)) {
    
    	//判断是否经过该边界
			if (i < 2 && *x2 - *x1) {
    
               //左边界和右边界
				float m = (float)(*y2 - *y1) / (*x2 - *x1); //计算斜率
				float iy = m * (m_window[i] - *x1) + *y1;	//计算出边界与线段的交点
				//更新端点，舍弃窗口边界之外的部分
				if (i == 0) {
    
    	//左边界
					if (*x1 < *x2) {
    
    
						*x1 = m_window[i];
						*y1 = iy;
					}
					else {
    
    		
						*x2 = m_window[i];
						*y2 = iy;
					}
				}
				else {
    
    		    //右边界
					if (*x1 > *x2) {
    
    
						*x1 = m_window[i];
						*y1 = iy;
					}
					else {
    
    
						*x2 = m_window[i];
						*y2 = iy;
					}
				}
			}
			else if (*y2 - *y1) {
    
               //上边界和下边界
				float m = (float)(*x2 - *x1) / (*y2 - *y1);
				float ix = m * (m_window[i] - *y1) + *x1;
				if (i == 2) {
    
    	//上边界
					if (*y1 > *y2) {
    
    
						*x1 = ix;
						*y1 = m_window[i];
					}
					else {
    
    
						*x2 = ix;
						*y2 = m_window[i];
					}
				}
				else {
    
    		    //下边界
					if (*y1 < *y2) {
    
    
						*x1 = ix;
						*y1 = m_window[i];
					}
					else {
    
    
						*x2 = ix;
						*y2 = m_window[i];
					}
				}
			}
		}
	}
	return 1;
}

int LineVisible(int* x1, int* y1, int* x2, int* y2)
{
    
    
	int pcode1, pcode2;
	// 为0表示位于框内部
	//| 0101 | 0100 | 0110 |
	//| 0001 | 0000 | 0010 |
	//| 1001 | 1000 | 1010 |
	pcode1 = pCode(x1, y1);
	pcode2 = pCode(x2, y2);

	if (!pcode1 && !pcode2)    return 1;     //完全可见
	if ((pcode1 & pcode2) != 0)  return 0;     //完全不可见
	if (pcode1 == 0) {
    
    
		float temp;
		temp = *x1;  *x1 = *x2;  *x2 = temp;
		temp = *y1;  *y1 = *y2;  *y2 = temp;
	}
	return 2;
}

int pCode(int* x, int* y)
{
    
    
	int code = 0;
	Ccg2DTransDoc* pDoc = GetDocument();

	if (*x <= pDoc->m_wndLx)  code |= 1;//左
	if (*x >= pDoc->m_wndRx)  code |= 2;//右
	if (*y >= pDoc->m_wndRy)  code |= 4;//上
	if (*y <= pDoc->m_wndLy)  code |= 8;//下

	return code;
}

int LineCross(int x1, int y1, int x2, int y2, int i)
{
    
    
	int visible1, visible2;

	visible1 = pVisible(x1, y1, i);
	visible2 = pVisible(x2, y2, i);

	if (visible1 != visible2) return 1;
	else                      return 0;

}

int pVisible(int x, int y, int i)
{
    
    
	int visible = 0;
	Ccg2DTransDoc* pDoc = GetDocument();

	switch (i) {
    
    
	case 0: //左边界
		if (x >= pDoc->m_wndLx)  visible = 1; break;
	case 1: //右边界
		if (x <= pDoc->m_wndRx)  visible = 1; break;
	case 2: //上边界
		if (y <= pDoc->m_wndRy)  visible = 1; break;
	case 3: //下边界
		if (y >= pDoc->m_wndLy)  visible = 1; break;
	}
	return visible;
}

2.Liang-Barsky Line Clip

// Liang-Barsky Line Clip
int Ccg2DTransView::LB_ClipLine(int* x1, int* y1, int* x2, int* y2)
{
    
    
	Ccg2DTransDoc* pDoc = GetDocument();
	float dx = *x1 - *x2, dy = *y1 - *y2;
	if (dy == 0) {
    
    	// 水平
		if (*x1 > * x2) {
    
    	//交换
			int temp = *x2;	*x2 = *x1;	*x1 = temp;
		}
		if (*y1 >= pDoc->m_wndRy || *y1 <= pDoc->m_wndLy)	//超出范围
			return 0;
		if ((*x1 >= pDoc->m_wndRx && *x2 >= pDoc->m_wndRx) || (*x1 <= pDoc->m_wndLx && *x2 <= pDoc->m_wndLx))	//超出范围
			return 0;
		if (*x1 <= pDoc->m_wndLx)
			*x1 = pDoc->m_wndLx;
		if (*x2 >= pDoc->m_wndRx)
			*x2 = pDoc->m_wndRx;
	}
	else if (dx == 0) {
    
       //垂直
		if (*y1 > * y2) {
    
    	// 交换
			int temp = *y2;	*y2 = *y1;	*y1 = temp;
		}
		if (*x1 >= pDoc->m_wndRx || *x1 <= pDoc->m_wndLx)	//超出范围
			return 0;
		if ((*y1 >= pDoc->m_wndRy && *y2 >= pDoc->m_wndRy) || (*y1 <= pDoc->m_wndLy && *y2 <= pDoc->m_wndLy))	//超出范围
			return 0;
		if (*y1 <= pDoc->m_wndLy)
			*y1 = pDoc->m_wndLy;
		if (*y2 >= pDoc->m_wndRy)
			*y2 = pDoc->m_wndRy;
	}
	else {
    
      //一般情况
		float x11, x22, y11, y22;

		int p1 = *x1 - *x2;
		int p2 = *x2 - *x1;
		int p3 = *y1 - *y2;
		int p4 = *y2 - *y1;

		int q1 = *x1 - pDoc->m_wndLx;
		int q2 = pDoc->m_wndRx - *x1;
		int q3 = *y1 - pDoc->m_wndLy;
		int q4 = pDoc->m_wndRy - *y1;

		float u1 = (float)q1 / p1;
		float u2 = (float)q2 / p2;
		float u3 = (float)q3 / p3;
		float u4 = (float)q4 / p4;

		int pk1, pk2, pk3, pk4;
		float uk1, uk2, uk3, uk4;
		if (p1 < 0) {
    
    
			pk1 = p1;
			uk1 = u1;
			pk3 = p2;
			uk3 = u2;
		}
		else {
    
    
			pk3 = p1;
			uk3 = u1;
			pk1 = p2;
			uk1 = u2;
		}
		if (p3 < 0) {
    
    
			pk2 = p3;
			uk2 = u3;
			pk4 = p4;
			uk4 = u4;
		}
		else {
    
    
			pk4 = p3;
			uk4 = u3;
			pk2 = p4;
			uk2 = u4;
		}

		float umax = max(0, max(uk1, uk2));
		float umin = min(1, min(uk3, uk4));

		if (umax > umin)
			return 0;
		else {
    
    
			x11 = *x1 + umax * (*x2 - *x1);
			y11 = *y1 + umax * (*y2 - *y1);
			x22 = *x1 + umin * (*x2 - *x1);
			y22 = *y1 + umin * (*y2 - *y1);

			*x1 = (int)(x11 + 0.5);
			*x2 = (int)(x22 + 0.5);
			*y1 = (int)(y11 + 0.5);
			*y2 = (int)(y22 + 0.5);
		}
		return 1;
	}
}

5.绘制多边形

//绘制多边形
void DisplayPolygon(CDC* pDC, int pointNumber,
	CPoint transPolygon[N], COLORREF rgbColor)
{
    
    
	CcgTransDoc* pDoc = GetDocument();

	CPen newPen;
	CPen* oldPen;
	CPoint VPolygon[N];

	newPen.CreatePen(PS_SOLID, 2, rgbColor);
	oldPen = (CPen*)pDC->SelectObject(&newPen);

	for (int i = 0; i < pointNumber; i++) {
    
    
		VPolygon[i].x = m_wndWidth / 2 + transPolygon[i].x;
		VPolygon[i].y = m_wndHeight / 2 - transPolygon[i].y;
	}

	pDC->MoveTo(VPolygon[0]);
	for (int i = 1; i < pointNumber; i++) pDC->LineTo(VPolygon[i]);

	pDC->SelectObject(oldPen);
	newPen.DeleteObject();
}

6.多边形2D变换

void Ccg2DTransView::TransPolygon(int pointNumber, CPoint spPolygon[N],
	CPoint transPolygon[N], float transMatrix[3][2])
{
    
    
	Ccg2DTransDoc* pDoc = GetDocument();

	for (int i = 0; i < pointNumber; i++) {
    
    
		transPolygon[i].x = spPolygon[i].x * transMatrix[0][0] +
							spPolygon[i].y * transMatrix[1][0] +
											 transMatrix[2][0];
		transPolygon[i].y = spPolygon[i].x * transMatrix[0][1] +
							spPolygon[i].y * transMatrix[1][1] +
											 transMatrix[2][1];
	}
}

7.多边形裁剪

Sutherland-Hodgman Polygon Clip

// Sutherland-Hodgman Polygon Clip
int Ccg2DTransView::ClipPolygon(int n, CPoint* tPoints, int* cn, CPoint* cPoints)
{
    
    
	int Nin, Nout, ix, iy, Sx, Sy;
	Ccg2DTransDoc* pDoc = GetDocument();

	Nin = n;
	for (int i = 0; i < 4; i++) {
    
      // Along the window border
		*cn = 0;
		for (int j = 0; j < Nin; j++) {
    
      // Scan polygon every point and line.
			if (j > 0) {
    
    
				if (LineCross(Sx, Sy, tPoints[j].x, tPoints[j].y, i)) {
    
    
					interSect(Sx, Sy, tPoints[j].x, tPoints[j].y, i, &ix, &iy);
					outPut(ix, iy, cn, cPoints);
				}
			}
			Sx = tPoints[j].x;
			Sy = tPoints[j].y;
			if (pVisible(Sx, Sy, i)) outPut(Sx, Sy, cn, cPoints);
		}

		Nin = *cn;
		if (*cn == 0) return 0;
		for (int j = 0; j < Nin; j++) {
    
    
			tPoints[j].x = cPoints[j].x;
			tPoints[j].y = cPoints[j].y;
		}

		if (cPoints[0].x != cPoints[Nin - 1].x ||
			cPoints[0].y != cPoints[Nin - 1].y) {
    
    

			tPoints[Nin].x = cPoints[Nin].x = cPoints[0].x;
			tPoints[Nin].y = cPoints[Nin].y = cPoints[0].y;

			Nin++;
			*cn = Nin;
		}
	}
	return 1;
}

void interSect(int Sx, int  Sy, int Px, int Py,
	int  i, int* ix, int* iy)
{
    
    
	Ccg2DTransDoc* pDoc = GetDocument();

	switch (i) {
    
    
	case 0: // Left
		*ix = pDoc->m_wndLx;
		*iy = (Sy - Py) * (pDoc->m_wndLx - Px) / (Sx - Px) + Py;
		break;
	case 1: // Right
		*ix = pDoc->m_wndRx;
		*iy = (Sy - Py) * (pDoc->m_wndRx - Px) / (Sx - Px) + Py;
		break;
	case 2: // Top
		*iy = pDoc->m_wndRy;
		*ix = (Sx - Px) * (pDoc->m_wndRy - Py) / (Sy - Py) + Px;
		break;
	case 3: // Bottom
		*iy = pDoc->m_wndLy;
		*ix = (Sx - Px) * (pDoc->m_wndLy - Py) / (Sy - Py) + Px;
		break;
	}
}

void outPut(int x, int y, int* cn, CPoint* cPoints)
{
    
    
	cPoints[*cn].x = x;
	cPoints[*cn].y = y;
	(*cn)++;
}

void CCgTransControl::ViewTransLine(CDC* pDC, CRect dcRect)
{
    
    
	CPen newPen;
	CPen* oldPen;
	Ccg2DTransDoc* pDoc = (Ccg2DTransDoc*)GetDocument();

	// Create new red-color pen to Draw Clipping Line
	newPen.CreatePen(PS_SOLID, 2, RGB(255, 255, 0));
	oldPen = (CPen*)pDC->SelectObject(&newPen);

	int vx1, vy1, vx2, vy2;

	int wndWidth = pDoc->m_wndRx - pDoc->m_wndLx;  // Space Window size parameters.
	int wndHeight = pDoc->m_wndRy - pDoc->m_wndLy;

	float Sx = (float)(dcRect.right) / wndWidth;    // View-Space Viewport size parameters.
	float Sy = (float)(dcRect.bottom) / wndHeight;

	vx1 = (pDoc->CP1.x - pDoc->m_wndLx) * Sx;
	vy1 = (pDoc->CP1.y - pDoc->m_wndLy) * Sy;
	vx2 = (pDoc->CP2.x - pDoc->m_wndLx) * Sx;
	vy2 = (pDoc->CP2.y - pDoc->m_wndLy) * Sy;

	pDC->MoveTo(vx1, dcRect.bottom - vy1);
	pDC->LineTo(vx2, dcRect.bottom - vy2);

	// Remember: must delete newPen every time.	
	pDC->SelectObject(oldPen);
	newPen.DeleteObject();
}

void CCgTransControl::ViewTransPolygon(CDC* pDC, CRect dcRect)
{
    
    
	CPen newPen;
	CPen* oldPen;
	Ccg2DTransDoc* pDoc = (Ccg2DTransDoc*)GetDocument();

	// Create new red-color pen to Draw Clipping Line
	newPen.CreatePen(PS_SOLID, 2, RGB(0, 255, 255));
	oldPen = (CPen*)pDC->SelectObject(&newPen);

	CPoint m_VPolygon[N];

	int wndWidth = pDoc->m_wndRx - pDoc->m_wndLx;  // Space Window size parameters.
	int wndHeight = pDoc->m_wndRy - pDoc->m_wndLy;

	float Sx = (float)(dcRect.right) / wndWidth;    // View-Space Viewport size parameters.
	float Sy = (float)(dcRect.bottom) / wndHeight;

	for (int i = 0; i < pDoc->m_clipPointNumber; i++) {
    
    
		m_VPolygon[i].x = (pDoc->m_clipPolygon[i].x - pDoc->m_wndLx) * Sx;
		m_VPolygon[i].y = dcRect.bottom - (pDoc->m_clipPolygon[i].y - pDoc->m_wndLy) * Sy;
	}

	pDC->MoveTo(m_VPolygon[0]);
	for (int i = 1; i < pDoc->m_clipPointNumber; i++) pDC->LineTo(m_VPolygon[i]);

	// Remember: must delete newPen every time.	
	pDC->SelectObject(oldPen);
	newPen.DeleteObject();
}