多边形填充 | 计算机图形学（c++版MFC）

最新推荐文章于 2024-04-27 13:04:40 发布
最新推荐文章于 2024-04-27 13:04:40 发布
阅读量3.8k 收藏 45
点赞数 4
分类专栏： 计算机图形图像 文章标签： c++ mfc 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kndjg/article/details/125127068
版权

声明：凡代码问题，欢迎私信或在评论区沟通。承蒙指正，一起成长！ 

目录

实验1：绘制如下图所示扇形，并进行填充。

实验2：按下鼠标拖动绘制椭圆，然后在区域内双击鼠标，填充该椭圆区域。

实验3：绘制正六边形，并使用扫描线方式进行填充。

1. 了解并掌握圆形绘制算法；

2．掌握多边形的填充算法，已知多边形的顶点，通过绘制直线的函数或种子填充算法填充该多边形。

一、实验1：绘制如下图所示扇形，并进行填充。

（1）程序源代码

// shiyan2View.cpp : implementation of the CShiyan2View class
//

#include "stdafx.h"
#include "shiyan2.h"
#include <math.h>
#include "shiyan2Doc.h"
#include "shiyan2View.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

//int x1,y1,x2,y2; //全局变量圆弧首尾两点坐标

/
// CShiyan2View

IMPLEMENT_DYNCREATE(CShiyan2View, CView)

BEGIN_MESSAGE_MAP(CShiyan2View, CView)
	//{{AFX_MSG_MAP(CShiyan2View)
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_LBUTTONDBLCLK()
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

/
// CShiyan2View construction/destruction

CShiyan2View::CShiyan2View()
{
	// TODO: add construction code here

}

CShiyan2View::~CShiyan2View()
{
}

BOOL CShiyan2View::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CView::PreCreateWindow(cs);
}

/
// CShiyan2View drawing

void Midpointcircle_2(int radius,int color,CDC *p)
{
	int x,y,d,E=12,SE=20-8*radius;
	x=0;y=radius;
	d=3-4*radius;
	p->SetPixel(x+200,y+150,color);
	while(y>x)
	{
		if(d<=0)
		{
			d+=E;
			SE+=8;
		}
		else
		{
			d+=SE;
			SE+=16;
			y--;
		}
		E+=8;
		x++;
		p->SetPixel(x+200,y+150,color);
	}
}


/*
void Midpointcircle_1(int radius,int color,CDC *p)
{
	int x,y; float d;x=0;y=radius;
	d=3.0/4-radius;
	p->SetPixel(x+500,y+150,color);
	while(y>x)
	{
		if(d<=0)
			d+=2.0*x+3;
		else
		{
			d+=2.0*(x-y)+5;
			y--;
		}
		x++;
		p->SetPixel(-x+500,-y+150,color);
		p->SetPixel(x+500,-y+150,color);
	}
	x1=-x+500;y1=-y+150;
	x2=x+500;y2=-y+150;
}
*/


void B(int x,int y,int c1,int c2,CDC *p)
{
	long c;
	c=p->GetPixel(x,y);
	if(c!=c1 && c!=c2)
	{
		p->SetPixel(x,y,c1);
		B(x+1,y,c1,c2,p); B(x-1,y,c1,c2,p);
		B(x,y+1,c1,c2,p);  B(x,y-1,c1,c2,p);
	}
}
///
///
///

struct Edge
{
    //用来存储边的
    int yUpper;
    float xIntersect, dxPerScan;
    struct Edge * next;  //指向下一条边
} tEdge; //结构体变
///
void insertEdge(Edge *list,Edge *edge)
{
    Edge*p,*q=list;
    p=q->next;
    while(p!=NULL)
    {
        if(edge->xIntersect<p->xIntersect)
            p=NULL;
        else
        {
            q=p;
            p=p->next;
        }
    }
    edge->next=q->next;
    q->next=edge;
}
///
int yNext(int k,int cnt, CPoint * pts)
{
    int j;
    if((k+1)>(cnt-1))
        j=0;
    else
        j=k+1;
    while(pts[k].y==pts[j].y)
    {
        if((k+1)>(cnt-1))
            j=0;
        else
            j++;
    }
    return pts[j].y;
}

void makeEdgeRec (CPoint lower, CPoint upper, int yComp, Edge * edge, Edge *edges[])
{
    edge->dxPerScan=(float)(upper.x-lower.x)/(upper.y-lower.y);
    edge->xIntersect=lower.x;
    if(upper.y<yComp)
        edge->yUpper=upper.y-1;
    else
        edge->yUpper=upper.y;
    insertEdge(edges[lower.y],edge);
}
///
void buildEdgeList (int cnt, CPoint *pts, Edge *edges[])
{
    Edge * edge;
    CPoint v1,v2;
    int i,yPrev=pts[cnt-2].y;
    v1.x=pts[cnt-1].x;
    v1.y=pts[cnt-1].y;
    for(i=0; i<cnt; i++)
    {
        v2=pts[i];
        if(v1.y!=v2.y)
        {
            edge=(Edge*)malloc(sizeof(Edge));
            if(v1.y<v2.y)
                makeEdgeRec(v1,v2,yNext(i,cnt,pts),edge,edges);
            else
                makeEdgeRec(v2,v1,yPrev,edge,edges);
        }
        yPrev=v1.y;
        v1=v2;
    }
}
///
void buildActiveList (int scan, Edge * active, Edge * edges[])
{
    Edge*p,*q;
    p=edges[scan]->next;
    while(p)
    {
        q=p->next;
        insertEdge(active,p);
        p=q;
    }
}

void fillScan (int scan, Edge * active, CDC * pDC)
{
    Edge*p1,*p2;
    int i;
    p1=active->next;
    while(p1)
    {
        p2=p1->next;
        for(i=p1->xIntersect; i<p2->xIntersect; i++)
            pDC->SetPixel(i,scan,0);
        p1=p2->next;
    }
}

void deleteAfter(Edge *q)
{
    Edge * p=q-> next;
    q->next=p->next;
    free(p);
}
//
void updateActiveList (int scan, Edge * active)
{
    Edge *q=active,*p=active->next;
    while(p)
        if(scan>=p->yUpper)
        {
            p=p->next;
            deleteAfter(q);
        }
        else
        {
            p->xIntersect=p->xIntersect+p->dxPerScan;
            q=p;
            p=p->next;
        }
}
//
void resortActiveList(Edge *active)
{
    Edge*q,*p=active->next;
    active->next=NULL;
    while(p)
    {
        q=p->next;
        insertEdge(active,p);
        p=q;
    }
}
///
void scanFill(int cnt,CPoint *pts,CDC *pDC)
{
    Edge *edges[300],*active;       //edges是指针数组
    int i,scan;
    for(i=0; i<300; i++)
    {
        edges[i]=(Edge*)malloc(sizeof(Edge));//开辟内存区
        edges[i]->next=NULL;
    }
    buildEdgeList(cnt,pts,edges);
    active=(Edge*)malloc(sizeof(Edge));
    active->next=NULL;
    for(scan=0; scan<300; scan++)
    {
        buildActiveList(scan,active,edges);
        if(active->next)
        {
            fillScan(scan,active,pDC);
            updateActiveList(scan,active);
            resortActiveList(active);
        }
    }
}


///
///
///

CPoint vx[6];

//画六边形  104.7 *6
void Hexagan(CDC *p)
{
	int r=50;
	int j=0;
	p->MoveTo((int)(200+r*cos(52/100)),(int)(200+r*sin(52/100)));
	for(float i=0;i<=628;i=i+104.7)
	{
		int a=(int)(200+r*cos(i/100));
		int b=(int)(200+r*sin(i/100));
		p->LineTo(a,b);
		vx[j].x=a, vx[j].y=b;
		Sleep(500);
	}
	p->LineTo((int)(200+r*cos(52/100)),(int)(200+r*sin(52/100)));
	vx[j].x=(int)(200+r*cos(52/100));
	vx[j].y=(int)(200+r*sin(52/100));
}

void CShiyan2View::OnDraw(CDC* pDC)
{
	CShiyan2Doc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
/*
	Midpointcircle_1(145,0,pDC);
	pDC->MoveTo(x1,y1);
	pDC->LineTo(500,150);
	pDC->LineTo(x2,y2);
	B(500,1,255,0,pDC);

*/
//	Hexagan(pDC);

	int cnt=6;
	CPoint he[6];
	he[0].x=200,he[0].y=100;
	he[1].x=300,he[1].y=100;
	he[2].x=350,he[2].y=187;
	he[3].x=300,he[3].y=274;
	he[4].x=200,he[4].y=274;
	he[5].x=150,he[5].y=187;
	pDC->MoveTo(he[0].x,he[0].y);
	pDC->LineTo(he[1].x,he[1].y);
	pDC->LineTo(he[2].x,he[2].y);
	pDC->LineTo(he[3].x,he[3].y);
	pDC->LineTo(he[4].x,he[4].y);
	pDC->LineTo(he[5].x,he[5].y);
	pDC->LineTo(he[0].x,he[0].y);
	scanFill(cnt,he,pDC);

	// TODO: add draw code for native data here
}

/
// CShiyan2View printing

BOOL CShiyan2View::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CShiyan2View::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CShiyan2View::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/
// CShiyan2View diagnostics

#ifdef _DEBUG
void CShiyan2View::AssertValid() const
{
	CView::AssertValid();
}

void CShiyan2View::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CShiyan2Doc* CShiyan2View::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CShiyan2Doc)));
	return (CShiyan2Doc*)m_pDocument;
}
#endif //_DEBUG

/
// CShiyan2View message handlers

CPoint DownPoint;
//全局变量

void CShiyan2View::OnLButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	DownPoint=point;
	CView::OnLButtonDown(nFlags, point);
}

void CShiyan2View::OnLButtonUp(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	CDC *p=GetDC();
	p->Ellipse(DownPoint.x,DownPoint.y,point.x,point.y);
//	p->Rectangle(DownPoint.x,DownPoint.y,point.x,point.y);
	CView::OnLButtonUp(nFlags, point);
}

void CShiyan2View::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	CDC *pDC=GetDC();
	B(point.x,point.y,90000,0,pDC);
//	scanFill(4,&point,pDC);
	CView::OnLButtonDblClk(nFlags, point);
}

（2）运行结果

 

半径R=145；圆心坐标(500,150)；

二、实验2：编写程序，运行后按下鼠标拖动绘制椭圆，然后在区域内双击鼠标，填充该椭圆区域。

（1）程序源代码

CPoint DownPoint;
//全局变量
void CShiyan2View::OnLButtonDown(UINT nFlags, CPoint point) 
{
    // TODO: Add your message handler code here and/or call default
    DownPoint=point;
    CView::OnLButtonDown(nFlags, point);
}
void CShiyan2View::OnLButtonUp(UINT nFlags, CPoint point) 
{
    // TODO: Add your message handler code here and/or call default
    CDC *p=GetDC();
    p->Ellipse(DownPoint.x,DownPoint.y,point.x,point.y);
    CView::OnLButtonUp(nFlags, point);
}
void CShiyan2View::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
    // TODO: Add your message handler code here and/or call default
    CDC *pDC=GetDC();
    B(point.x,point.y,90000,0,pDC);
    CView::OnLButtonDblClk(nFlags, point);
}

（2）运行结果

       

 

 三、实验3：绘制正六边形，并使用扫描线方式进行填充。

（1）程序源代码


///    扫描线填充函数    /
struct Edge
{
    //用来存储边的
    int yUpper;
    float xIntersect, dxPerScan;
    struct Edge * next;  //指向下一条边
} tEdge; //结构体变
///
void insertEdge(Edge *list,Edge *edge)
{
    Edge*p,*q=list;
    p=q->next;
    while(p!=NULL)
    {
        if(edge->xIntersect<p->xIntersect)
            p=NULL;
        else
        {
            q=p;
            p=p->next;
        }
    }
    edge->next=q->next;
    q->next=edge;
}
///
int yNext(int k,int cnt, CPoint * pts)
{
    int j;
    if((k+1)>(cnt-1))
        j=0;
    else
        j=k+1;
    while(pts[k].y==pts[j].y)
    {
        if((k+1)>(cnt-1))
            j=0;
        else
            j++;
    }
    return pts[j].y;
}

void makeEdgeRec (CPoint lower, CPoint upper, int yComp, Edge * edge, Edge *edges[])
{
    edge->dxPerScan=(float)(upper.x-lower.x)/(upper.y-lower.y);
    edge->xIntersect=lower.x;
    if(upper.y<yComp)
        edge->yUpper=upper.y-1;
    else
        edge->yUpper=upper.y;
    insertEdge(edges[lower.y],edge);
}
///
void buildEdgeList (int cnt, CPoint *pts, Edge *edges[])
{
    Edge * edge;
    CPoint v1,v2;
    int i,yPrev=pts[cnt-2].y;
    v1.x=pts[cnt-1].x;
    v1.y=pts[cnt-1].y;
    for(i=0; i<cnt; i++)
    {
        v2=pts[i];
        if(v1.y!=v2.y)
        {
            edge=(Edge*)malloc(sizeof(Edge));
            if(v1.y<v2.y)
                makeEdgeRec(v1,v2,yNext(i,cnt,pts),edge,edges);
            else
                makeEdgeRec(v2,v1,yPrev,edge,edges);
        }
        yPrev=v1.y;
        v1=v2;
    }
}
///
void buildActiveList (int scan, Edge * active, Edge * edges[])
{
    Edge*p,*q;
    p=edges[scan]->next;
    while(p)
    {
        q=p->next;
        insertEdge(active,p);
        p=q;
    }
}

void fillScan (int scan, Edge * active, CDC * pDC)
{
    Edge*p1,*p2;
    int i;
    p1=active->next;
    while(p1)
    {
        p2=p1->next;
        for(i=p1->xIntersect; i<p2->xIntersect; i++)
            pDC->SetPixel(i,scan,0);
        p1=p2->next;
    }
}

void deleteAfter(Edge *q)
{
    Edge * p=q-> next;
    q->next=p->next;
    free(p);
}
//
void updateActiveList (int scan, Edge * active)
{
    Edge *q=active,*p=active->next;
    while(p)
        if(scan>=p->yUpper)
        {
            p=p->next;
            deleteAfter(q);
        }
        else
        {
            p->xIntersect=p->xIntersect+p->dxPerScan;
            q=p;
            p=p->next;
        }
}
//
void resortActiveList(Edge *active)
{
    Edge*q,*p=active->next;
    active->next=NULL;
    while(p)
    {
        q=p->next;
        insertEdge(active,p);
        p=q;
    }
}
///
void scanFill(int cnt,CPoint *pts,CDC *pDC)
{
    Edge *edges[300],*active;       //edges是指针数组
    int i,scan;
    for(i=0; i<300; i++)
    {
        edges[i]=(Edge*)malloc(sizeof(Edge));//开辟内存区
        edges[i]->next=NULL;
    }
    buildEdgeList(cnt,pts,edges);
    active=(Edge*)malloc(sizeof(Edge));
    active->next=NULL;
    for(scan=0; scan<300; scan++)
    {
        buildActiveList(scan,active,edges);
        if(active->next)
        {
            fillScan(scan,active,pDC);
            updateActiveList(scan,active);
            resortActiveList(active);
        }
    }
}
///    扫描线填充函数    /

void CShiyan2View::OnDraw(CDC* pDC)
{
    CShiyan2Doc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);
    int cnt=6;
    CPoint he[6];
    he[0].x=200,he[0].y=100;
    he[1].x=300,he[1].y=100;
    he[2].x=350,he[2].y=187;
    he[3].x=300,he[3].y=274;
    he[4].x=200,he[4].y=274;
    he[5].x=150,he[5].y=187;
    pDC->MoveTo(he[0].x,he[0].y);
    pDC->LineTo(he[1].x,he[1].y);
    pDC->LineTo(he[2].x,he[2].y);
    pDC->LineTo(he[3].x,he[3].y);
    pDC->LineTo(he[4].x,he[4].y);
    pDC->LineTo(he[5].x,he[5].y);
    pDC->LineTo(he[0].x,he[0].y);
    scanFill(cnt,he,pDC);

    // TODO: add draw code for native data here
}

（2）运行结果

 

尘封的CPU
关注
  • 4
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
基于MFC实现多边形填充算法完整代码
05-05
使用VS 2017实现多边形填充中的种子填充算法，此资源包括完整的项目文件，可以直接使用。此代码仅供学习交流使用。
VC++6.0 MFC 课程设计简易绘图程序
07-09
有铅笔工具，橡皮工具，画刷工具。可以画圆，椭圆，矩形，填充的透明的。直线，任意多边形。不能保存和打开图像文件。有不少BUG，我不是专业学软件的，只是一次课程设计的作业，内附设计说明书和一份教程，还有老师给我的几个代码。
计算机图形学MFC.zip
12-19
计算机图形学大作业： 一、主菜单的菜单项 基本图形绘制、图形变换、自由曲线绘制、图形裁剪或图形填充 二、二级子菜单基本图形绘制 1.直线绘制： 1）Bresenham绘制直线 2）DDA绘制直线 3）改进的Bresenham绘制直线 4）系统库函数绘制直线——直线线宽、线形设计 2.Bresenham绘制圆 3.Bresenham绘制椭圆 4.矩形的绘制 5.多边形的绘制 6.圆弧的绘制 三、二级子菜单图形变换 1.基本图形变换 1）平移变换 2）比例变换 3）错切变换 4）对称变换 5) 旋转变换 2.复合变换： 1）复合平移变换 2）复合比例变换 3）复合旋转变换 3.相对任意参考点的变换 4.相对任意直线的变换 四、二级子菜单自由曲线绘制 1. Bezier 曲线绘制 2.1)1次Bezier曲线 2)2次Bezier曲线 3)3次Bezier曲线 3. 3次B样条曲线 4. Hermite三次样条曲线 5. 曲线的拼接设计 五、二级菜单图形填充
计算机图形学 实验4 多边形的扫描转换（MFC中）
Confident_ZYL的博客
06-15 5154
实验目的： 理解多边形填充的目的 掌握多边形的各种填充算法 实验内容： 一、读懂多边形有效边表填充算法。 二、编写程序实现以边为中心的边缘填充算法 算法的原理是将每条非水平边右侧的像素取补，边的处理顺序随意。像素点颜色值经过偶数次取补运算后保持不变，经过奇数次取补运算后变为其补数。 图1 边填充算法图示 算法思路： 假设要绘制的多边形的顶点顺序是：（550,400），（350,600），（250,350），（350,50），（500,250），（600,50），（800,450） 定义一个POINT类型
要求在MFC的视图中利用鼠标画多边形，并按要求利用横线或竖线进行填充
baidu_40924225的博客
07-30 4676
Task2-1 任务报告 任务内容 ·任务说明 编写C++MFC程序，要求在MFC的视图中利用鼠标画多边形，并按要求利用横线或竖线进行填充。利用对话框控制线的数量或密度，以及横线或竖线，并可以重复画线或填充。 ·输入输出 界面显示 任务完成情况 ·实现思路 画鼠标点击画多边形 使用MFC内置的OnLButtonDown(UINT nFlags, CPoint point)函数实现。 首先使用cpo...
MFC实现基本图形绘制、变换、自由曲线绘制、图形裁剪和填充
m0_50824556的博客
03-24 6754
Bresenham、DDA、改进的Bresenham、系统库函数画直线，Bresenham画圆，画椭圆，绘制矩形，多边形，圆弧。平移，比例，错切，对称，旋转变换，复合平移，复合比例，复合旋转变换，相对任意参考点对称，旋转，相关任意直线对称。1次 Bezier曲线，2次 Bezier曲线，3次 Bezier曲线，3次B样条曲线，Hermite三次样条曲线，曲线拼接。多边形裁剪，绘制填充多边形，有效边表填充算法填充多边形。
MFC小程序之画三角形并填充
半雨微凉
01-24 9551
效果图： 知识点： 1、使用MoveTo、LineTo画三角形 2、使用Polygon画三角形 3、使用CRgn填充 示例代码： CClientDC dc( this ); CPen pen( PS_SOLID, 1, RGB( 0, 255, 0 ) ); CPen *oldPen = dc.SelectObject( &amp;...
MFC实现多边形填充算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
11-27 423
MFC实现多边形填充算法（附完整源码）
MFC画直线、圆、椭圆、矩形、填充等
02-20
用MFC实现画直线、圆、椭圆、矩形、填充等计算机的基本图形
MFC之学习多边形绘制、阴影模式、多边形填充模式与绘制实心五角星
星辰大海的博客
07-25 3986
1.笔记 1.1绘制多边形函数 BOOL CDC::Polygon(LPPOINT lpPoints,int nCount); lpPoints是多边形顶点数组名，数组中每个点是CPoint对象（或称POINT结构体），nCount是数组中顶点个数。调用成功返回非零，否则返回零。 1.2阴影画刷 1.2.1创建阴影画刷函数 BOOL CreateHatchBrush(int nIndex,COLORREF crColor); 参数为阴影模式、阴影颜色。调用成功返回非零，否则返回零。 1.
计算机图形学大作业C++代码（MFC）终极版
04-28
计算机图形学大作业终极版！！！包括2D和3D，2D包括直线、圆、多边形画法和填充、曲线、曲面的多种方法，弹球反射、图形变换（对称、旋转），亮点是，画完图形可以鼠标拖动修改；3D包括画小房子，灯光效果，这是我自己写的代码，亲测可用，各种功能应有尽有，由于太全面，所以只能要高分了，请各位谅解。。
实验三计算机图形学多边形填充算法.doc
04-10
实验三计算机图形学多边形填充算法
扫描线区域填充算法 C语言代码 计算机图形学
05-07
经过调试的扫描线区域填充算法，用C语言编写的，
vc++绘制有填充颜色的椭圆
05-11
vc++绘制有填充颜色椭圆，32程序
计算机图形学MFC-多边形有效边表填充算法-c/c++源码
03-08
（系统会自己调高积分，我重新改成5分啦！）大学计算机图形学课程作业代码，完美实现多边形有效边表填充算法，自用，具体代码完整。打包下载，可直接运行。c/c++语言MFC实现。支持vs。
计算机图形学(MFC)-多边形平滑填充（颜色渐变效果进行填充）
03-24
资源内容：透过鼠标获取多边形顶点绘制多边形，通过预先设定好的个顶点颜色，实现过度填充 语言：C++ 运行环境：Visual Studio 2013/更高版本
MFC实现多边形裁剪 计算机图形学
10-16
MFC框架，实现了绘制直线，填充区域，多边形裁剪功能，全部为C++实现，层次清晰，仅供学习使用~
【C++ | Python 八股文（备战秋招）】—— 日积月累
最新发布
BigDavid123的博客
04-27 270
C++、Python常见八股文
笨蛋学C++【C++基础第六弹】
YSL_Monet的博客
04-24 874
定义类需要用到关键字 class，然后指定类的名称，类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数class 类名{访问修饰符（public/protected/private）:成员变量;成员函数();
计算机图形学c++实现扫描线填充
10-14
扫描线填充是计算机图形学中一种常用的填充算法，用于将封闭的几何图形或多边形内部填充为指定的颜色。下面我将使用C语言来实现扫描线填充算法。 首先，需要定义一个几何图形或多边形的顶点集合，并按照顺时针或逆时针的顺序连接这些点。然后，需要确定扫描线的范围，即图形的最小和最大y坐标。 接下来，我们使用循环遍历每一条扫描线，从最小y坐标开始，逐渐增加到最大y坐标。对于每一条扫描线，需要找到与其相交的边，并记录下这些边的交点。 在记录交点的过程中，我们还需要判断相邻边是否平行。如果平行，就无法确定边与扫描线的交点；如果不平行，我们可以根据扫描线的y坐标和边的两个顶点坐标，使用线性插值来确定交点的x坐标。 最后，根据获取的交点集合，我们可以将扫描线上的每一段直线区域填充为指定的颜色。这可以通过使用循环和画线函数来实现。 以上就是使用C语言实现扫描线填充的基本步骤。当然，在实际编程中，还需要考虑边界情况、效率优化和图形接口等相关问题。有了这个基本框架，可以根据具体需求进行更多的功能扩展和优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

尘封的CPU

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值