LOOP 细分四面体（编辑中）

最新推荐文章于 2023-01-10 16:44:41 发布
最新推荐文章于 2023-01-10 16:44:41 发布
阅读量1.3k 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 细分曲线曲面 文章标签： 细分 opengl CAGD
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lafengxiaoyu/article/details/51590784
本文介绍了一个基于OpenGL的Loop细分算法实现，通过动态分配内存的方式构建复杂的三维几何模型，并演示了如何利用细分来增加模型细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

通过之前的matlab实现了loop细分仅仅用了一点点代码，我收到了极大的启发，打算在这学期结束之前一定搞定LOOP细分，哦也！

#include <windows.h>  
#include<GL/GLUT.H>    
#include <math.h>        
#include <gl/GL.h>        
#include<iostream> 
#include <stdlib.h>

template <class T>
int getArrayLen(T& array)
{//使用模板定义一 个函数getArrayLen,该函数将返回数组array的长度
	return (sizeof(array) / sizeof(array[0]));
}


#define pi 3.1415927f;  
float a = 0.5f;
float u = sqrtf(2.0) / 3;
float v = float(1) / 3;
float t = sqrtf(6.0) / 3;

static const GLfloat vertex_list[][3] = {
	0.0f, 0.0f, a,
	-2 * a*u, 0, -a*v,
	a*u, a*t, -a*v,
	a*u, -a*t, -a*v
};

static const GLint index_list[][3] = {
	0, 1, 2,
	0, 2, 3,
	0, 1, 3,
	1, 2, 3,
};

int newIndexOfVertices;
int ***edgeVertice;
float newVertices[100][3];
int newFaces[100][3];

int jishu;

int nVertices = getArrayLen(vertex_list);
int nFaces = getArrayLen(index_list);

void idd()
{


	for (int i = 0; i < nVertices; i++)
		for (int j = 0; j < 3; j++)
		{
			newVertices[i][j] = vertex_list[i][j];
		}


	//动态定义三维数组：  
	edgeVertice = new int**[nVertices];
	for (int i = 0; i < nVertices; i++)
	{
		edgeVertice[i] = new int*[nVertices];
	}

	for (int i = 0; i <nVertices; i++)
		for (int j = 0; j < nVertices; j++)
			edgeVertice[i][j] = new int[3];
	//输入三维数组值：  

	for (int i = 0; i < nVertices; i++)
		for (int j = 0; j < nVertices; j++)
			for (int k = 0; k < 3; k++)
				edgeVertice[i][j][k] = 0;

	newIndexOfVertices = nVertices;
}





int addEdgeVertice(int v1Index,int v2Index,int v3Index)
{
	if (v1Index > v2Index)
	{
		int vTmp = v1Index;
		v1Index = v2Index;
		v2Index = vTmp;
	}

	if (edgeVertice[v1Index][v2Index][0] == 0)
	{
		newIndexOfVertices = newIndexOfVertices + 1;
		edgeVertice[v1Index][v2Index][0] = newIndexOfVertices-1;
		edgeVertice[v1Index][v2Index][1] = v3Index;
	}
	else
	{
        edgeVertice[v1Index][v2Index][2] = v3Index;
	}
		
	int vNIndex = edgeVertice[v1Index][v2Index][0];
	return vNIndex;
}



void myDisplay(void){
	glClear(GL_COLOR_BUFFER_BIT);
	glRotatef(45, 1, 1, 1);
	glFrontFace(GL_CCW);

	for (int i = 0; i < 4; ++i)      // 有四个面，循环六次  
	{
		glBegin(GL_LINE_LOOP);
		for (int j = 0; j < 3; ++j)     // 每个面有四个顶点，循环四次  
			glVertex3fv(vertex_list[index_list[i][j]]);
		glEnd();
	}

	idd();

	jishu = 0;

	for (int i = 0; i < nFaces; i++)
	{
		int vaIndex = index_list[i][0];
		int vbIndex = index_list[i][1];
		int vcIndex = index_list[i][2];

		int vpIndex = addEdgeVertice(vaIndex, vbIndex, vcIndex);
		int vqIndex = addEdgeVertice(vbIndex, vcIndex, vaIndex);
		int vrIndex = addEdgeVertice(vaIndex, vcIndex, vbIndex);
	
		newFaces[jishu][0] = vaIndex; newFaces[jishu][1] = vpIndex; newFaces[jishu][2] = vrIndex; jishu++;
		newFaces[jishu][0] = vpIndex; newFaces[jishu][1] = vbIndex; newFaces[jishu][2] = vqIndex; jishu++;
		newFaces[jishu][0] = vrIndex; newFaces[jishu][1] = vqIndex; newFaces[jishu][2] = vcIndex; jishu++;
		newFaces[jishu][0] = vrIndex; newFaces[jishu][1] = vpIndex; newFaces[jishu][2] = vqIndex; jishu++;
	}
	

	int vNOpposite2Index;
	int vNOpposite1Index;
	for (int v1 = 0; v1 < nVertices - 1; v1++)
		for (int v2 = 0; v2 < nVertices; v2++)
		{

			int vNIndex = edgeVertice[v1][v2][0];
			if (vNIndex != 0)
			{
				vNOpposite1Index = edgeVertice[v1][v2][1];
				vNOpposite2Index = edgeVertice[v1][v2][2];
			}

			if (vNOpposite2Index == 0)
			{
				for (int t = 0; t < 3; t++)
				{
					newVertices[vNIndex][t] = vertex_list[v1][t] + vertex_list[v2][t];
				}
			}
			else
			{
				for (int t = 0; t < 3; t++)
				{
					newVertices[vNIndex][t] = 3 / 8 * (vertex_list[v1][t] + vertex_list[v2][t]) + 1 / 8 * (vertex_list[vNOpposite1Index][t] + vertex_list[vNOpposite2Index][t]);
				}
			}

		}
	
	



	

	glFlush();
}


int main(int argc, char *argv[])
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(400, 400);
	glutCreateWindow("opengl1");
	glutDisplayFunc(&myDisplay);
	glutMainLoop();
	return 0;
}

拜拜

#include <windows.h>    
#include<GL/GLUT.H>      
#include <math.h>          
#include <gl/GL.h>          
#include<iostream>   
#include <stdlib.h>  

template <class T>
int getArrayLen(T& array)
{//使用模板定义一 个函数getArrayLen,该函数将返回数组array的长度  
	return (sizeof(array) / sizeof(array[0]));
}


#define pi 3.1415927f;    
float a = 0.5f;
float u = sqrtf(2.0) / 3;
float v = float(1) / 3;
float t = sqrtf(6.0) / 3;

static const GLfloat vertex_list[][3] = {
	0.0f, 0.0f, a,
	-2 * a*u, 0, -a*v,
	a*u, a*t, -a*v,
	a*u, -a*t, -a*v
};

static const GLint index_list[][3] = {
	0, 1, 2,
	0, 2, 3,
	0, 1, 3,
	1, 2, 3,
};

int newIndexOfVertices;
int ***edgeVertice;
float newVertices[100][3];
int newFaces[100][3];

int jishu;

int nVertices = getArrayLen(vertex_list);
int nFaces = getArrayLen(index_list);

void idd()
{


	for (int i = 0; i < nVertices; i++)
		for (int j = 0; j < 3; j++)
		{
			newVertices[i][j] = vertex_list[i][j];
		}


	//动态定义三维数组：    
	edgeVertice = new int**[nVertices];
	for (int i = 0; i < nVertices; i++)
	{
		edgeVertice[i] = new int*[nVertices];
	}

	for (int i = 0; i <nVertices; i++)
		for (int j = 0; j < nVertices; j++)
			edgeVertice[i][j] = new int[3];
	//输入三维数组值：    

	for (int i = 0; i < nVertices; i++)
		for (int j = 0; j < nVertices; j++)
			for (int k = 0; k < 3; k++)
				edgeVertice[i][j][k] = 0;

	newIndexOfVertices = nVertices;
}





int addEdgeVertice(int v1Index, int v2Index, int v3Index)
{
	if (v1Index > v2Index)
	{
		int vTmp = v1Index;
		v1Index = v2Index;
		v2Index = vTmp;
	}

	if (edgeVertice[v1Index][v2Index][0] == 0)
	{
		newIndexOfVertices = newIndexOfVertices + 1;
		edgeVertice[v1Index][v2Index][0] = newIndexOfVertices - 1;
		edgeVertice[v1Index][v2Index][1] = v3Index;
	}
	else
	{
		edgeVertice[v1Index][v2Index][2] = v3Index;
	}

	int vNIndex = edgeVertice[v1Index][v2Index][0];
	return vNIndex;
}



void myDisplay(void) {
	glClear(GL_COLOR_BUFFER_BIT);
	glRotatef(45, 1, 1, 1);
	glFrontFace(GL_CCW);

	for (int i = 0; i < 4; ++i)      // 有四个面，循环六次    
	{
		glBegin(GL_LINE_LOOP);
		for (int j = 0; j < 3; ++j)     // 每个面有四个顶点，循环四次    
			glVertex3fv(vertex_list[index_list[i][j]]);
		glEnd();
	}

	idd();

	jishu = 0;

	for (int i = 0; i < nFaces; i++)
	{
		int vaIndex = index_list[i][0];
		int vbIndex = index_list[i][1];
		int vcIndex = index_list[i][2];

		int vpIndex = addEdgeVertice(vaIndex, vbIndex, vcIndex);
		int vqIndex = addEdgeVertice(vbIndex, vcIndex, vaIndex);
		int vrIndex = addEdgeVertice(vaIndex, vcIndex, vbIndex);

		newFaces[jishu][0] = vaIndex; newFaces[jishu][1] = vpIndex; newFaces[jishu][2] = vrIndex; jishu++;
		newFaces[jishu][0] = vpIndex; newFaces[jishu][1] = vbIndex; newFaces[jishu][2] = vqIndex; jishu++;
		newFaces[jishu][0] = vrIndex; newFaces[jishu][1] = vqIndex; newFaces[jishu][2] = vcIndex; jishu++;
		newFaces[jishu][0] = vrIndex; newFaces[jishu][1] = vpIndex; newFaces[jishu][2] = vqIndex; jishu++;
	}


	int vNOpposite2Index;
	int vNOpposite1Index;
	for (int v1 = 0; v1 < nVertices - 1; v1++)
		for (int v2 = v1; v2 < nVertices; v2++)
		{

			int vNIndex = edgeVertice[v1][v2][0];
			
				if (vNIndex != 0)
				{
				 {
					vNOpposite1Index = edgeVertice[v1][v2][1];
					vNOpposite2Index = edgeVertice[v1][v2][2];
			 	 }

				if (vNOpposite2Index == 0)
				 {
					for (int t = 0; t < 3; t++)
					{
						newVertices[vNIndex][t] = 1 / 2 * (vertex_list[v1][t] + vertex_list[v2][t]);
					}
				 }
				else
				 {
					for (int t = 0; t < 3; t++)
					{
						newVertices[vNIndex][t] = 3 / 8 * (vertex_list[v1][t] + vertex_list[v2][t]) + 1 / 8 * (vertex_list[vNOpposite1Index][t] + vertex_list[vNOpposite2Index][t]);
					}
				 }
			    }
		}







	glFlush();
}


int main(int argc, char *argv[])
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(400, 400);
	glutCreateWindow("opengl1");
	glutDisplayFunc(&myDisplay);
	glutMainLoop();
	return 0;
}  


#include <windows.h>      
#include<GL/GLUT.H>        
#include <math.h>            
#include <gl/GL.h>            
#include<iostream>     
#include <stdlib.h>    

template <class T>
int getArrayLen(T& array)
{//使用模板定义一 个函数getArrayLen,该函数将返回数组array的长度    
	return (sizeof(array) / sizeof(array[0]));
}


#define pi 3.1415927f;      
float a = 0.5f;
float u = sqrtf(2.0) / 3;
float v = float(1) / 3;
float t = sqrtf(6.0) / 3;

float M_PI = 3.14159265f;


static float c = M_PI / 180.0f; //弧度和角度转换参数    
static int du = 90, oldmy = -1, oldmx = -1; //du是视点绕y轴的角度,opengl里默认y轴是上方向    
static float r = 3.1f, h = 0.0f; //r是视点绕y轴的半径,h是视点高度即在y轴上的坐标    
float zoom = 1.0f;


static const GLfloat vertex_list[][3] = {
	0.0f, 0.0f, a,
	-2 * a*u, 0, -a*v,
	a*u, a*t, -a*v,
	a*u, -a*t, -a*v
};

static const GLint index_list[][3] = {
	0, 1, 2,
	0, 2, 3,
	0, 1, 3,
	1, 2, 3,
};

int newIndexOfVertices;
int ***edgeVertice;
float newVertices[100][3];
int newFaces[100][3];

int jishu;

int nVertices = getArrayLen(vertex_list);
int nFaces = getArrayLen(index_list);

void idd()
{


	for (int i = 0; i < nVertices; i++)
		for (int j = 0; j < 3; j++)
		{
			newVertices[i][j] = vertex_list[i][j];
		}


	//动态定义三维数组：      
	edgeVertice = new int**[nVertices];
	for (int i = 0; i < nVertices; i++)
	{
		edgeVertice[i] = new int*[nVertices];
	}

	for (int i = 0; i <nVertices; i++)
		for (int j = 0; j < nVertices; j++)
			edgeVertice[i][j] = new int[3];
	//输入三维数组值：      

	for (int i = 0; i < nVertices; i++)
		for (int j = 0; j < nVertices; j++)
			for (int k = 0; k < 3; k++)
				edgeVertice[i][j][k] = 0;

	newIndexOfVertices = nVertices;
}





int addEdgeVertice(int v1Index, int v2Index, int v3Index)
{
	if (v1Index > v2Index)
	{
		int vTmp = v1Index;
		v1Index = v2Index;
		v2Index = vTmp;
	}

	if (edgeVertice[v1Index][v2Index][0] == 0)
	{
		newIndexOfVertices = newIndexOfVertices + 1;
		edgeVertice[v1Index][v2Index][0] = newIndexOfVertices - 1;
		edgeVertice[v1Index][v2Index][1] = v3Index;
	}
	else
	{
		edgeVertice[v1Index][v2Index][2] = v3Index;
	}

	int vNIndex = edgeVertice[v1Index][v2Index][0];
	return vNIndex;
}



void myDisplay(void) {
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glEnable(GL_DEPTH_TEST);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(80.0f, 1.0f, 1.0f, 1000.0f);
	glMatrixMode(GL_MODELVIEW);


	//printf("At:%.2f %.2f %.2f\n",r*cos(c*du),h,r*sin(c*du)); //这就是视点的坐标    
	glLoadIdentity();
	gluLookAt(r*cos(c*du)*cos(c*h)*zoom, r*sin(c*h)*zoom, r*sin(c*du)*cos(c*h)*zoom, 0, 0, 0, 0, 1, 0); //从视点看远点,y轴方向(0,1,0)是上方向    
	glFrontFace(GL_CCW);

	//for (int i = 0; i < 4; ++i)      // 有四个面，循环六次      
	//{
	//	glBegin(GL_LINE_LOOP);
	//	for (int j = 0; j < 3; ++j)     // 每个面有四个顶点，循环四次      
	//		glVertex3fv(vertex_list[index_list[i][j]]);
	//	glEnd();
	//}

	idd();

	jishu = 0;

	for (int i = 0; i < nFaces; i++)
	{
		int vaIndex = index_list[i][0];
		int vbIndex = index_list[i][1];
		int vcIndex = index_list[i][2];

		int vpIndex = addEdgeVertice(vaIndex, vbIndex, vcIndex);
		int vqIndex = addEdgeVertice(vbIndex, vcIndex, vaIndex);
		int vrIndex = addEdgeVertice(vaIndex, vcIndex, vbIndex);

		newFaces[jishu][0] = vaIndex; newFaces[jishu][1] = vpIndex; newFaces[jishu][2] = vrIndex; jishu++;
		newFaces[jishu][0] = vpIndex; newFaces[jishu][1] = vbIndex; newFaces[jishu][2] = vqIndex; jishu++;
		newFaces[jishu][0] = vrIndex; newFaces[jishu][1] = vqIndex; newFaces[jishu][2] = vcIndex; jishu++;
		newFaces[jishu][0] = vrIndex; newFaces[jishu][1] = vpIndex; newFaces[jishu][2] = vqIndex; jishu++;
	}


	int vNOpposite2Index;
	int vNOpposite1Index;
	for (int v1 = 0; v1 < nVertices - 1; v1++)
		for (int v2 = v1; v2 < nVertices; v2++)
		{

			int vNIndex = edgeVertice[v1][v2][0];

			if (vNIndex != 0)
			{
				{
					vNOpposite1Index = edgeVertice[v1][v2][1];
					vNOpposite2Index = edgeVertice[v1][v2][2];
				}

				if (vNOpposite2Index == 0)
				{
					for (int t = 0; t < 3; t++)
					{
						newVertices[vNIndex][t] = 1 / 2 * (vertex_list[v1][t] + vertex_list[v2][t]);
					}
				}
				else
				{
					for (int t = 0; t < 3; t++)
					{
						newVertices[vNIndex][t] = 3 / 8 * (vertex_list[v1][t] + vertex_list[v2][t]) + 1 / 8 * (vertex_list[vNOpposite1Index][t] + vertex_list[vNOpposite2Index][t]);
					}
				}
			}
		}

	for (int v = 0; v < nVertices; v++)
	{

		
		int **p = new int*[nVertices];
		for (int i = 0; i<nVertices; i++)
		{
			p[i] = new int[Column];
		}


		for (int t = 0; t < 3; t++)
		{
			newVertices[v][t] = vertex_list[v][t] ;
		}
	}

	for (int i = 0; i < 16; ++i)      // 有四个面，循环六次      
	{
		glBegin(GL_LINE_LOOP);
		for (int j = 0; j < 3; ++j)     // 每个面有四个顶点，循环四次      
			glVertex3fv(newVertices[newFaces[i][j]]);
		glEnd();
	}





	glFlush();
	glutSwapBuffers();
}

void Mouse(int button, int state, int x, int y) //处理鼠标点击    
{
	if (state == GLUT_DOWN) //第一次鼠标按下时,记录鼠标在窗口中的初始坐标    
		oldmx = x, oldmy = y;


	if (state == GLUT_UP && button == GLUT_WHEEL_UP)
	{
		zoom = zoom + 0.2;
		if (zoom >= 2)zoom = 2;

		//glutPostRedisplay();  
	}
	if (state == GLUT_UP && button == GLUT_WHEEL_DOWN)
	{
		zoom = zoom - 0.2;
		if (zoom <= 0.6) zoom = 0.6;
		//glutPostRedisplay();  
	}
}

void onMouseMove(int x, int y) //处理鼠标拖动      
{
	//printf("%d\n",du);      
	du += x - oldmx; //鼠标在窗口x轴方向上的增量加到视点绕y轴的角度上，这样就左右转了      
	h += (y - oldmy); //鼠标在窗口y轴方向上的改变加到视点的y坐标上，就上下转了      
	if (h > 90)
	{
		h = 90;
	}
	else if (h < -90)
	{
		h = -90;
	}
	//if (h>1.0f) h = 1.0f; //视点y坐标作一些限制，不会使视点太奇怪      
	//else if (h<-1.0f) h = -1.0f;      
	oldmx = x, oldmy = y; //把此时的鼠标坐标作为旧值，为下一次计算增量做准备      
}



int main(int argc, char *argv[])
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(400, 400);
	glutCreateWindow("OpenGL");
	glutDisplayFunc(myDisplay);
	glutIdleFunc(myDisplay);  //设置不断调用显示函数    
	glutMouseFunc(Mouse);
	glutMotionFunc(onMouseMove);
	glutMainLoop();
	return 0;
}


三维图形学知识分享--三角剖分网格细分详细代码实现
80后程序员的技术分享
04-26 778
该算法将每个四边形分割成四个新的四边形，并生成新的顶点，然后根据一定的规则对顶点进行移动。：Doo-Sabin 细分也是一种基于四边形网格的迭代细分方法，它将每个四边形分割成若干个新的四边形，并生成新的顶点。：这是最简单的细分方法之一，它将每个三角形或四面体分割成若干个更小的三角形或四面体，保持原始网格的形状和拓扑不变。这样可以使得网格更加平滑，但是可能会改变原始网格的形状。对于由不规则三角形或四面体组成的网格，细分可以改善网格的质量，使其具有更均匀的形状和大小，从而提高数值计算的精度和稳定性。
第016封“情书”：防线houdini Loops & Subdivision迭代循环与细分
sinat_33115291的博客
07-17 356
▉底线 是人性的最后一道防线    反攻的号角已经吹响，法军发起反攻，让你溃不成军。我的防线固若金汤，谁也休想攻破。要塞失陷！这一节我们要看一下    使grid逐渐沦陷的迭代循环&细分如何制作。这一节要实现的效果.....▉今天是41岁第354天周一这是写给houdini的第016封“情书”先上节点流程图 本...
geogen:生成细分深度可变的四面体，六面体，八面体和二十面体
05-23
地源 生成细分深度可变的四面体，六面体，八面体和二十面体 我正在进行的宇宙业余爱好的一部分
等距可细分的四面体
03-06
等距可细分的四面体
用四面体中点三角网迭代法进行椭球体曲面细分的实践
行走的过客
08-28 462
按照《3D Engine Design for Virtual Globes》书上4.1.1和4.1.2中介绍的方法，使用webgl从头到尾撸一波，效果如下（录制gif分辨率问题请忽略其中阴影线）： 迭代层数为0（原始四面体）： 迭代次数为1： 迭代次数为2： 迭代次数为3： 迭代次数为4： 书中说到4已经可以了，但是我觉得到5还是有区别，更加圆，但是5以后确实看不到什么区别了，迭代次数为5： 方法大致思路是： 1.用四个点绘制一个四面体： 2.对四面体每条边取中点投影到椭球体上，对于每个三角
Qt OpenGL（07）递归细分四面体法绘制球体
读书笔记
01-10 1610
OpenGL 利用 递归细分方法绘制 球面
OpenGL递归细分四面体法绘制球体
JeremyZhao1998的博客
06-30 6874
北京航空航天大学计算机学院 2020春季计算机图形学课程第三次作业的一部分，使用OpenGL，用递归细分四面体法绘制球体
经典三角网格细分算法详解：Loop方法与交互式优化
本文主要探讨了"loop网格细分算法"在三维模型构建中的重要应用。三维模型的精细度对于设计和渲染的准确性和真实感至关重要。Loop算法作为一种经典的三角网格细分方法，它通过对原始三角形网格进行迭代操作，增加新...
Toolbox Wavelets on Meshes：在 3D 网格上计算小波变换的工具箱-matlab开发
06-01
例如它允许计算* 在球体上定义的函数的小波变换，该函数已在 4:1 细分四面体上采样。 * 在 4:1 细分粗三角剖分上定义的函数的小波变换。 * 半规则网格的小波变换，被视为定义在 4:1 细分粗三角剖分上的 3 个函数。 ...
3DSMAX中英文对照大全(从A-Z分类)
Zen
11-05 5133
A 　　Absolute Mode Transform Type-in绝对坐标方式变换输入 　　Absolute/Relative Snap Toggle Mode绝对/相对捕捉开关模式 　　ACIS Options ACIS选项 　　Activate活动；激活 　　Activate All Maps激活所有贴图 　　Activate Grid激活栅格；激活网格 　　Activate Grid Object激活网格对象；激活网格物体 　　Activate Home Grid激活主栅格；激活主网格 　　Act
loop细分曲面算法
10-21
loop细分曲面算法
Catmull-Clark细分的MATLAB实现
05-16
Catmull-Clark细分的MATLAB实现，test.m文件中是执行文件，具体的算法在CCSubdivision.m 中，对于有边界和无边界的四边形网格都是可以用的，输入和输出都是obj文件
网格细分 —— Loop细分
HachiLin的博客
05-19 7201
网格细分 —— Loop细分 1. 定义 网格细分是通过按一定规则给网格增加顶点和面片的数量，让网格模型变得更加光滑。Loop细分方法是最早一种基于三角网格的细分方法。一次细分的过程分为两步骤，第一步是增加顶点；第二步是对顶点位置进行调整，使得网格更加光滑。 2. 增加顶点 Loop细分在每条边上都增加一个顶点，并且同一个三角形内的顶点用新增顶点连接起来，以构成新的三角形。 3. 顶点位置的调整 ...
网格细分 Loop细分算法
qq_44654498的博客
05-10 2604
Loop网格细分的思想
三角网格细分算法 —— Loop 算法
hdu_wyx的博客
12-26 6794
三角网格细分算法 —— Loop细分 主要参考文章： https://zhuanlan.zhihu.com/p/144400261 https://blog.youkuaiyun.com/McQueen_LT/article/details/106136324 Loop细分： 是一种专门针对三角形面的细分方法——主要思想就是1个旧三角面片分成4个新三角面片 （主要和 CC相类似,利用 新增边点和 更新原始点 来新增模型的三角形网格数量 -> 细分） Loop 细分曲面过程就是插入...
微信小程序多列选择器实现日期+时间的选择
苏苏就是小苏苏的博客
12-09 2525
1.实现效果 2.实现原理 mode='multiSelector'多列选择器 自定义范围数组range 3.实现代码 <!--pages/jsCase/multiTime/index4.wxml--> <view class="act_box"> <view class="act_item flex j_b"> <view class="nowp"><text class="require">*</text>
渐进插值的LOOP 曲面细分
拉风小宇的博客
03-22 4066
目前很多细分方法都存在不能用同一种方法处理封闭网格和开放网格的问题。对此，一种新的基于插值技术的LOOP 曲面细分方法，其主要思想就是给定一个初始三角网格$M$，反复生成新的顶点，新顶点是通过其相邻顶点的约束求解得到的，从而构造一个新的控制网格$\bar{M}$，在取极限的情况下，可以证明插值过程是收敛的;因为生成新顶点使用的是与其相连顶点的约束求解得到的，本质上是一种局部方法，所以，该方法很容易定义。
网格细分算法（Catmull-Clark subdivision & Loop subdivision）附源码
热门推荐
拉风小宇的博客
05-28 2万+
转载自：http://www.cnblogs.com/shushen/p/5251070.html 下图描述了细分的基本思想，每次细分都是在每条边上插入一个新的顶点，可以看到随着细分次数的增加，折线逐渐变成一条光滑的曲线。曲面细分需要有几何规则和拓扑规则，几何规则用于计算新顶点的位置，拓扑规则用于确定新顶点的连接关系。下面介绍两种网格细分方法：Catmull-Clark细分和Loop细分
Loop 细分曲面（loop subdivision）详解，附Python完整代码
McQueen_LT的博客
06-01 1万+
一、概述 在做完了 catmull−clarksubdivisioncatmull-clark\quad subdivisioncatmull−clarksubdivision 之后，紧接着继续做 loopsubdivisionloop\quad subdivisionloopsubdivision，但是跟之前一样，网上的帖子都是直接给出了各个控制点新增或更新时，所有相关点的权重，并没有给出具体过程是怎么做的，而且在做 looplooploop细分 的时候并没有像之前一样有完整的“保真代码”（能够体现出具体
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

拉风小宇

请我喝个咖啡呗

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

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

打赏作者

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

抵扣说明：

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

余额充值