计算机图形学の多边形裁剪算法(openGL)

最新推荐文章于 2022-07-09 09:00:00 发布
最新推荐文章于 2022-07-09 09:00:00 发布
阅读量2.6k 收藏 30
点赞数 2
分类专栏： openGL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42683011/article/details/108976672
版权

二维图形裁剪算法:

参考博客:

https://blog.csdn.net/m0_46359746/article/details/106392352

image-20200930153345235

Liang-Barsky 线段裁剪算法:

//Liang-Barsky 线段裁剪算法

class wcPt2D {

public:
	GLfloat x,y;
public:
	/*
Default Constructor:initalize position 48(0.0,0.0).*/
	wcPt2D(){
		x=y=0.0;
	}

	wcPt2D(GLfloat nx, GLfloat ny): x(nx), y(ny){}

	wcPt2D(const wcPt2D& pCopy){
		this->x=pCopy.x;
		this->y=pCopy.y;
	}

	void setCoords(GLfloat xCoord,GLfloat yCoord){
		x = xCoord;
		y = yCoord;
		return ;
	}

	wcPt2D& operator= (wcPt2D p2){
		this->x=p2.getx ();
		this->y=p2.gety ();
		return *this;
	}


	GLfloat getx()const{
		return x;
	}
	GLfloat gety ( ) const {
		return y;
	}
};

inline GLint round(const GLfloat a){
	return GLint(a + 0.5);
}

GLint clipTest(GLfloat p, GLfloat q, GLfloat * u1, GLfloat *u2){
	GLfloat r;
	GLint returnValue=true;
	if(p<0.0){
		r=q/p;
		if(r>*u2){
			returnValue = false;
		}else if(r>*u1){
			*u1=r;
		}
	}else{
		if(p>0.0){
			r=q/p;
			if(r<*u1){
				returnValue=false;
			}else if(r<*u2){
				*u2=r;
			}
		}else{

			if(q<0.0){
				returnValue=false;
			}
		}
	}
	return (returnValue);
}


void lineClipLiangBrask(wcPt2D winMin, wcPt2D winMax, wcPt2D p1, wcPt2D p2){
	GLfloat u1=0.0, u2=1.0, dx=p2.getx ()-p1.getx (),dy;
	if(clipTest (-dx, p1.getx ()-winMin.getx (),&u1, &u2)){
		if(clipTest (dx, winMax.getx ()-p1.getx (),&u1, &u2)){
			dy=p2.gety ()-p1.gety ();
			if(clipTest (-dy, p1.gety ()-winMin.gety (), &u1, &u2)){
				if(clipTest (dy,winMax.gety ()-p1.gety (),&u1, &u2)){
					if(u2<1.0){
						p2.setCoords(p1.getx ()+u2*dx,p1.gety ()+u2*dy);
					}
					if(u1>0.0){
						p1.setCoords(p1.getx ()+u1*dx, p1.gety ()+u1*dy);
					}
					lineDDA (round(p1.getx ()), round (p1.gety ()),round(p2.getx ()),round(p2.gety ()));
				}
			}
		}
	}

	return ;
}

display:

//	Liang-Barsky线段裁剪算法
//初始直线
glColor3f (0.0,0.0,1.0);
lineBres (0,100,400,300);
glFlush ();

//可视化边界:
glColor3f(1.0,0.0,0.0);
lineBres (100,100,100,300);
lineBres (100,100,300,100);
lineBres (300,300,100,300);
lineBres (300,300,300,100);


glColor3f (0.0,1.0,0.0);
lineClipLiangBrask (wcPt2D(100,100), wcPt2D(300, 300), wcPt2D(0,100),wcPt2D(400, 300));
glFlush ();

Liang-Barsky 多边形裁剪算法:

//-----------------------------------------
//Liang-Barsky 线段裁剪算法

class wcPt2D {

public:
	GLfloat x,y;
public:
	/*
Default Constructor:initalize position 48(0.0,0.0).*/
	wcPt2D(){
		x=y=0.0;
	}

	wcPt2D(GLfloat nx, GLfloat ny): x(nx), y(ny){}

	wcPt2D(const wcPt2D& pCopy){
		this->x=pCopy.x;
		this->y=pCopy.y;
	}

	void setCoords(GLfloat xCoord,GLfloat yCoord){
		x = xCoord;
		y = yCoord;
		return ;
	}

	wcPt2D& operator= (wcPt2D p2){
		this->x=p2.getx ();
		this->y=p2.gety ();
		return *this;
	}


	GLfloat getx()const{
		return x;
	}
	GLfloat gety ( ) const {
		return y;
	}
};

inline GLint round(const GLfloat a){
	return GLint(a + 0.5);
}

GLint clipTest(GLfloat p, GLfloat q, GLfloat * u1, GLfloat *u2){
	GLfloat r;
	GLint returnValue=true;
	if(p<0.0){
		r=q/p;
		if(r>*u2){
			returnValue = false;
		}else if(r>*u1){
			*u1=r;
		}
	}else{
		if(p>0.0){
			r=q/p;
			if(r<*u1){
				returnValue=false;
			}else if(r<*u2){
				*u2=r;
			}
		}else{

			if(q<0.0){
				returnValue=false;
			}
		}
	}
	return (returnValue);
}


void lineClipLiangBrask(wcPt2D winMin, wcPt2D winMax, wcPt2D p1, wcPt2D p2){
	GLfloat u1=0.0, u2=1.0, dx=p2.getx ()-p1.getx (),dy;
	if(clipTest (-dx, p1.getx ()-winMin.getx (),&u1, &u2)){
		if(clipTest (dx, winMax.getx ()-p1.getx (),&u1, &u2)){
			dy=p2.gety ()-p1.gety ();
			if(clipTest (-dy, p1.gety ()-winMin.gety (), &u1, &u2)){
				if(clipTest (dy,winMax.gety ()-p1.gety (),&u1, &u2)){
					if(u2<1.0){
						p2.setCoords(p1.getx ()+u2*dx,p1.gety ()+u2*dy);
					}
					if(u1>0.0){
						p1.setCoords(p1.getx ()+u1*dx, p1.gety ()+u1*dy);
					}
					lineDDA (round(p1.getx ()), round (p1.gety ()),round(p2.getx ()),round(p2.gety ()));
					//					return 2;
				}
			}
		}
	}

	return ;
}

int lineClipLiangBrask(wcPt2D winMin, wcPt2D winMax, wcPt2D p1, wcPt2D p2, wcPt2D pOut[]){
	GLfloat u1=0.0, u2=1.0, dx=p2.getx ()-p1.getx (),dy;
	if(clipTest (-dx, p1.getx ()-winMin.getx (),&u1, &u2)){
		if(clipTest (dx, winMax.getx ()-p1.getx (),&u1, &u2)){
			dy=p2.gety ()-p1.gety ();
			if(clipTest (-dy, p1.gety ()-winMin.gety (), &u1, &u2)){
				if(clipTest (dy,winMax.gety ()-p1.gety (),&u1, &u2)){
					if(u2<1.0){
						p2.setCoords(p1.getx ()+u2*dx,p1.gety ()+u2*dy);
					}
					if(u1>0.0){
						p1.setCoords(p1.getx ()+u1*dx, p1.gety ()+u1*dy);
					}
					pOut[0]=p1;
					pOut[1]=p2;
//					lineDDA (round(p1.getx ()), round (p1.gety ()),round(p2.getx ()),round(p2.gety ()));
					return 2;
				}
			}
		}
	}

	return 0;
}

void display(){
	glClear (GL_COLOR_BUFFER_BIT);
	//可视化边界:
	const int minX=100, minY=100, maxX=300, maxY=300;
	glColor3f(1.0,0.0,0.0);
	lineDDA (minX,minY,minX,maxY);
	lineDDA (minX,minY,maxX,minY);
	lineDDA (maxX,maxY,minX,maxY);
	lineDDA (maxX,maxY,maxX,minY);

	glColor3f(0.0,1.0,0.0);
	GLint n=5;
	wcPt2D pIn[n];
	pIn[0].setCoords (0,200);
	pIn[1].setCoords (150,250);
	pIn[2].setCoords (250,250);
	pIn[3].setCoords (400,200);
	pIn[4].setCoords (200,50);

	for(int i=0;i<n;++i){
		lineDDA (pIn[i].x,pIn[i].y,pIn[(i+1)%n].x,pIn[(i+1)%n].y);
	}


	wcPt2D pOut[20];
	wcPt2D tempPOut[2];
	int outCount=0;
	int flag=0;
	for(int i=0;i<n;++i){
		flag=lineClipLiangBrask (wcPt2D(minX,minY), wcPt2D(maxX, maxY), pIn[i],pIn[(i+1)%n],tempPOut);
		if(flag==2){
			for(int j=0;j<2;++j){
				pOut[outCount++]=tempPOut[j];
			}
		}
	}

	glColor3f(0.0,0.0,1.0);
	int i=1;
	for(;i<=outCount;++i){
		lineDDA (pOut[i-1].x,pOut[i-1].y,pOut[i%outCount].x,pOut[i%outCount].y);
	}

	glFlush ();


	return ;
}

效果:

image-20201009120216266

Sutherland-Hodgman多边形裁剪算法

#define NDEBUG
#ifndef GLUT_DISABLE_ATEXIT_HACK
#define GLUT_DISABLE_ATEXIT_HACK
#endif
#include <windows.h>
#include <gl/glut.h>
#include <math.h>
#include <stdio.h>

const int windowWidge=600, windowHeight=600;


void setPixel(GLint xCoord, GLint yCoord){
	glBegin (GL_POINTS);
	glVertex2i (xCoord, yCoord);
	glEnd();
}


//-----------------------------------------

void lineDDA (int x0, int y0, int xEnd, int yEnd){
	int dx=xEnd-x0,dy=yEnd-y0,steps,k;
	float xIncrement,yIncrement,x=x0,y=y0;
	if(fabs(dx)> fabs(dy)){
		steps = fabs(dx);
	}else {
		steps = fabs(dy);
	}
	xIncrement = float(dx)/float(steps);
	yIncrement = float(dy)/ float(steps);
	setPixel(round(x),round(y));
	for(k = 0;k< steps;k++){
		x += xIncrement;
		y += yIncrement;
		setPixel(round(x),round(y));
	}
	return ;
}



//---------------------------------------------
//Sutherland-Hodgman多边形裁剪算法

class wcPt2D {

public:
	GLfloat x,y;
public:
	/*
Default Constructor:initalize position 48(0.0,0.0).*/
	wcPt2D(){
		x=y=0.0;
	}

	wcPt2D(GLfloat nx, GLfloat ny): x(nx), y(ny){}

	wcPt2D(const wcPt2D& pCopy){
		this->x=pCopy.x;
		this->y=pCopy.y;
	}

	void setCoords(GLfloat xCoord,GLfloat yCoord){
		x = xCoord;
		y = yCoord;
		return ;
	}

	wcPt2D& operator= (wcPt2D p2){
		this->x=p2.getx ();
		this->y=p2.gety ();
		return *this;
	}


	GLfloat getx()const{
		return x;
	}
	GLfloat gety ( ) const {
		return y;
	}
};


//枚举类的替代, C++中enum的操作与C有很大不同
const int Left=0, Right=1, Bottom=2, Top=3;

//typedef enum{
//	Left, Right, Bottom, Top
//} Boundary;

using namespace std;

const GLint nClip = 4;


//判断点p是否在显示框内
GLint inside(wcPt2D p, int b, wcPt2D wMin, wcPt2D wMax){
	int flag=true;
	switch(b){
		case Left:{
			if(p.getx ()<wMin.getx ()){
				flag=false;
			}
			break;
		}
		case Right:{
			if(p.getx ()>wMax.getx ()){
				flag=false;
			}
			break;
		}
		case Bottom:{
			if(p.gety ()<wMin.gety ()){
				flag=false;
			}
			break;
		}
		case Top:{
			if(p.gety ()>wMax.gety ()){
				flag=false;
			}
			break;
		}
	}
	return flag;
}

//判断向量(p1, p2)是否与边界相交
GLint cross(wcPt2D p1, wcPt2D p2, int winEdge, wcPt2D wMin, wcPt2D wMax){
	if(inside (p1,winEdge,wMin,wMax)==inside (p2, winEdge, wMin, wMax)){
		return false;
	}else{
		return true;
	}
}

//返回向量(p1, p2)与相应边界的交点
wcPt2D intersect(wcPt2D p1, wcPt2D p2, int winEdge, wcPt2D wMin, wcPt2D wMax){
	wcPt2D iPt;
	GLfloat m;

	if(p1.x!= p2.x){
		m=(p1.gety ()-p2.gety ())/(p1.getx ()-p2.getx ());
	}
	switch (winEdge) {
		case Left:{
			iPt.x=wMin.x;
			iPt.y=p2.y+(wMin.x-p2.x)*m;
			break;
		}
		case Right:{
			iPt.x=wMax.x;
			iPt.y=p2.y+(wMax.x-p2.x)*m;
			break;
		}
		case Bottom:{
			iPt.y=wMin.y;
			if(p1.x!=p2.x){
				iPt.x=p2.x+(wMin.y-p2.y)/m;
			}else{
				iPt.x=p2.x;
			}
			break;
		}
		case Top:{
			iPt.y=wMax.y;
			if(p1.x!=p2.x){
				iPt.x=p2.x+(wMax.y-p2.y)/m;
			}else{
				iPt.x=p2.x;
			}
			break;
		}
	}
	return iPt;
}

void clipPoint(wcPt2D &p, int winEdge, wcPt2D wMin, wcPt2D wMax, wcPt2D * pOut,
			   int *cnt, wcPt2D first[], wcPt2D *s){
	wcPt2D iPt;

	//判断first[winEdge]为nullPtr
	if(first[winEdge].x==0 && first[winEdge].y==0){
		first[winEdge]=p;
	}else{
		if(cross(p,s[winEdge], winEdge, wMin, wMax)){
			iPt=intersect (p, s[winEdge], winEdge, wMin, wMax);
			if(winEdge<Top){
				clipPoint (iPt, winEdge+1, wMin, wMax, pOut, cnt, first, s);
			}else{
				//存交点
				pOut[*cnt] =iPt;
				(*cnt)++;
			}
		}
	}
	s[winEdge]=p;
	if(inside (p,winEdge, wMin, wMax)){
		if(winEdge<Top){
			clipPoint (p, winEdge+1, wMin, wMax, pOut, cnt, first, s);
		}else{
			pOut[*cnt]=p;
			(*cnt)++;
		}
	}
}

void closeClip(wcPt2D wMin, wcPt2D wMax, wcPt2D *pOut, GLint *cnt,
			   wcPt2D first[],wcPt2D *s){
	wcPt2D pt;
	int winEdge;
	for(winEdge=Left; winEdge<=Top;winEdge++){
		if(cross(s[winEdge],first[winEdge],winEdge, wMin, wMax)){
			pt=intersect (s[winEdge], first[winEdge], winEdge, wMin, wMax);
			if(winEdge<Top){
				clipPoint (pt, winEdge+1, wMin, wMax, pOut, cnt, first, s);
			}else{
				pOut[*cnt]=pt;
				(*cnt)++;
			}
		}
	}
}

GLint polygonClipSuthHodg(wcPt2D wMin, wcPt2D wMax, GLint n, wcPt2D *pIn, wcPt2D *pOut){
	wcPt2D first[nClip] , s[nClip];
	GLint k, cnt=0;
	for(k=0;k<n;k++){
		clipPoint (pIn[k],Left, wMin, wMax, pOut, &cnt, first, s);
	}
	closeClip (wMin, wMax, pOut, &cnt, first, s);
	return cnt;
}


//---------------------------------------------


//绘制程序
void display(){

	//Sutherland-Hodgman多边形裁剪算法
	glClear (GL_COLOR_BUFFER_BIT);
	//可视化边界:
	const int minX=100, minY=100, maxX=300, maxY=300;
	glColor3f(1.0,0.0,0.0);
	lineDDA (minX,minY,minX,maxY);
	lineDDA (minX,minY,maxX,minY);
	lineDDA (maxX,maxY,minX,maxY);
	lineDDA (maxX,maxY,maxX,minY);

	//定义多边形的颜色和顶点
	glColor3f(0.0,1.0,0.0);
	GLint n=6;
	wcPt2D pIn[n];
	pIn[0].setCoords (50,200);
	pIn[1].setCoords (150,250);
	pIn[2].setCoords (250,250);
	pIn[3].setCoords (350,200);
	pIn[4].setCoords (250,50);
	pIn[5].setCoords (150,50);
	//绘制原始多边形
	for(int i=0;i<n;++i){
		lineDDA (pIn[i].x,pIn[i].y,pIn[(i+1)%n].x,pIn[(i+1)%n].y);
	}

	//获取裁剪后的点集
	wcPt2D pOut[20];
	int count=polygonClipSuthHodg (wcPt2D(minX,minY),wcPt2D(maxX,maxY),n,pIn,pOut);

	//定义裁剪后的多边形颜色
	glColor3f(0.0,0.0,1.0);
	//绘制裁剪后的多边形
	for(int i=1;i<=count;++i){
		lineDDA (pOut[i-1].x,pOut[i-1].y,pOut[i%count].x,pOut[i%count].y);
	}

	glFlush ();


	return ;
}

//初始化绘制
void init(){
	glClearColor(1.0,1.0,1.0,0.0);//清除颜色设置
	glMatrixMode(GL_PROJECTION);//设置投影方式
	gluOrtho2D (0.0,windowWidge*1.0,0.0,windowHeight*1.0);
	return ;
}

int main(int argc, char** argv){
	glutInit(&argc, argv);//初始化glut
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);//设置显示模式为单缓冲，RGB模式
	glutInitWindowPosition(0,0);//设置窗口位置
	glutInitWindowSize(windowWidge,windowHeight);//设置窗口大小
	glutCreateWindow("lineClipLiangBrask");//设置窗口标题
	init();
	glutDisplayFunc(display);
	glutMainLoop();
	return 0;
}

效果:

image-20201009153730699

Janus_V
关注
专栏目录
图像处理之图像分割算法：GrabCut算法：图像分割算法概览
kkchenjj的博客
07-27 442
交互性: GrabCut算法允许用户通过简单的标记（矩形框或粗略的轮廓）来指导分割过程，提高了分割的准确性和效率。自动细化: 一旦用户提供了初始标记，算法能够自动细化边界，减少用户的手动调整。背景和前景的区分: 通过迭代优化，GrabCut能够有效地区分图像的背景和前景，即使在复杂背景下也能保持良好的分割效果。颜色和纹理信息的利用: 算法结合了颜色和纹理信息，能够处理具有相似颜色但不同纹理的区域，提高了分割的鲁棒性。
OpenGL.裁剪算法
随便写写
06-06 5602
裁剪就是来确定 哪些是位于视景体内，应当被最后成图来考虑的 哪些是位于视景体外，不需要后续的处理了（因为不属于成图范围嘛） 线段的裁剪算法 Cohen-Sutherlend算法 这是一种很巧妙的裁剪算法，运用了编码的思想 先考虑二维的裁剪，即一条二维的线段和一个方形的裁剪区域 方形的裁剪区域为 对于一条线段，其是由两个顶点来刻画的 对于每个顶点都根据其位置（x，y）进行编码 编码 b1b
计算机图形学简单多边形裁剪程序
06-03
计算机图形学简单多边形裁剪程序，开发环境VC++6.0，语言C++
OpenGL多边形裁剪
12-07
Sutherland—Hodgman OpenGL多边形裁剪 vc++ 6.0 环境下开发
任意凸多边形裁剪凹多边形算法 OpengL实现
11-18
OpenGL实现的用凸多边去裁剪任意多边形的算法，手动画出直线，VS2008工程
opengl 直线多边形 裁剪
04-25
opengl 图形学 直线和多边形裁剪 C++
opengl裁剪算法
10-21
OpenGL的经典裁剪算法，经过亲自验证，运行无问题
在OpenGL环境下， 运用Sutherland_Hodheman算法实现多边形裁剪
m0_45116317的博客
05-27 1672
#在OpenGL环境下， 运用Sutherland_Hodheman算法实现多边形裁剪 Sutherland_Hodheman算法基本思想是：简单得通过单一边或面的剪裁实现对多边形的裁剪；原多边形和每次裁剪所生成的多边形将逐次对裁剪窗口的每一条边进行裁剪。 #include<GL/glut.h> #include<iostream> #include<stdio.h> #include<stdlib.h> typedef struct { float x,
计算机图形学OpenGL、codeblock、多边形裁剪、Sutherland_Hodgman算法
12-20
多边形裁剪是计算机图形学中的关键步骤，特别是在3D图形渲染中。当一个三维模型被投影到二维屏幕上时，可能会有部分多边形超出屏幕边界，此时就需要进行裁剪以确保只显示可见的部分。Cohen-Sutherland线段裁剪算法是...
计算机图形学中的多边形裁剪
11-25
在计算机图形学中，多边形裁剪是一项基础且重要的任务，它主要用于处理三维模型在二维屏幕上的显示问题。当一个三维物体被投影到二维屏幕上时，可能会有部分多边形超出屏幕的边界，即所谓的“视窗”。为了正确地显示...
计算机图形学-多边形的裁剪算法
12-20
在计算机图形学中，多边形的裁剪算法是一项基础且关键的技术，它用于处理图形对象与屏幕边界或其他几何形状的交集问题。在本案例中，我们将探讨如何编程实现直线段的裁剪算法。 直线段裁剪算法主要用于处理屏幕空间...
计算机图形学 多边形裁剪
12-04
使用C#实现计算机图形学中的多边形裁剪算法，界面友好，功能完善
计算机图形学实现多边形裁剪
12-29
#include <graphics.h>， line(left,top,right,top); line(left,bottom,right,bottom); line(left,top,left,bottom); line(right,top,right,bottom); //绘制边框和裁剪图形
多边形裁剪算法 计算机图形学
06-09
逐次多边形裁剪算法算法的思想发窗口四条边界单一逐次对多边形进行裁剪，每次用窗口的一条边界(包括延长线)对要裁剪的多边形进行裁剪，裁剪时，顺序地测试多边形各顶点，保留边界内侧的顶点，删除外侧的顶点，同时，适时地插入新的顶点：即交点和窗口顶点，从而得到一个新的多边形顶点序列。然后以此新的顶点序列作为输入，相对第二条窗边界线进行裁剪，又得到一个更新的多边形顶点序列依次下去，相对于第三条、第四条边界线进行裁剪，最后输出的多边形顶点序列即为所求的裁剪好了的多边形。
c++ OpenGL DDA／Bresenham 算法画直线， 多边形填充与裁剪
10-24
本程序用C++ Glut／OpenGL实现DDA与Bresenham的直线画法，鼠标点击画直线，多边形。扫描线算法填充复杂多边形，Cohen－Sutherland直线裁剪以及Sutherland－Hodgeman多边形裁剪。内附英文READEME文件。运行程序后右键点击显示菜单，界面友好。
计算机图形学 多边形裁剪完整代码 WinTC
09-10
计算机图形学作业，不需修改直接在WINtc下运行
计算机图形学裁剪算法
01-13
总的来说，计算机图形学中的裁剪算法是图形处理的关键技术之一，它涉及到几何学、线性代数、坐标变换等多个数学领域，是计算机图形学理论和实践的基础。理解和掌握这些算法对于从事图形相关的软件开发至关重要。
Sutherland-Hodgman算法：OpenGL GLFW实现交互的多边形裁剪
playerz的博客
11-08 824
代码 /*INTRODUCTION // Mouse: // - LEFT button: // 1. add point to draw the polygon // - RIGHT button: // clip the polygon // Keyboard: // - SPACE: // clear the window */ #include <GLFW/glfw3.h> #include<iostream> #include<vector> #defi
【OpenGL】计算机图形学实验四: 直线、多边形裁剪实验(直线和多边形的裁剪)
JKL27的博客
07-09 5850
(直线和多边形的裁剪)1、实验目的和要求实验目的：实验内容：2、实验设备PC机、CodeBlocks\VS系列\OpenGL安装包3、实验内容及原理 实验原理(基本知识)1) Cohen-Sutherland裁剪算法又称编码裁剪算法，对每条直线段分三种情况处理： ① 如果点P1, P2完全在裁剪窗口内，则该直线段完全可见，“简取”之； ② 如果点P1, P2都在窗口外，且在窗口的同一外侧，则该直线段完全不可见，“简弃”之； ③ 若不满足“简取”和“简弃”的条件，则直线段可能与窗口相交
计算机图形学：多边形描述与填充算法
"多边形的描述-计算机图形学ppt" 在计算机图形学中，多边形是一种基本的图形元素，常用于构建复杂的3D模型和2D形状。多边形的描述通常涉及到其特征属性，包括顶点（vertices）和边（edges）。在给定的描述中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值