计算机图形学计算机图形学-图形学代码

〃DDA画直线响应函数

voidCLine_ScanView::OnLineDda()

(

//TODO:在此添加命令处理程序代码

LineI;

LDoModal();

DDALine(l.xlJ.ylJ.x2,l.y2,NULL);

)

〃Bresenham画直线响应函数

voidCLine_ScanView::OnLineBresenham()

(

//TODO:在此添加命令处理程序代码

LineI;

LDoModal();

BresenhamLine(l.xlJ.yl,l.x2,l.y2,NULL);

}

〃中点Bresenham而直线响应函数

voidCLine_ScanView::OnLineMidbresenham()

{

//TODO:在此添加命令处理程序代码

LineI;

LDoModalf);

x

MidBresenhamLine(l.xl,l.yl/l-2J.y2,NULL);

}

//DDA画直线算法

voidCLine_ScanView::DDALine(intxl,intyl,intx2,inty2,intcolor)

(

intdx,dy,epsl,k;

floatx=10,y=10,xlncreJylncre;

dx=x2-xl;

dy=y2-yl;

k=dy/dx;

y=yi;

if(abs(dx)>abs(dy))

epsl=abs(dx);

else

epsl=abs(dy);

xlncre=(float)dx/(float)epsl;

ylncre=(float)dy/(float)epsl;

CCIientDCdc(this);

for(k=0;k<=epsl;k++){

dc.SetPixel((int)x.(int)y,color);

x+=xlncre;

y+=ylncre;

)

)

//MidBresenham画直线算法

voidCLine_ScanView::MidEresenhamLine(intxl,intyl,intx2,inty2,intcolor)

(

intdx,dy,d,Uplncre,Downlncre,x,y;

if(xl>x2){

x=x2;x2=xl;xl=x;

y=y2;y2=yl;yl=y;

)

x=xl;

y=yi;

dx=x2-xl;

dy=y2-yl;

d=dx-2*dy;

CCIientDCdc(this);

Uplncre=2*dx-2*dy;

Downlncre=-2*dy;

while(x<=x2){

dc.SetPixel(x,y,color);

x++;

if(d<0){

V++；

d+=Uplncre;

)

else

d+=Downlncre;

)

}

//Bresenham画宜线算法

voidCLine_ScanView::BresenhamLine(intxl,intyl,intx2,inty2,intcolor)

{

intx,y,dx,dy,e;

dx=x2-xl;

dy=y2-yl；

e=-dx;

x=xl;

y=yi;

CCIientDCdc(this);

while(x<=x2){

de.SetPixel(x,y,color);

x++;

e=e+2*dy;

if(e>0){

y++;

e=e-2*dx;

)

)

)

//中点画圆响应函数

voidCLine_ScanView::OnCixleMidbresenham()

{

//TODO:在此添加命令处理程序代码

Circlec;

c.DoModal();

MidBresenhamCircle(c.r,NULL);

)

//中点画圆算法

voidCLine_ScanView::MidBresenhamCircle(intr,intcolor)

{

intx=0;

inty=r;

intd=1-r;

intxO=100;

intyO=100;

CDC*pDC=GetDC();

while(x<=y){

pDC->SetPixel(x+xO,y+yO,color);

pDC->SetPixel(-x+xO,y+yO,color);

pDC->SetPixel(-x+xO,-y+yO,color);

pDC->SetPixel(x+xO,-y+yO,color);

pDC->SetPixel(y+xOzx+yO,color);

pDC->SetPixel(-y+xO,x+yO,color);

pDC->SetPixel(-y+xO,-x+yO,color);

pDC->SetPixel(y+xO,-x+yOzcolor);

if(d<0)

d+=2*x+3;

else{

d+=2*(x-y)+5;

y-;

)

x++;

)

}

〃中点画椭圆响应函数

voidCLine_ScanView::OnEllipseMidbresenham()

(

//TODO:在此添加命令处理程序代码

TuoYuanty;

ty.DoModal();

MidBresenhamEllipse代.ya,ty.b,NULL);

)

//中点画椭圆算法

voidCLine_ScanView::MidEresenhamEllipse(inta,intb,intcolor)

{

intx=0;

inty=b;

intxO=100;

intyO=100;

floatdl,d2;

dl=b*b+a*a*(-b+0.25);

CDC*pDC=GetDC();

pDC->SetPixel(x+xO,y+yO,color);

pDC->SetPixel(-x+xO,-y+yO,color);

pDC->SetPixel(-x+xO,y+yO,color);

pDC->SetPixel(x+xO,-y+yO,color);

while(b*b*(x+l)<a*a*Jy-0.5)){

if(dl<0){

dl+=b*b*(2xx+3);

x++;

)

else{

dl+=b*b*(2xx+3)+a*a*(-2*y+2);

x++;

y-;

)

pDC->SetPixel(x+xO,y+yO,color);

pDC->SetPixel(-x+xO,-y+yO,color);

pDC->SetPixel(-x+xO,y+yO,color);

pDC->SetPixel(x+xO,-y+yO,color);

)

d2=b*b*(x+0.5)*(x+0.5)+a*a*(y-l)*(y-l)-a*a*b*b;

while(y>0){

if(d2<=0){

d2+=b*b*(2xx+2)+a*a*(-2*y+3);

x++;

y--;

)

else{

d2+=a*a*(-2*y+3);

y-;

)

pDC->SetPixel(x+xO,y+yO,color);

pDC->SetPixel(-x+xO,-y+yO,color);

pDC->SetPixel(-x+xO,y+yO,color);

pDC->SetPixel(x+xO,-y+yO,color);

)

//多边形的扫描转换响应函数

voidCLine_ScanView::OnPolygonScan()

(

//TODO:在此添加命令处理程序代码

CDC*pDC=GetDC();

constintPOINTNUM=6;〃多边形点数.

/******定义结构体用于活性边表AET和新边表

NET***********************************/

typedefstructXET

(

floatx;

floatdx,ymax;

XET*next;

}AET,NET;

/"****定义点结构体pQjp^******♦♦***♦*♦*♦*♦*♦***♦*****♦♦*♦*********************I

structpoint

(

floatx;

floaty;

}polypoint[POINTNUM]={250,50,550,150,550,400,250,250,100,350,100,100};〃多边形顶点

//mypoint[POINTNUM]={100,100,200,100,200,200,100/200};//iEZj^

*****计算最高点的y坐标(扫描到此结束)**********，****************************

intMaxY=O;

inti;

for(i=0;i<POINTNUM;i-+)

if(polypoint[i].y>MaxY)

MaxY=polypoint[i].y;

******初始化AET表*******************************************************X***/

AET*pAET=newAET;

pAET->next=NULL;

*****初j好[f匕NET表************************************************************

NET*pNET(1024];

for(i=0;i<=MaxY;i++)

(

pNET[i]=newNET;

pNET[i]->next=NULL;

)

/****♦♦扫描并建立NET表

*********************************************************/

for(i=0;i<=MaxY;i++)

(

forfintj=0;j<POINTNUM;j++)

if(polypoint[j].y==i)

{

if(polypoint[(j-l+POINTNUM)%POINTNUM].y>polypoint[j].y)

(

NET*p=newNET;

p->x=polypoint[j].x;

p->ymax=polypoint[(j-l+POINTNUM)%POINTNUM].y;

p->dx=(polypoint[(j-l+POINTNUM)%POINTNUM].x-polypoint[j].x)/(polypoint[(j-l+POINTNUM)%

POINTNUM].y-polypoint[j].y);

p->next=pNET[i]->next;

pNET[i]->next=p;

)

if(polypoint[(j+l+POINTNUM)%POINTNUM].y>polypoint(j].y)

(

NET*p=newNET;

p->x=polypoint[j].x;

p->ymax=polypoint[(j+l+POINTNUM)%POINTNUM].y;

p->dx=(polypoint[(j+l+POINTNUM)%POINTNUM].x-polypoint[j].x)/(polypoint[(j+l+POINTNlM)%

POINTNUM).y-polypo>nt[j].y);

p->next=pNET[i]->next;

pNET[i]->next=p;

)

)

/******建立并更新活性边表

AET*****************************************************

for(i=0;i<=MaxY;i++)

//计算新的交点x,更新

AET********************************************************/

NET*p=pAET->next;

while(p)

p->x=p->x+p->dx;

p=p->next;

)

//更新后新AET先排序

************************************************************

*/

〃断表排序,不再开辟空间

AET*tq=pAET;

p=pAET->next;

tq->next=NULL;

while(p)

(

while(tq->next&&p->x>=tq->next->x)

tq=tq->next;

NET*s=p->next;

p->next=tq->next;

tq->next=p;

P=s；

tq=pAET;

)

//(改进算法)先从AET表中删除ymax==i的结点

****************************************/

AET*q=pAET;

p=q->next;

while(p)

{

if(p->ymax==i)

q->next=p->next;

deetep;

p=q->next;

else

{

q=q->next;

p=q->next;

)

)

〃将NET中的新点加入AET,并用插入法按X值递增排序

**********************************/

p=pNET[i]->next;

q=pAET;

while(p)

{

while(q->next&&p->x>=q->next->x)

q=q->next;

NET*s=p->next;

p->next=q->next;

q->next=p;

P=s；

q=pAET:

)

/******配对填充颜色

***************************************************************/

p=pAET->next;

while(p&&p->next)

for(floatj=p->x;j<=p->next->x;j++)

pDC->SetPixel(static_cast<int>(j),i/RGB(255,0,0));

p=p->next->next;〃考虑端点情况

)

)

)

//多边形的4种子填充响应函数

voidCLine_ScanView::OnPolygonArea4()

(

//TODO:在此添加命令处理程序代码

DuoBianXingdbx;

dbx.DoModal();

BoundaryFill4(dbx.x,dox.y,RGB(0,255,0),RGB(255,0,0));

)

//多边形的4种子填充算法

voidCLine_ScanView::BoundaryFill4(intx,inty,intboundarycolor,intnewcolor)

CDC*pDC=GetDC();

CPenpen;

pen.CreatePen(RS_SOUDz2,RGB(0,255,0));

pDC->SelectObject(&pen);

inta[4][2]={200,100,180,120,220,120,200,100};

pDC->MoveTo(a[0][0],a[0][l]);

for(inti=0;i<4;i++){

pDC->LineTo(a[i][0]/a[i][l]);

)

intcolor=pDC->GetPixel(xzy);

if(color!=newcolor&&color!=boundarycolor){

pDC->SetPixel(x,y.newcolor);

BoundaryFill4(x/yfl/boundarycolor,newcolor);

BoundaryFill4(xyl,boundarycolor,newcolor);

BoundaryFill4(x+l,y,boundarycolor,newcolor);

BoundaryFill4(x-l,y,boundarycolor,newcolor);

)

)

//多边形的8种子填充响应函数

voidCLine_ScanView::OnPolygonArea8()

(

//TODO:在此添加命令处理程序代码

DuoBianXingdbx;

dbx.DoModal();

BoundaryFill8(dbx.x,dbx.y,RGB(0,255,0),RGB(255,0,0));

//多边形的8种子填充算法

voidCLine_ScanView::BoundaryFill8(intx,inty,intboundarycoloointnewcolor)

|

CDC*pDC=GetDC();

CPenpen;

pen.CreatePen(PS_SOSD,2,RGB(0,255,0));

pDC->SelectObject(&pen);

inta[4][2]={200,100480,120,220,120,200,100};

pDC->MoveTo(a[0][0],a[0][l]);

for(inti=0;i<4;i++){

pDC->LineTo(a[i][0]/a[i][l]);

)

intcolor=pDC->GetPixel(x,y);

if(color!=newcolor&&color!=boundarycolor){

pDC->SetPixel(x,y,newcolor);

BoundaryFillSfx^-nl,boundarycolor,newcolor);

BoundaryFill8(x+l,y+l,boundarycolor,newcolor);

BoundaryFillSfx^-l^oundarycoloGnewcolor);

BoundaryFill8(x-l,y-l,boundarycolorznewcolor);

BoundaryFill8(x+l,y,boundarycolor,newcolor);

BoundaryFill8(x+l,y-l,boundarycolor,newcolor);

BoundaryFill8(x-l,y,boundarycolor,newcolor);

BoundaryFill8(x-1,7+1,boundarycolor,newcolor);

)

}

//二维变换的比例变换响应函数

voidCLine_ScanView::OnTv/oProportion()

{

//TODO:在此添加命令处理程序代码

CCIientDCdc(this);

CPenpenl;

penl.CreatePen(PS_S0LID/2,RGB(255z10,255));

int

3[11][2]={100,105,90,135,60,135,85,155,75,185,100,165,125,185,115,155,140,135,110,135,100,

105);

dc.SelectObject(&penl);

dc.MoveTo(a[0][0],a[C][l]);

for(inti=0;i<ll;i++){

dc.LineTo(a[i][0],a[i][l]);

)

doublesx=0.5,sy=0.5;

dc.MoveTo(a[0][0]*sx,a[0][l]*sy);

for(inti=0;i<ll;i++){

dc.LineTo(a[i][O]*sxza[i][l]*sy);

Sleep(5);

)

penl.DeleteObject();

)

//二维变换的旋转变换响应函数

voidCLine_ScanView::OnTv/oRotating()

(

//TODO:在此添加命令处理程序代码

CCIientDCdc(this);

CPenpenl;

penl.CreatePen(PS_S0LID,2,RGB(255,10,255));

int

a[ll](2]={100,105,90,135,60,135,85,155,75,185,100,165,125,185,115,155,140,135,110,135,100,

105);

dc.SelectObject(&penl);

dc.MoveTo(a[O][O],a[C][l]);

for(inti=0;i<ll;i++){

dc.LineTo同」[0]月皿1]);

)

intt=600;

dc.MoveTo(a[0][0]*cos((t/6)*1.0)-a[0][l]*sin((t/6)*1.0),//一个点

a[0][0]*sin((t/6)*1.0)+a[0][l]*cos((t/6)*1.0));

for(inti=0;i<ll;i++){

dc.LineTo(a[i]⑼*cos((t/6)*1.0)-a「][l]*sin((t/6)*L0),〃一个点

a[i][0]*sin((t/6)*1.0)+a[i][l]*cos((t/6)*1.0));

)

penl.DeleteObject();

)

//二维变换的错切变换响应函数

voidCLine_ScanView::OnTv/oShear()

{

//TODO:在此添加命令处理程序代码

CCIientDCdc(this);

CPenperil;

penl.CreatePen(PS_S0LID,2,RGB(255,10,255));

int

a[ll][2]={100,105,90,135,60,135,85,155,75,185,100,165,125,185,115,155,140,135,110,135,100,

105};

dc.SelectObject(&penl);

dc.MoveTo

for(inti=0;i<ll;i++){

dc.LineTo(a[i][0],a[i][l]);

)

doublec=2zd=1.5,u=50;

dc.MoveTo(a[0][0]+c*a[0][l]/a[0][l]-u);

for(inti=0;i<ll;i++){

dc.LineTo(a[i][0]+c*a[i][l],a[i][l]-u);

)

ints=170,h=200;

dc.MoveTo(a[O][O]+szd*a[O][O]+a[O][l]-h);

for(inti=0;i<ll;i++){

dc.LineTo(a[i][0]+szd*a[i](0]+a[i][l]-h);

)

penl.DeleteObject();

//二维变换的对称变换响应函数

voidCLine_ScanView::OnTv/oSymmetry()

(

//TODO:在此添加命令处理程序代码

CCIientDCdc(this);

CPenperil;

penl.CreatePen(PS_S0LID,2,RGB(255,10,255));

int

a[ll][2]={100,105,90,135,60,135,85,155,75,185,100,165,125,185,115,155,140,135,110,135,100,

105);

dc.SelectObject(&penl);

dc.MoveTo(a[0][0],a[C][l]);

for(inti=0;i<ll;i++){

dc.LineTo(a[i](O],a[iKl));

)

intm=0,b=200;

个点

dc.MoveTo(a[0][0]*(l-m*m)/(l+m*m)+2*(a[0][l]-b)*m/(l+m*m)z//—

a[0][0]*(2*m)/(l+m*m)+(a[0][l]-b)*(m*m-l)/(l+m*m)+b);

for(inti=0;i<ll;i++){

dc.LineTo(a[i][0]*(l-m*mi/(l+m*m)+2*(a[i][l]-b)*m/(l+m*m)/

a[i][0]*(2*m)/(l+m*m)+(a[][l]-b)*(m*m-l)/(l+m*m)+b);

)

penl.DeleteObject();

)

//一维变换的平移变换响应函数

voidCLine_ScanView::OnTv/oTranslation()

{

//TODO:在此添加命令处理程序代码

CCIientDCdc(this);

CPenperil;

penl.CreatePen(PS_S0LID,2,RGB(255,10,255));

int

a[ll]⑵={100,105,90,135,60,135,85,155,75,185,100,165,125,185,115,155,140,135,110,135,100,

105};

dc.SelectObject(&penl);

dc.MoveTo

for(inti=0;i<ll;i++){

dc.LineTo(a[i][0],a[i][l]);

)

inttx=120,ty=100;

dc.MoveTo(a[0][0]+tx,a[0][l]+ty);

for(inti=0;i<ll;i++){

dc.LineTo(a[i][O]+tx,a[i][l]+ty);

)

penl.DeleteObject();

)

//三维变换的比例变换响应函数

voidCLine_ScanView::OnTI'reeProportion()

(

//TODO:在此添加命令处理程序代码

CCIientDCdc(this);

CPenpenl,pen2;

penl.CreatePen(PS_SOLIDz2,RGB(O/O/O));

pen2.CreatePen(PS_S0LID,2,RGB(0,255/0));

inta[4][4]={100,150,0,1,50,200,0,1,150,200,0,1,100,150,0,";

dc.SelectObject(&penl);

dc.MoveTo(3[0][0],3[0][1]);

for(inti=0;i<4;i++){

dc.LineTo(a[i](OLa[i][l])；

)

intb[4][4]={2,0,0,0,02,0,0,0,0,2,0,0,0,0,1};

intc[4][4];

for(inti=0;i<4;i++){

forfintj=0;j<4;j++|{

c[i][j]=O;

)

)

for(inti=0;i<4;i++){

for(intj=0;j<4;j++|{

forfintk=0;k<4;k++){

c[i皿=c[i皿+a皿k]*b[k皿；

)

)

)

dc.SelectObject(&pen2);

dc.MoveTo(c[0][0]zc[0][l]);

for(inti=0;i<4;i++){

dc.LineTo(c[i][0]zc[i][l]);

)

penl.DeleteObject();

pen2.DeleteObject();

)

//三维变换的旋转变换响应函数

voidCLine_ScanView::OnThreeRotating()

//TODO:在此添加命令处理程序代码

CCIientDCdc(this);

CPenpenl,pen2;

penLCreatePen(PS_SOLID,2,RGB(O,O,O));

pen2.CreatePen(PS_SOLID,2,RGB(255,O,O));

inta[4][4]={100,150,0,1,50,200,0,1,150,200,0,1,100,150,0,1};

dc.SelectObject(&penl);

dc.MoveTo(a[O][O],a[C][l]);

for(inti=0;i<4;i++){

dc.LineTo(a[i][0],a[i][l]);

)

intt=600;

dc.SelectObject(&pen2);

dc.MoveTo(a[0][0]*cos((t/6)*1.0)-a[0][l]*sin((t/6)*1.0),//-

a[0][0]*sin((t/6)*1.0)+a[0][l]*cos((t/6)*1.0));

for(inti=0;i<4;i++){

dc.LineTo(a皿0r85((t/G)*1.0)-a[i][l]*sin((t/G)*1.0),〃一个点

a[i][0]*sin((t/6)*1.0)+a[i][l]*cos((t/6)*1.0));

)

penl.DeleteObject();

pen2.DeleteObject();

)

//三维变换的错切变换响应函数

voidCLine_ScanView::OnTbreeShear{)

{

//TODO:在此添加命令处理程序代码

CCIientDCdc(this);

CPenpenlzpen2;

penl.CreatePen(PS_S0LID,2,RGB(0,0,0));

pen2.CreatePen(PS_SOLID,2,RGB(255,255,0));

inta[4][4]={100,150,0,1,50,200,0,1,150,200,0,1,100,150,0,1};

dc.SelectObject(&penl);

dc.MoveTo(a[O][O],a[C][l]);

for(inti=0;i<4;i++){

dc.LineTo(a[i][OLa[i][l]);

)

intb[4][4]={1,2,0,0,15,1,0,0,0,0,1,0,0,0,0,1};

intc[4][4];

for(inti=0;i<4;i++){

forfintj=0;j<4;j++|{

c[i皿=0；

}

}

for(inti=0;i<4;i++){

forfintj=0;j<4;j++|{

for(intk=0;k<4;k++){

c[i]U]=c[i][j]+a[i][k]*b[k]U];

)

}

)

dc.SelectObject(&pen2);

dc.MoveTo(c[0][0],c[0][l]);

for(inti=0;i<4;i++){

dc.LineTo(c[i][0],c[i][l]);

)

penl.DeleteObject();

pen2.DeleteObject();

)

//二维变换的对称变换响应函数

voidCLine_ScanView::OnTbreeSymmetry()

{

//TODO:在此添加命令处理程序代码

CCIientDCdc(this);

CPenpenl,pen2;

penl.CreatePen(PS_S0LID,2,RGB(0,0,0));

pen2.CreatePen(PS_SOLID,2,RGB(O,255/255));

inta[4][4]={100,150,0,1,50,200,0,1,150,200,0,1,100,150,0,1};

dc.SelectObject(&penl);

dc.MoveTo(a[0][0],a[C][l]);

for(inti=0;i<4;i++){

dc.LineTo(a[i][OLa[i][l]);

)

intb[4][4]={0,1,0,0,100,0,0,0,1,0,0,0,0,1};〃沿y=x对称

intc[4][4];

for(inti=0;i<4;i++){

forfintj=0;j<4;j++|{

c[i)U)=O;

)

)

for(inti=0;i<4;i++){

forfintj=0;j<4;j++|{

for(intk=0;k<4;k++){

c[i]U]=c[i]U]+a[i][k]*b[k](j];

)

}

}

dc.SelectObject(&pen2);

dc.MoveTo(c[0][0],c[0][l]);

for(inti=0;i<4;i++){

dc.LineTo(c[i][0],c[i][l]);

)

penl.DeleteObject();

pen2.DeleteObject();

)

//三维变换的平移变换响应函数

voidCLine_ScanView::OnTI*reeTranslation()

(

//TODO:在此添加命令处理程序代码

CCIientDCdc(this);

CPenpenlzpen2;

penl.CreatePen(PS_SOLID,2,RGB(O,O,O));

pen2.CreatePen(PS_SOLID/2,RGD(0/0,255));

inta[4][4]={100,150,0,1,50,200,0,1,150,200,0,1,100,150,0,1};

dc.SelectObject(&penl);

dc.MoveTo(a[O][O],a[C][l]);

for(inti=0;i<4;i++){

dc.LineTo(a[i][OLa[i][l]);

)

intb[4][4]={1,0,0,0,0,1,0,0,0,0,1,0,100,100,0,1};

intc[4][4];

for(inti=0;i<4;i++){

for(intj=0;j<4;j++|{

c[i]U)=O；

)

)

for(inti=0;i<4;i++){

for(intj=0;j<4;j++|{

for(intk=0;k<4;k++){

c[i]D]=c[i][j]+a[i][k]*b[k]U];

)

)

)

dc.SelectObject(&pen2);

dc.MoveTo(c[0][0],c[0][l]);

for(inti=0;i<4;i++){

dc.LineTo(c[i][0]/c[i][l]);

)

penl.DeleteObject();

pen2.DeleteObject();

//直线段CS裁剪算法的响应函数

voidCLine_ScanView::OnLineCs()

(

//TODO:在此添加命令处理程序代码

Line_Cut1c;

lc.DoModal();

intmin_clip_x=100zmin_clip_y=100,max_clip_x=300,max_clip_y=300;

CCIientDCdc(this);

dc.MoveTo(min_clip_x,min_clip_y);

dc.LineTo(min_clip_x,nax_clip_y);

dc.MoveTo(min_clip_x,max_clip_y);

dc.LineTo(max_clip_x,max_clip_y);

dc.MoveTo(max_clip_>:,max_clip_y);

dc.LineTo(max_clip_x,min_clip_y);

dc.MoveTo(max_clip_>:?min_clip_y);

dc.LineTo(min_clip_x,min_clip_y);

if(CutLine(lc.xOJc.yO,lcxlJc.yl)){

dc.MoveTo(lc.xO,lc.yO);

dc.LineTo(lc.xlJc.yl);

)

)

//直线段中点分割算法的响应函数

voidCLine_ScanView::OnLineMidpoint()

{

//TODO:在此添加命令处理程序代码

intxO,yO,xl,yl;

CCIientDCdc(this);

intmin_clip_x=100/min_clip_y=100zmax_clip_x=300,max_clip_y=300;

dc.MoveTo(min_clip_x,min_clip_y);

dc.LineTo(min_clip_x,max_clip_y);

dc.MoveTo(min_clip_x,max_clip_y);

dc.LineTo(max_clip_x,max_clip_y);

dc.MoveTo(max_clip_>:/max_clip_y);

dc.LineTo(max_clip_x,min_clip_y);

dc.MoveTo(max_clip_>:,min_clip_y);

dc.LineTo(min_clip_x,min_clip_y);

x0=120;y0=90;xl=310,yl=310;

Mid_CutLine(xO,yO,xl,/l);

)

/*voidCLine_ScanView::CompOutCode(intx,inty,CRect*rect,OutCode*outCode)

(

outCode->all=0;

outCode->top=outCode->bottom=0;

if(y<rect->top)

(

outCode->top=1;

outCode->all+=1;

)

elseif(y>rect->bottom)

(

outCode->bottom=1;

outCode->all+=1;

)

outCode->right=outCDde->left=0;

if(x>rect->right)

(

outCode->right=1;

outCode->all+=1;

)

elseif(x<rect->left)

{

outCode->left=1;

outCode->all+=1;

)

)*/

//直线段的CS裁剪算法

intCLine_ScanView::CutLine(int&xO,int&yO,int&xl,int&yl)

(

#defineCLIP_CODE_CDxOOOO

^defineCLIP_CODE_N0x0008

//defineCLIP_CODE_S0x0004

#defineCLIP_CODE_E0x0002

#defineCLIP_CODE_W0x0001

#defineCLIPCODENE0x000a

#defineCLIP_CODE_SE0x0006

#defineCLIP_CODE_NW0x0009

#defineCLIP_CODE_SW0x0005

intxcO=xO,ycO=yO,xcl=xl,ycl=yl;

intmin_clip_x=100/min_clip_y=100,max_clip_x=300,max_clip_y=300;

intpO_code=0zpl_code=0;

〃确定各个顶点所在的位置代码

if(yO<min_clip_y)

pO_code|=CLIP_CODE_N;

elseif(yO>max_clip_y)

pO_code|=CLIP_CODE_S;

if(xO<min_clip_x)

pO_code|=CLIP_CODE_W;

elseif(xO>max_clip_x)

pO_code|=CLIP_CODE_E;

if(yl<min_clip_y)

pl_code|=CLIP_CODE_N;

elseif(yl>max_clip_y)

pl_code|=CLIP_CODE_S;

if(xl<min_clip_x)

pl_code|=CLIP_CODE_W;

elseif(xl>max_clip_x)

pl_code|=CLIP_CODE_E;

〃先检测一些简单的情况

if(pO_code&pl_code)〃有相同的位置代码，表示在裁剪区外部

return0;

if(p0_code==0&&pl_code==0)〃表示两个点都在裁更区内，不需要裁剪

return1;

〃判断第一个点的位置代码

switch(pO_code)

(

caseCLIP_CODE_C:

break;

caseCLIP_CODE_N:

ycO=min_clip_y;

xcO=xO+0.5+(ycO-yO)*(xl-xO)/(yl-yO);

break;

)

caseCLIP_CODE_S:

(

ycO=max_clip_y;

xcO=xO+0.5+(ycO-yO)*(xl-xO)/(yl-yO);

break;

)

caseCLIP_CODE_W:

(

xcO=min_clip_x;

yc0=y0+0.5+(xc0-x0)*(yl-y0)/(xl-x0);

break;

)

caseCLIP_CODE_E:

(

xcO=max_clip_x;

ycO=yO+O.5+(xcO-xO)*(yl-yO)/(xl-xO);

break;

)

caseCLIP_CODE_NE:

(

ycO=min_clip_y;

xcO=xO+0.5+(ycO-yO)*(xl-xO)/(yl-yO);

if(xcO<min_clip_x||xcO>max_clip_x)

(

xcO=max_clip_x;

ycO=yO+O.5+(xcO-xO)*(yl-yO)/(xl-xO);

)

break;

)

caseCLIP_CODE_SE:

(

ycO=max_clip_y;

xcO=xO+0.5+(ycO-yO)*(xl-xO)/(yl-yO);

if(xcO<min_clip_x11xcO>max_clip_x)

(

xcO=max_clip_x;

ycO=yO+O.5+(xcO-xO)*(yl-yO)/(xl-xO);

)

break;

)

caseCLIPCODENW:

ycO=min_clip_y;

xcO=xO+0.5+(ycO-yO)*(xl-xO)/(yl-yO);

if(xcO<min_clip_x||xcO>max_clip_x)

{

xcO=min_clip_x;

ycO=yO+O.5+(xcO-xO)*(yl-yO)/(xl-xO);

)

break;

)

caseCLIP_CODE_SW:

(

ycO=max_clip_y;

xcO=xO+0.5+(ycO-yO)*(xl-xO)/(yl-yO);

if(xcO<min_clip_x||xcO>max_clip_x)

{

xcO=min_clip_x;

ycO=yO+O.5+(xcO-xO)*(yl-yO)/(xl-xO);

)

break;

)

default:

break;

}//endswitch(pO_code)

〃判断第二个点的位置代码

switch(pl_code)

(

caseCLIP_CODE_C:

break;

caseCLIP_CODE_N:

(

ycl=min_clip_y;

xcl=xl+0.5+(ycl-yl)*(xl-xO)/(yl-yO);

break；

)

caseCLIP_CODE_S:

ycl=max_clip_y;

xcl=xl+0.5+(ycl-yl)*(xl-xO)/(yl-yO);

break;

)

caseCLIP_CODE_W:

(

xcl=min_clip_x;

ycl=yl+0.5+(xcl-xl)*(yl-y0)/(xl-x0);

break;

)

caseCLIP_CODE_E:

(

xcl=max_clip_x;

ycl=yl+0.5+(xcl-xl)*(yl-y0)/(xl-x0);

break;

)

caseCLIP_CODE_NE:

(

ycl=min_clip_y;

xcl=xl+0.5+(ycl-yl)*(xl-x0)/(yl-y0);

if(xcl<min_clip_x11xcl>max_clip_x)

(