loop & butterfly subdivison

最新推荐文章于 2023-05-12 10:08:30 发布
最新推荐文章于 2023-05-12 10:08:30 发布
阅读量957 收藏
点赞数
分类专栏： opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lcbwlx/article/details/41595193
版权
这篇博客主要介绍了在作业中应用的Loop细分算法和Butterfly细分算法。Loop算法参考了http://2n1.org/opengl/proj2/的实现，而Butterfly算法则依照PPT的描述进行。博客中提供了Loop.h文件和Butterfly的相关内容。
摘要由CSDN通过智能技术生成

还是作业的一部分……


loop借鉴了http://2n1.org/opengl/proj2/里面的算法， 感谢！


butterfly则是根据ppt的算法。


一下是loop。h

#ifndef LOOP_H_
#define LOOP_H_

#include "halfedge_vector.h"
#define PI 3.14159265359

#include <assert.h>

halfegde_point getMiddlePoint(halfegde_point a, halfegde_point b)
{
	halfegde_point newp1;

	newp1.x = (a.x+b.x)/2;
	newp1.y = (a.y+b.y)/2;
	newp1.z = (a.z+b.z)/2;

	newp1.isnew = true;
	newp1.edge_index = -1;

	newp1.beighbour.clear();

	return newp1;
}

void addEdge(int p1, int p2, int p3, vector<halfegde_point> &p, vector<halfegde> &e, vector<halfedge_face> &f) 
{
	halfedge_face f1;
	f.push_back(f1);
	int fi = f.size()-1;

	halfegde e1, e2, e3;
	e.push_back(e1);
	e.push_back(e2);
	e.push_back(e3);

	int ei1, ei2, ei3;
	ei3 = e.size()-1;
	ei2 = ei3-1;
	ei1 = ei2-1;

	e[ei1].original_point_index = p1;
	e[ei1].next_edge_index = ei2;
	e[ei1].previous_edge_index = ei3;
	e[ei1].twin_edge_index = -1;
	e[ei1].face_index = fi;
	e[ei1].split_point_index = -1;
	e[ei1].issplited = false;
	p[p1].edge_index = ei1;

	e[ei2].original_point_index = p2;
	e[ei2].next_edge_index = ei3;
	e[ei2].previous_edge_index = ei1;
	e[ei2].twin_edge_index = -1;
	e[ei2].face_index = fi;
	e[ei2].split_point_index = -1;
	e[ei2].issplited = false;
	p[p2].edge_index = ei2;

	e[ei3].original_point_index = p3;
	e[ei3].next_edge_index = ei1;
	e[ei3].previous_edge_index = ei2;
	e[ei3].twin_edge_index = -1;
	e[ei3].face_index = fi;
	e[ei3].split_point_index = -1;
	e[ei3].issplited = false;
	p[p3].edge_index = ei3;

	f[fi].one_edge_index = ei1;
}

void update_newpoint(vector<halfegde_point>&p, vector<halfedge_face>f, vector<halfegde>e, vector<halfegde_point> &p2)
{
	// points initial
	for (int i = 0; i< p.size(); i++)
	{
		// is it right?
		// address or data?

		halfegde_point tmp;
		tmp.x = p[i].x;
		tmp.y = p[i].y;
		tmp.z = p[i].z;
		tmp.isnew = p[i].isnew;
		tmp.edge_index = p[i].edge_index;

		for (int j  = 0; j< p[i].beighbour.size(); j++)
		{
			tmp.beighbour.push_back(p[i].beighbour[j]);
		}

		p2.push_back(tmp);
	}

	for (int i = 0; i< p.size(); i++)
	{
		vector<int> neigh = p[i].beighbour;

		int n = neigh.size();
		float bn = 1.25-(3+2*cos(2*PI/n))*(3+2*cos(2*PI/n))/32;
		float an = n*(1-bn)/bn;

		float x = 0, y = 0, z = 0;

		for (int j = 0; j< n; j++)
		{
			x+= p[neigh[j]].x;
			y+= p[neigh[j]].y;
			z+= p[neigh[j]].z;
		}

		p2[i].x = (p[i].x*an+x)/(an+n);
		p2[i].y = (p[i].y*an+y)/(an+n);
		p2[i].z = (p[i].z*an+z)/(an+n);
	}
}

void getloop(vector<halfegde_point>p, vector<halfedge_face>f, vector<halfegde>e, 
	vector<halfegde_point> &p2, vector<halfedge_face> &f2, vector<halfegde> &e2)
{
	// points initial
	for (int i = 0; i< p.size(); i++)
	{
		// is it right?
		// address or data?

		halfegde_point tmp;
		tmp.x = p[i].x;
		tmp.y = p[i].y;
		tmp.z = p[i].z;
		tmp.isnew = p[i].isnew;
		tmp.edge_index = p[i].edge_index;

		for (int j  = 0; j< p[i].beighbour.size(); j++)
		{
			tmp.beighbour.push_back(p[i].beighbour[j]);
		}

		p2.push_back(tmp);
	}

	// face
	for (int i = 0; i< f.size(); i++)
	{
		int edge1 = f[i].one_edge_index;
		int edge2 = e[edge1].next_edge_index;
		int edge3 = e[edge2].next_edge_index;

		assert(e[edge3].next_edge_index == edge1);

		int point1 = e[edge1].original_point_index;
		int point2 = e[edge2].original_point_index;
		int point3 = e[edge3].original_point_index;

		int newpindex1, newpindex2, newpindex3;
		// e1
		if (e[edge1].issplited)
		{
			newpindex1 = e[edge1].split_point_index;
		}
		else
		{
			halfegde_point newp1 = getMiddlePoint(p[point1], p[point2]);
			p2.push_back(newp1);
			newpindex1 = p2.size()-1;

			e[edge1].issplited = true;
			e[edge1].split_point_index = newpindex1;
			int etwin = e[edge1].twin_edge_index;
			if (etwin != -1)
			{
				e[etwin].issplited = true;
				e[etwin].split_point_index = newpindex1;
			}

		}

		// e2
		if (e[edge2].issplited)
		{
			newpindex2 = e[edge2].split_point_index;
		}
		else
		{
			halfegde_point newp2 = getMiddlePoint(p[point2], p[point3]);
			p2.push_back(newp2);
			newpindex2 = p2.size()-1;

			e[edge2].issplited = true;
			e[edge2].split_point_index = newpindex2;
			int etwin = e[edge2].twin_edge_index;
			if (etwin != -1)
			{
				e[etwin].issplited = true;
				e[etwin].split_point_index = newpindex2;
			}
		}

		// e3
		if (e[edge3].issplited)
		{
			newpindex3 = e[edge3].split_point_index;
		}
		else
		{
			halfegde_point newp3 = getMiddlePoint(p[point3], p[point1]);
			p2.push_back(newp3);
			newpindex3 = p2.size()-1;

			e[edge3].issplited = true;
			e[edge3].split_point_index = newpindex3;
			int etwin = e[edge3].twin_edge_index;
			if (etwin != -1)
			{
				e[etwin].issplited = true;
				e[etwin].split_point_index = newpindex3;
			}
		}

		// add face;
		addEdge(point1, newpindex1, newpindex3,p2, e2, f2);
		addEdge(newpindex1, point2, newpindex2,p2, e2, f2);
		addEdge(newpindex3, newpindex2, point3,p2, e2, f2);
		addEdge(newpindex1, newpindex2, newpindex3,p2, e2, f2);
	}

	// twins edge
	for (int i = 0; i< e2.size(); i++)
	{
		for (int j = i+1; j< e2.size(); j++)
		{
			int abegin = e2[i].original_point_index;
			int aend = e2[e2[i].next_edge_index].original_point_index;

			int bbegin = e2[j].original_point_index;
			int bend  = e2[e2[j].next_edge_index].original_point_index;

			if (abegin == bend
				&&aend == bbegin)
			{
				e2[i].twin_edge_index = j;
				e2[j].twin_edge_index = i;
				break;
			}
			/*
			if (twins(e2, e2[i], e2[j]))
			{
				e2[i].twin_edge_index = j;
				e2[j].twin_edge_index = i;
				break;
			}
			*/
		}
	}

	// update neighbour
	update_neighbour(p2, f2, e2);

	// update points
	vector<halfegde_point> p3;
	update_newpoint(p2, f2, e2, p3);
	p2 = p3;
}

#endif

一下是butterfly


#ifndef BUTTERFLY_H_
#define BUTTERFLY_H_

#include "halfedge_vector.h"
#define PI 3.14159265359

#include <assert.h>

void calculate_points(halfegde_point a, int bindex, vector<halfegde_point> p, float &x, float &y, float &z)
{
	int avaluence = a.beighbour.size();

	if (avaluence == 3)
	{
		float aweight[] = {0.417, -0.083, -0.083};

		// a
		int ab = 0;
		while (a.beighbour[ab] != bindex)
		{
			ab ++;
		}

		for (int i = 0; i< 3; i++)
		{
			int ai = a.beighbour[(ab+i)%3];

			x += p[ai].x*aweight[i];
			y += p[ai].y*aweight[i];
			z += p[ai].z*aweight[i];
		}

		float aw2 = 0.75;

		x += a.x * aw2;
		y += a.y * aw2;
		z += a.z * aw2;
	}

	else if (avaluence == 4)
	{
		float aweight[] = {0.375, 0, -0.125, 0};

		// a
		int ab = 0;
		while (a.beighbour[ab] != bindex)
		{
			ab ++;
		}

		for (int i = 0; i< 4; i++)
		{
			int ai = a.beighbour[(ab+i)%4];

			x += p[ai].x*aweight[i];
			y += p[ai].y*aweight[i];
			z += p[ai].z*aweight[i];
		}

		float aw2 = 0.75;

		x += a.x * aw2;
		y += a.y * aw2;
		z += a.z * aw2;
	}

	else
	{
		float *aweight = new float[avaluence];
		for (int i = 0; i< avaluence; i++)
		{
			aweight[i] = 1.0/avaluence*(0.25+0.5*cos(4*PI/avaluence*i)+cos(2*PI/avaluence*i));
		}

		// a
		int ab = 0;
		while (a.beighbour[ab] != bindex)
		{
			ab ++;
		}

		for (int i = 0; i< avaluence; i++)
		{
			int ai = a.beighbour[(ab+i)%avaluence];

			x += p[ai].x*aweight[i];
			y += p[ai].y*aweight[i];
			z += p[ai].z*aweight[i];
		}

		float aw2 = 1;
		for (int i = 0; i< avaluence; i++)
		{
			aw2 -= aweight[i];
		}

		// aw2  =0;

		x += a.x * aw2;
		y += a.y * aw2;
		z += a.z * aw2;

		delete [] aweight;
	}
}

halfegde_point getMiddlePoint(halfegde_point a, int aindex, halfegde_point b, int bindex, vector<halfegde_point> p)
{
	halfegde_point newp1;

	int avaluence = a.beighbour.size();
	int bvalance = b.beighbour.size();


			float x = 0, y = 0, z = 0;

	if (avaluence == 6
		&&bvalance == 6)
	{
		float aweight[] = {0.5, 0.125, -0.0625, 0, -0.0625, 0.125};
		float bweight[] = {0.5, 0, -0.0625, 0, -0.0625, 0};

		// a
		int ab = 0;
		while (a.beighbour[ab] != bindex)
		{
			ab ++;
		}

		int bb = 0;
		while (b.beighbour[bb] != aindex)
		{
			bb ++;
		}

		for (int i = 0; i< 6; i++)
		{
			int ai = a.beighbour[(ab+i)%6];
			int bi = b.beighbour[(bb+i)%6];

			x += p[ai].x*aweight[i] + p[bi].x*bweight[i]; 
			y += p[ai].y*aweight[i] + p[bi].y*bweight[i]; 
			z += p[ai].z*aweight[i] + p[bi].z*bweight[i]; 
		}
	}

	else
	{
		calculate_points(a, bindex, p, x, y, z);
		calculate_points(b, aindex, p, x, y, z);

		x = x/2;
		y = y/2;
		z = z/2;
	}

	newp1.x = x;
	newp1.y = y;
	newp1.z = z;

	newp1.isnew = true;
	newp1.edge_index = -1;

	newp1.beighbour.clear();

	return newp1;
}

void addEdge(int p1, int p2, int p3, vector<halfegde_point> &p, vector<halfegde> &e, vector<halfedge_face> &f) 
{
	halfedge_face f1;
	f.push_back(f1);
	int fi = f.size()-1;

	halfegde e1, e2, e3;
	e.push_back(e1);
	e.push_back(e2);
	e.push_back(e3);

	int ei1, ei2, ei3;
	ei3 = e.size()-1;
	ei2 = ei3-1;
	ei1 = ei2-1;

	e[ei1].original_point_index = p1;
	e[ei1].next_edge_index = ei2;
	e[ei1].previous_edge_index = ei3;
	e[ei1].twin_edge_index = -1;
	e[ei1].face_index = fi;
	e[ei1].split_point_index = -1;
	e[ei1].issplited = false;
	p[p1].edge_index = ei1;

	e[ei2].original_point_index = p2;
	e[ei2].next_edge_index = ei3;
	e[ei2].previous_edge_index = ei1;
	e[ei2].twin_edge_index = -1;
	e[ei2].face_index = fi;
	e[ei2].split_point_index = -1;
	e[ei2].issplited = false;
	p[p2].edge_index = ei2;

	e[ei3].original_point_index = p3;
	e[ei3].next_edge_index = ei1;
	e[ei3].previous_edge_index = ei2;
	e[ei3].twin_edge_index = -1;
	e[ei3].face_index = fi;
	e[ei3].split_point_index = -1;
	e[ei3].issplited = false;
	p[p3].edge_index = ei3;

	f[fi].one_edge_index = ei1;
}

void getbutterfly(vector<halfegde_point>p, vector<halfedge_face>f, vector<halfegde>e, 
	vector<halfegde_point> &p2, vector<halfedge_face> &f2, vector<halfegde> &e2)
{
	// points initial
	for (int i = 0; i< p.size(); i++)
	{
		// is it right?

		halfegde_point tmp;
		tmp.x = p[i].x;
		tmp.y = p[i].y;
		tmp.z = p[i].z;
		tmp.isnew = p[i].isnew;
		tmp.edge_index = p[i].edge_index;

		for (int j  = 0; j< p[i].beighbour.size(); j++)
		{
			tmp.beighbour.push_back(p[i].beighbour[j]);
		}
		p2.push_back(tmp);
	}

	// face
	for (int i = 0; i< f.size(); i++)
	{
		int edge1 = f[i].one_edge_index;
		int edge2 = e[edge1].next_edge_index;
		int edge3 = e[edge2].next_edge_index;

		assert(e[edge3].next_edge_index == edge1);

		int point1 = e[edge1].original_point_index;
		int point2 = e[edge2].original_point_index;
		int point3 = e[edge3].original_point_index;

		int newpindex1, newpindex2, newpindex3;
		// e1
		if (e[edge1].issplited)
		{
			newpindex1 = e[edge1].split_point_index;
		}
		else
		{
			halfegde_point newp1 = getMiddlePoint(p[point1], point1, p[point2], point2, p);
			p2.push_back(newp1);
			newpindex1 = p2.size()-1;

			e[edge1].issplited = true;
			e[edge1].split_point_index = newpindex1;
			int etwin = e[edge1].twin_edge_index;
			if (etwin != -1)
			{
				e[etwin].issplited = true;
				e[etwin].split_point_index = newpindex1;
			}

		}

		// e2
		if (e[edge2].issplited)
		{
			newpindex2 = e[edge2].split_point_index;
		}
		else
		{
			halfegde_point newp2 = getMiddlePoint(p[point2], point2, p[point3], point3, p);
			p2.push_back(newp2);
			newpindex2 = p2.size()-1;

			e[edge2].issplited = true;
			e[edge2].split_point_index = newpindex2;
			int etwin = e[edge2].twin_edge_index;
			if (etwin != -1)
			{
				e[etwin].issplited = true;
				e[etwin].split_point_index = newpindex2;
			}
		}

		// e3
		if (e[edge3].issplited)
		{
			newpindex3 = e[edge3].split_point_index;
		}
		else
		{
			halfegde_point newp3 = getMiddlePoint(p[point3], point3, p[point1], point1, p);
			p2.push_back(newp3);
			newpindex3 = p2.size()-1;

			e[edge3].issplited = true;
			e[edge3].split_point_index = newpindex3;
			int etwin = e[edge3].twin_edge_index;
			if (etwin != -1)
			{
				e[etwin].issplited = true;
				e[etwin].split_point_index = newpindex3;
			}
		}

		// add face;
		addEdge(point1, newpindex1, newpindex3,p2, e2, f2);
		addEdge(newpindex1, point2, newpindex2,p2, e2, f2);
		addEdge(newpindex3, newpindex2, point3,p2, e2, f2);
		addEdge(newpindex1, newpindex2, newpindex3,p2, e2, f2);
	}

	// twins edge
	for (int i = 0; i< e2.size(); i++)
	{
		for (int j = i+1; j< e2.size(); j++)
		{
			int abegin = e2[i].original_point_index;
			int aend = e2[e2[i].next_edge_index].original_point_index;

			int bbegin = e2[j].original_point_index;
			int bend  = e2[e2[j].next_edge_index].original_point_index;

			if (abegin == bend
				&&aend == bbegin)
			{
				e2[i].twin_edge_index = j;
				e2[j].twin_edge_index = i;
				break;
			}
			/*
			if (twins(e2, e2[i], e2[j]))
			{
				e2[i].twin_edge_index = j;
				e2[j].twin_edge_index = i;
				break;
			}
			*/
		}
	}

	// update new point
	update_neighbour(p2, f2, e2);
}

#endif

lcbwlx
关注
专栏目录
【图形学实验】Loop Subdivision与Modified Butterfly Subdivision
Vikanill的博客
11-18 1055
crease是什么 当说一条边是creaseedge的时候，我们的意思其实是说这条边是sharpedge. 为的是在Subdivision的时候能够保留一些锐利的部分，例如 正常的LoopSubdivision下图中的色边即为标记的sharpedge，标记出来的目的是为了在之后的Subdivision过程中还能保持锐利。 添加了对crease处理的LoopSubdivisionLoopSubdivision 参考：Piecewise Smooth Surface Reconstruc...
Loop subdivision（循环细分） && modify butterfly subdivision（改进的蝴蝶细分）算法实现
longroad1216的博客
11-30 3243
最近完成了计算机图形学的实验，实现了以halfedge（半边）数据结构为基础的Loop subdivision（循环细分） 和 modified butterfly subdivision（改进的蝴蝶细分）两种算法，并用OpenGL进行可视化。 模型为.wrl（虚拟现实文本格式）文件，可以对 #VRML V2.0 utf8 标准的模型进行读写和细分。 算法 细分算法主要参考了课程lectur...
关于Hexo主题butterfly的副标题里的sub内容不能显示的解决方法
最新发布
weixin_50473027的博客
05-12 761
Hexo主题butterlfy副标题sub配置不显示解决方法
网格细分算法（Catmull-Clark subdivision & Loop subdivision）附源码
热门推荐
拉风小宇的博客
05-28 2万+
转载自：http://www.cnblogs.com/shushen/p/5251070.html 下图描述了细分的基本思想，每次细分都是在每条边上插入一个新的顶点，可以看到随着细分次数的增加，折线逐渐变成一条光滑的曲线。曲面细分需要有几何规则和拓扑规则，几何规则用于计算新顶点的位置，拓扑规则用于确定新顶点的连接关系。下面介绍两种网格细分方法：Catmull-Clark细分和Loop细分
【建模学习笔记001-SubDivision Surface】
平台不倒，记录不息
11-13 420
Blender--subdivision
9、图
whj95的专栏
05-26 2538
作者：whj95导读导读 图的定义 图的术语 无向图 有向图 图的表示 圈图C图 星图S图 轮图W图 完全图K图 二部图偶图 完全二部图 子图 生成子图 导出子图 主子图 并运算 图的同构 邻接表 adjacency list 邻接矩阵 adjacency matrix 关系矩阵 incidence matrix 同构 isomorphism 连通性 connectivity 基本概念 无向图的连
django报错：render() got an unexpected keyword argument 'renderer'
zhuyongru的专栏
08-13 2100
TypeError at /admin-ds/article/articlespost/add/ render() got an unexpected keyword argument 'renderer' Request Method: GET Request URL: http://localhost:8000/admin-ds/article/articlespost/...
Games101课程笔记_lecture12_几何(网格细分)+Shodow map
qq_41286360的博客
03-20 1271
几何网格的细分和简化把增加点，调整点的步骤理解清楚。 shadow map只能做硬阴影，核心是比较从光源出发记录的深度值和从相机出发看到的点到光源的深度值的大小。
[pytorch修改]dataloader.py 实现darknet中的subdivision功能
weixin_30257433的博客
10-17 312
dataloader.py import random import torch import torch.multiprocessing as multiprocessing from torch._C import _set_worker_signal_handlers, _update_worker_pids, \ _remove_worker_pids, _e...
Subdivision细分曲面建模PPT课件.pptx
10-07
Subdivision 细分曲面建模 Subdivision 细分曲面建模是计算机图形学中的一种三维建模技术，它结合了 NURBS 建模和多边形建模的优点，能够创建高质量的三维模型。细分曲面建模的最大优点是其分层级管理，能够创建...
Physically Based Rendering from Theory to Implementation - part1
03-01
Main Rendering Loop Scene Methods An Integrator for Whitted-Style Ray Tracing How to Proceed through This Book The Exercises Using and Understanding the Code Pointer or Reference? Code ...
GAMES101-现代计算机图形学入门-闫令琪——Lecture 12 Geometry 3
godycy的博客
11-12 441
GAMES101-现代计算机图形学入门-闫令琪——Lecture 12 Geometry 3 Mesh Operations: Geometry Processing Mesh subdivision 增加 Mesh simplification 减少 Mesh regularization 正则化 Mesh subdivision (upsampling) 两步操作： 引入更多的三角形 让这些三角形的位置发生变化，让形状更光滑 让三角形变成四个 然后区分老顶点和新顶点 分别对老顶点和新顶点调整
opengl 显示图片以及保存图片
lcbwlx的专栏
01-18 5771
opengl 的贴图功能是很基本的，不过也难住了我这个新手，所以特意写了一个示例程序，以便以后查阅。 程序很简单，只是在在 x, y 平面画一个框，然后贴上一张图。并且可以保存opengl窗口到图片。 //本程序的目的是展示贴图和保存图片 #include #include #include #include #include using namespace cv
matlab 调用 opengl 画骨架
lcbwlx的专栏
03-26 4057
博主写程序一般用matlab， 因为最方便， 基本不用写基本函数， 只需要调用写好的库就行了。 然而， matlab并不是万能的， 有些事情matlab就不擅长， 比如画三维图形。 经研究， 可以采用折中的解决方案， 即： 使用opengl画三维图形， 同时离线渲染， 保存到内存中， 然后用matlab读取内存， 得到结果。 这里， 离线渲染是指不显示窗口， 直接渲染到数组里。
halfedge 结构
lcbwlx的专栏
11-29 1805
本学期的高级计算机图像学作业的一部分， 实现halfedge结构。 我用obj结构和halfedge互相转化来完成这样一件事。 halfedge.h: #ifndef HALFEDGE_VECTOR_H_ #define HALFEDGE_VECTOR_H_ #include using namespace std; #include typedef struct {
读取并显示 obj (2)
lcbwlx的专栏
04-28 1492
这个是读取obj的另一个版本，专门读取由灰度图转换的obj。
灰度图转换 obj
lcbwlx的专栏
04-28 1286
有些深度图，希望能直观的显示，这就需要变成obj然后看了。 本
glut 显示 obj 模型
lcbwlx的专栏
11-29 1242
图形学作业的最后一部分…… 添加了光照， 但是没有纹理。 #ifndef SHOW_BY_GLUT_H_ #define SHOW_BY_GLUT_H_ #include #define max_point 1000000 #define max_face 1000000 float p[max_point][3]; int f[max_face][3]; int f_
显示obj信息
lcbwlx的专栏
04-04 1184
其实是承接上一篇读取obj之后的显示。 说明
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值