matlab实现loop细分

最新推荐文章于 2024-08-05 16:04:12 发布
最新推荐文章于 2024-08-05 16:04:12 发布
阅读量1w 收藏 26
点赞数 7
分类专栏： 细分曲线曲面 MATLAB 细分曲线曲面 文章标签： matlab 细分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lafengxiaoyu/article/details/51581801
版权

可能利用opengl实现loop细分的工作还要再搁置一段时间，先放matlab写好的程序

作者是Jesus Mena，代码在https://cn.mathworks.com/matlabcentral/fileexchange/24942-loop-subdivision中

具体的细分规则在我的http://blog.csdn.net/lafengxiaoyu/article/details/51524302这篇文章的下半篇里有很明确的简介，这里主要讲的是实现方法

首先是以loopSubdivision命名的.m文件

function [newVertices, newFaces] =  loopSubdivision(vertices, faces)
% Mesh subdivision using the Loop scheme.
%
%  Dimensions:
%    vertices: 3xnVertices
%    faces:    3xnFaces
%  
%  Author: Jesus Mena

	global edgeVertice;
    global newIndexOfVertices;
	newFaces = [];
	newVertices = vertices;

	nVertices = size(vertices,2);
	nFaces    = size(faces,2);
	edgeVertice = zeros(nVertices, nVertices, 3);
	newIndexOfVertices = nVertices;

    % ------------------------------------------------------------------------ %
	% create a matrix of edge-vertices and the new triangulation (newFaces).
    % computational complexity = O(3*nFaces)
    % 
    % * edgeVertice(x,y,1): index of the new vertice between (x,y)
    % * edgeVertice(x,y,2): index of the first opposite vertex between (x,y)
    % * edgeVertice(x,y,3): index of the second opposite vertex between (x,y)
    %
    %  0riginal vertices: va, vb, vc, vd.
    %  New vertices: vp, vq, vr.
    %
    %      vb                   vb             
    %     / \                  /  \ 
    %    /   \                vp--vq
    %   /     \              / \  / \
    % va ----- vc   ->     va-- vr --vc 
    %   \     /              \      /
    %    \   /                \    /
    %     \ /                  \  /
    %      vd                   vd               
    
	for i=1:nFaces
		[vaIndex, vbIndex, vcIndex] = deal(faces(1,i), faces(2,i), faces(3,i));
		
		vpIndex = addEdgeVertice(vaIndex, vbIndex, vcIndex);
		vqIndex = addEdgeVertice(vbIndex, vcIndex, vaIndex);
		vrIndex = addEdgeVertice(vaIndex, vcIndex, vbIndex);
		
		fourFaces = [vaIndex,vpIndex,vrIndex; vpIndex,vbIndex,vqIndex; vrIndex,vqIndex,vcIndex; vrIndex,vpIndex,vqIndex]';
		newFaces  = [newFaces, fourFaces]; 
    end;
    	
    % ------------------------------------------------------------------------ %
	% positions of the new vertices
	for v1=1:nVertices-1
		for v2=v1:nVertices
			vNIndex = edgeVertice(v1,v2,1);
            if (vNIndex~=0)
    			vNOpposite1Index = edgeVertice(v1,v2,2);
        		vNOpposite2Index = edgeVertice(v1,v2,3);

				if (vNOpposite2Index==0) % boundary case
 					newVertices(:,vNIndex) = 1/2*(vertices(:,v1)+vertices(:,v2));
				else
 					newVertices(:,vNIndex) = 3/8*(vertices(:,v1)+vertices(:,v2)) + 1/8*(vertices(:,vNOpposite1Index)+vertices(:,vNOpposite2Index));
                end;
            end;
        end;
    end;
    
	% ------------------------------------------------------------------------ %
    % adjacent vertices (using edgeVertice)
	adjVertice{nVertices} = [];

	for v=1:nVertices
		for vTmp=1:nVertices
			if (v<vTmp && edgeVertice(v,vTmp,1)~=0) || (v>vTmp && edgeVertice(vTmp,v,1)~=0)
				adjVertice{v}(end+1) = vTmp;
            end;
        end;	
    end;
    
	% ------------------------------------------------------------------------ %
    % new positions of the original vertices	
	for v=1:nVertices
		k = length(adjVertice{v});

		adjBoundaryVertices = [];
		for i=1:k
			vi = adjVertice{v}(i);
			if (vi>v) && (edgeVertice(v,vi,3)==0) || (vi<v) && (edgeVertice(vi,v,3)==0)
				adjBoundaryVertices(end+1) = vi;
			end;
		end;

		if (length(adjBoundaryVertices)==2) % boundary case
			newVertices(:,v) = 6/8*vertices(:,v) + 1/8*sum(vertices(:,adjBoundaryVertices),2);
		else
			beta = 1/k*( 5/8 - (3/8 + 1/4*cos(2*pi/k))^2 );
			newVertices(:,v) = (1-k*beta)*vertices(:,v) + beta*sum(vertices(:,(adjVertice{v})),2); 
		end;
    end;
 	
end

% ---------------------------------------------------------------------------- %
function vNIndex = addEdgeVertice(v1Index, v2Index, v3Index)
	global edgeVertice;
	global newIndexOfVertices;

	if (v1Index>v2Index) % setting: v1 <= v2
		vTmp = v1Index;
		v1Index = v2Index;
		v2Index = vTmp;
	end;
	
	if (edgeVertice(v1Index, v2Index, 1)==0)  % new vertex
		newIndexOfVertices = newIndexOfVertices+1;
		edgeVertice(v1Index, v2Index, 1) = newIndexOfVertices;
		edgeVertice(v1Index, v2Index, 2) = v3Index;
	else
		edgeVertice(v1Index, v2Index, 3) = v3Index;
	end;

	vNIndex = edgeVertice(v1Index, v2Index, 1);

    return;
end

这里涉及到非常多很新奇的数据结构和代码思想，这段代码我得一句一句解释

	global edgeVertice;
    global newIndexOfVertices;
	newFaces = [];
	newVertices = vertices;

	nVertices = size(vertices,2);
	nFaces    = size(faces,2);
	edgeVertice = zeros(nVertices, nVertices, 3);
	newIndexOfVertices = nVertices;
首先是定义阶段。关于全局变量的概念在这里 http://www.zdh1909.com/html/matlab/17668.html

意思是新的边点和顶点索引

值得注意的是 在函数文件里，全局变量的定义语句应放在变量使用以前，为了便于了解所有的全局变量，一般把全局变量的定义语句放在文件的前部。
注意：全局变量在使用时都需要用global来定义。也就是，在所有需要用到此全局变量的函数中都要先用global来定义了，然后再使用。

因此在后面的函数里再次定义的这两个全局变量

后面两句是初始化新面和新边

然后是计算点数和面数（2表示计算的是列）

size(A,n)如果在size函数的输入参数中再添加一项n，并用1或2为n赋值，则 size将返回矩阵的行数或列数。其中r=size(A,1)该语句返回的时矩阵A的行数， c=size(A,2) 该语句返回的时矩阵A的列数。

edgeVertice = zeros(nVertices, nVertices, 3);是非常重要的一步，建立了一个n*n*3的矩阵，n为点数，之后将展现强大的功用

    % ------------------------------------------------------------------------ %
	% create a matrix of edge-vertices and the new triangulation (newFaces).
    % computational complexity = O(3*nFaces)
    % 
    % * edgeVertice(x,y,1): index of the new vertice between (x,y)
    % * edgeVertice(x,y,2): index of the first opposite vertex between (x,y)
    % * edgeVertice(x,y,3): index of the second opposite vertex between (x,y)
    %
    %  0riginal vertices: va, vb, vc, vd.
    %  New vertices: vp, vq, vr.
    %
    %      vb                   vb             
    %     / \                  /  \ 
    %    /   \                vp--vq
    %   /     \              / \  / \
    % va ----- vc   ->     va-- vr --vc 
    %   \     /              \      /
    %    \   /                \    /
    %     \ /                  \  /
    %      vd                   vd
这一部分是说明部分，表示在va.vb间插入vp，vb.vc间插入vq和va.vc间插入vr

把一个三角形分割为四个（apr,bpq,cqr,pqr）

for i=1:nFaces
		[vaIndex, vbIndex, vcIndex] = deal(faces(1,i), faces(2,i), faces(3,i));
		
		vpIndex = addEdgeVertice(vaIndex, vbIndex, vcIndex);
		vqIndex = addEdgeVertice(vbIndex, vcIndex, vaIndex);
		vrIndex = addEdgeVertice(vaIndex, vcIndex, vbIndex);
		
		fourFaces = [vaIndex,vpIndex,vrIndex; vpIndex,vbIndex,vqIndex; vrIndex,vqIndex,vcIndex; vrIndex,vpIndex,vqIndex]';
		newFaces  = [newFaces, fourFaces]; 
    end;
这一段是为了得到newFaces矩阵，其中用到了函数addEdgeVertice

[Y1, Y2, Y3, ...] = deal(X1, X2, X3, ...) Matlab中文论坛 
  相当于 Y1 = X1; Y2 = X2; Y3 = X3; ...

就是把每个三角形统一化为abc，进行操作

p点是插入在a和b之间的，其对面的点是c

                vpIndex = addEdgeVertice(vaIndex, vbIndex, vcIndex);
		vqIndex = addEdgeVertice(vbIndex, vcIndex, vaIndex);
		vrIndex = addEdgeVertice(vaIndex, vcIndex, vbIndex);
这三条语句就是为了得到三个插入点的索引值 

function vNIndex = addEdgeVertice(v1Index, v2Index, v3Index)
	global edgeVertice;
	global newIndexOfVertices;

	if (v1Index>v2Index) % setting: v1 <= v2
		vTmp = v1Index;
		v1Index = v2Index;
		v2Index = vTmp;
	end;
	
	if (edgeVertice(v1Index, v2Index, 1)==0)  % new vertex
		newIndexOfVertices = newIndexOfVertices+1;
		edgeVertice(v1Index, v2Index, 1) = newIndexOfVertices;
		edgeVertice(v1Index, v2Index, 2) = v3Index;
	else
		edgeVertice(v1Index, v2Index, 3) = v3Index;
	end;

	vNIndex = edgeVertice(v1Index, v2Index, 1);

    return;
end
以p为例，v1是a，v2是b，v3是c

之后重新定义了两个全局变量

然后调换前两个边的顺序，使其成为顺序关系（这将为以后的运算带来方便，得到的edgeVertice矩阵将会是三角矩阵）

if (edgeVertice(v1Index, v2Index, 1)==0)  % new vertex
		newIndexOfVertices = newIndexOfVertices+1;

这个时候就要说到edgeVertice的妙用了，其相当于有三层矩阵，每一层都是n*n，比如拿正四面体为例，一共四个点，就是4*4

就是一个4*4的表格，x行y列表示边xy

第一层表示边上插入点的索引值，例如第一次迭代为三角形123，在12上插入边，由于12这条边还没有用过，（if语句就是用来判断这条边是不是已经用过了，如果已经用过了，那么第一层的值不应该是0，第二层的值被赋予是ab边对着的点c，接下来就是赋予第三层的值，也就是ab边对着的点d【ab边只能最多被两个三角形共用，如果被一个三角形用，那其就是边界，如果被两个三角形共用，就是内部边】）

newIndexOfVertices = newIndexOfVertices+1;
那么插入的就应该是5

第二层的值被赋予是ab边对着的点c，然后返回新加入点的索引值，再对面中其他的边做

然后再遍历其他的面，如果这条边已经被其他三角形用过，第一层就不是0了，比如三角形123之后是

faces =


     1     1     1     4
     2     3     4     3
     3     4     2     2

134，其中13已经做过了，插入的是5，对着的是2，这是插入点的索引就直接返回5，但是第三层的数加入为4

一遍做过之后

edgeVertice(:,:,1) =

     0     5     7     9
     0     0     6    10
     0     0     0     8
     0     0     0     0

edgeVertice(:,:,2) =

     0     3     2     3
     0     0     1     1
     0     0     0     1
     0     0     0     0

edgeVertice(:,:,3) =

     0     4     4     2
     0     0     4     3
     0     0     0     2
     0     0     0     0


第一个表示12间插入5，23点间插入6等

第二个表示12对着是3，23对着1等

第二个表示12还对着是4，23还对着4等

如果一条边只有对着一个点，那么对应的第三层应该是0

点的索引值搞定！下一步就是确定点的坐标

中间的一大堆代码就是干这个的

首先确定新点（就是边点坐标）

 % ------------------------------------------------------------------------ %
	% positions of the new vertices
	for v1=1:nVertices-1
		for v2=v1:nVertices
			vNIndex = edgeVertice(v1,v2,1);
            if (vNIndex~=0)
    			vNOpposite1Index = edgeVertice(v1,v2,2);
        		vNOpposite2Index = edgeVertice(v1,v2,3);


				if (vNOpposite2Index==0) % boundary case
 					newVertices(:,vNIndex) = 1/2*(vertices(:,v1)+vertices(:,v2));
				else
 					newVertices(:,vNIndex) = 3/8*(vertices(:,v1)+vertices(:,v2)) + 1/8*(vertices(:,vNOpposite1Index)+vertices(:,vNOpposite2Index));
                end;
            end;
        end;
    end;

就是这一段

遍历（n-1）*n的表格（因为第n行一定是0）

vNIndex是插入点索引

如果不为0（就是插入了点）

vNOpposite1Index = edgeVertice(v1,v2,2);
vNOpposite2Index = edgeVertice(v1,v2,3);

分别为边对着的两个点

                                if (vNOpposite2Index==0) % boundary case
 					newVertices(:,vNIndex) = 1/2*(vertices(:,v1)+vertices(:,v2));
				else
 					newVertices(:,vNIndex) = 3/8*(vertices(:,v1)+vertices(:,v2)) + 1/8*(vertices(:,vNOpposite1Index)+vertices(:,vNOpposite2Index));
如果是边界点，第一个计算方式；如果是内部点，第二种计算方式

之后就是计算旧点的坐标了

% ------------------------------------------------------------------------ %
    % adjacent vertices (using edgeVertice)
	adjVertice{nVertices} = [];

	for v=1:nVertices
		for vTmp=1:nVertices
			if (v<vTmp && edgeVertice(v,vTmp,1)~=0) || (v>vTmp && edgeVertice(vTmp,v,1)~=0)
				adjVertice{v}(end+1) = vTmp;
            end;
        end;	
    end;
    
	% ------------------------------------------------------------------------ %
    % new positions of the original vertices	
	for v=1:nVertices
		k = length(adjVertice{v});

		adjBoundaryVertices = [];
		for i=1:k
			vi = adjVertice{v}(i);
			if (vi>v) && (edgeVertice(v,vi,3)==0) || (vi<v) && (edgeVertice(vi,v,3)==0)
				adjBoundaryVertices(end+1) = vi;
			end;
		end;

		if (length(adjBoundaryVertices)==2) % boundary case
			newVertices(:,v) = 6/8*vertices(:,v) + 1/8*sum(vertices(:,adjBoundaryVertices),2);
		else
			beta = 1/k*( 5/8 - (3/8 + 1/4*cos(2*pi/k))^2 );
			newVertices(:,v) = (1-k*beta)*vertices(:,v) + beta*sum(vertices(:,(adjVertice{v})),2); 
		end;
    end;
 	
end
就是这一段

adjVertice{nVertices} = [];是建立了一个cell数据，为的是记录其中每个点的邻接点
比如我们这里nVertices为4，就是[] [] [] []4个数组

分别存储点1 2 3 4的邻近点

if (v<vTmp && edgeVertice(v,vTmp,1)~=0) || (v>vTmp && edgeVertice(vTmp,v,1)~=0)
判断是邻接点，因为是上三角顺序，所以有两种可能

判断是邻接点，储存入相应数组的结尾end就是数组结尾的意思，见http://blog.sina.com.cn/s/blog_6472561e0100gqqk.html

执行完这段语句之后的结果是 

>>adjVertice{1}
ans =
     2     3     4

>> adjVertice{2}
ans =
     1     3     4

>> adjVertice{3}
ans =
     1     2     4

>> adjVertice{4}
ans =
     1     2     3

第二段就是分情况计算坐标了

for v=1:nVertices
		k = length(adjVertice{v});

		adjBoundaryVertices = [];
		for i=1:k
			vi = adjVertice{v}(i);
			if (vi>v) && (edgeVertice(v,vi,3)==0) || (vi<v) && (edgeVertice(vi,v,3)==0)
				adjBoundaryVertices(end+1) = vi;
			end;
		end;

		if (length(adjBoundaryVertices)==2) % boundary case
			newVertices(:,v) = 6/8*vertices(:,v) + 1/8*sum(vertices(:,adjBoundaryVertices),2);
		else
			beta = 1/k*( 5/8 - (3/8 + 1/4*cos(2*pi/k))^2 );
			newVertices(:,v) = (1-k*beta)*vertices(:,v) + beta*sum(vertices(:,(adjVertice{v})),2); 
		end;
    end;
 	
end
这里还要判断点是不是边界点，如果是边界点，只有两个相邻点，设边界顶点v0的两个相邻点为v1、v2，则该顶点更新后位置为v = 3/4*v0 + 1/8*(v1 + v2)。 

adjBoundaryVertices = [];
		for i=1:k
			vi = adjVertice{v}(i);
			if (vi>v) && (edgeVertice(v,vi,3)==0) || (vi<v) && (edgeVertice(vi,v,3)==0)
				adjBoundaryVertices(end+1) = vi;
			end;
		end;
得到相邻边界点数组

然后分情况计算坐标！解释完毕


之后就是用来测试的test.m文件如下 
vertices = [10 10 10; -100 10 -10; -100 -10 10; 10 -10 -10]';
faces = [1 2 3; 1 3 4; 1 4 2; 4 3 2]';

figure(2);
subplot(1,4,1);
trimesh(faces', vertices(1,:), vertices(2,:), vertices(3,:));
axis tight;
axis square; 
axis off;
view(3);
for i=2:4
 subplot(1,4,i);
 [vertices, faces] = loopSubdivision(vertices, faces); 
trimesh(faces', vertices(1,:), vertices(2,:), vertices(3,:));
axis tight;
axis square; 
axis off;
view(3)
end

只需要说明trimesh(Tri,X,Y,Z) ，第一个tri为三角形索引，然后分别是三点x，y，z坐标

分别进行1到4次细分，效果如下


受益匪浅！看起来matlab功能还是非常强大的，也看得出来想法是特别好的，赞赞的，对用opengl编程一定是有帮助的

拉风小宇
关注
专栏目录
第四章 matlab的循环结构
axingxiansen的博客
05-20 1606
在 for 循环中的控制变量将会更新到下一个值，循环将会继续进行。在 for 循环中，代码的重复次数是确定的，在循环开始之前，我们就知道代码重复的次数了。它的 1 月 1 号对应的 day of year 是 1，12 月 31 号必定对应的是。它的 1 月 1 号对应的 day of year 是 1，12 月 31 号必定对应的是。这种循环将会执行 5 次，ii 值按先后顺序依次为 1，2，3，4，5。检测下面的 while 循环，确定每一次 while 循环结束的时侯 ires 的值。
曲面细分（loop曲面细分，catmull曲面细分）（计算机图形学学习笔记）
dx1313113的博客
09-03 2913
曲面细分，目标：尽量减少三角形的数量并保留整体的形状。作用可类似于mipmap，对场景中不同距离的物体使用不同数量的三角形建模，来减少计算机的运算量。再次分割可以发现奇异点还是4个，可以发现规律，每次分割奇异点增多的个数就是非四边形的个数，所以当非不存在非四边形的时候，不论分割多少次奇异点都不会增加。Loop细分只能解决三角形网格的细分问题，对于一般的情况可以采用Catmull-Clark细分。每次都坍缩分数最小的边，然后更新被影响的边的二次误差。二次误差：新的点应该与它相关联的面的距离的平方和最小。
网格细分 —— Loop细分
HachiLin的博客
05-19 6984
网格细分 —— Loop细分 1. 定义 网格细分是通过按一定规则给网格增加顶点和面片的数量，让网格模型变得更加光滑。Loop细分方法是最早一种基于三角网格的细分方法。一次细分的过程分为两步骤，第一步是增加顶点；第二步是对顶点位置进行调整，使得网格更加光滑。 2. 增加顶点 Loop细分在每条边上都增加一个顶点，并且同一个三角形内的顶点用新增顶点连接起来，以构成新的三角形。 3. 顶点位置的调整 ...
Matlab parfor-loop并行运算
热门推荐
西檬饭
05-13 2万+
Matlab中的并行运算常用的有 parfor-loop代替for-loop加速计算，这里parfor就是parallel的意思。 client把任务分配给多个workers，在一个循环中同时运行，等所有workers运行完返回结果，然后对结果进行整合。 一个迭代就是指执行一次循环体。每一个worker独立地按照一定的次序迭代。 官方原图： parfor 把for循环中的迭代分...
MATLAB: 循环loop、脚本-文件和绘图、函数-文件（M-文件）、信号生成和卷积、傅里叶变换、滤波器filter的实现
最新发布
2201_75569491的博客
08-05 299
MATLAB软件具备多种功能，在数据分析方面，它可以对数据进行探查、建模和可视化；在创建图形方面，MATLAB可以通过图形可视化并探查数据；在编程方面，MATLAB可以进行编程创建脚本、函数和类。同时，MATLAB可以与多种编程语言使用，例如可以将 MATLAB 与 Python、C/C++、Fortran、Java 及其他语言结合使用；在App 构建方面，MATLAB可以创建桌面 App 和 Web App；在硬件方面，MATLAB可以连接到硬件；
loop细分曲面算法
10-21
loop细分曲面算法
ameshref：2D自适应网格细化的高效Matlab实现
02-03
ameshref：2D自适应网格细化的高效Matlab实现
loopSubdivision.zip_LOOp细分_loop细分 matlab_matlab网格细分_thise8e_网格细分
07-15
本项目是Loop细分算法在MATLAB环境下的实现，方便用户对网格进行细化操作。 MATLAB是一种交互式计算环境，适用于数值分析、矩阵运算、图像处理等多种科学计算任务。在这里，MATLAB被用来编写代码来执行Loop细分算法...
LoopSubdivisionLimited.zip_LOOp细分_loop细分 matlab_subdivision matl
07-15
在MATLAB实现Loop子分维的过程中，首先需要对输入的网格数据进行处理。这通常包括读取网格的顶点、边和面信息，这些信息可能存储在结构体数组或自定义的数据结构中。然后，根据Loop算法的规则计算新顶点的位置，这...
快速循环网格细分：使用循环细分细分曲面网格。 边界和形状保持-matlab开发
06-01
该算法基于 B 样条曲线连续性，可实现良好的表面形状保持平滑。 该算法试图使表面的边界基本上不失真。 'mfMeshPoints' 是一个 Nx3 矩阵，其中 ['x' 'y' 'z'] 的每一行定义了三维空间中的一个点。 'mnTriangulation...
【matlab教程】20、简单网格细分
qq_38939822的博客
11-12 3832
问题 matlab处理网格时，有时需要将网格细分 思路参考：https://hanspond.github.io/2018/11/27/%E7%AE%80%E5%8D%95%E7%BD%91%E6%A0%BC%E7%BB%86%E5%88%86%201to4%20Mesh%20Subdivision/index.html 将每一个面的每一条边取中点并连接，形成新的三角形，原来一个面细分成四个面 原博主的代码只适合封闭曲面的细分，如果曲面是不封闭的，则拓扑结构会乱，如： 代码： %% created by
MATLAB对茶壶采集的的点云数据网格生成，并细化
03-24
MATLAB对茶壶采集的的点云数据网格生成，并细化
Subdivision:网格细分
06-16
细分 网格细分 一、问题说明： 在3D计算机图形领域，我们通常想让粗网格更平滑。 作为将每个多边形面细分为更接近光滑表面的更小面的递归过程的限制，可以从粗网格计算光滑表面。 我们称之为流程细分。 在这个项目中，我们专注于三角形网格，从基本的VRML 3D模型文件（.wrl）中读取输入数据，然后代码将数据构造为半边结构，并以此结构进行循环细分或修改蝴蝶细分. 最后，代码可以将细分的结果数据存储到一个.wrl文件中。 2.我的实现： 代码功能如下： 1)能够读写基本的VRML 3D模型文件(.wrl) 2)实现了半边数据结构，用于表示、遍历和操作3D三角形网格。 3）实现了循环细分。 4)实施了修改后的蝴蝶细分。 5）使用openGl来显示网格，它不仅可以显示顶点和边，还可以显示曲面。
for_loop_progress:用于“for”循环的简单快速的命令行等待栏-matlab开发
05-29
在命令行上以可调间隔显示“for”循环的进度百分比。 如果“for”循环的步骤不是 1，也可以工作。 例子 >> i=1; 步骤=2； len=20; 宁克=4； >> 对于 i:step:len >> for_loop_progress(i,len,step,Nincr); >> 结束 命令行输出： 25％ 50％ 75％ 100%
山东大学计算机图形学实验三读取.off模型进行网格细分与简化
08-08
通过读取.off模型获取三维图像数据，利用半边结构，进行网格细分。
基于OpenGL的Loop网格细分
05-16
基于OpenGL的Loop网格细分，有算法实现源码和试例obj文件
matlab-选择-循环-函数
weixin_30388677的博客
05-14 392
1选择 3循环 break 3函数 转载于:https://www.cnblogs.com/liu-wang/p/9037540.html
网格细分算法（Catmull-Clark subdivision & Loop subdivision）附源码
拉风小宇的博客
05-28 2万+
转载自：http://www.cnblogs.com/shushen/p/5251070.html 下图描述了细分的基本思想，每次细分都是在每条边上插入一个新的顶点，可以看到随着细分次数的增加，折线逐渐变成一条光滑的曲线。曲面细分需要有几何规则和拓扑规则，几何规则用于计算新顶点的位置，拓扑规则用于确定新顶点的连接关系。下面介绍两种网格细分方法：Catmull-Clark细分和Loop细分
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

拉风小宇

请我喝个咖啡呗

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

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

打赏作者

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

抵扣说明：

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

余额充值