Quadric Error Metrics三位网格精简算法实现

最新推荐文章于 2022-09-03 16:05:43 发布
最新推荐文章于 2022-09-03 16:05:43 发布
阅读量2.1k 收藏 4
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38486694/article/details/80697786
版权

用Qt实现，具体算法内容可自行百度。算法只对原始边进行了收缩，其后，新增边的处理存在bug，导致模型出现空洞，若有大佬知晓原因，望告知。

void MeshSimplifying(){
    //网格简化操作
    if(minHeap.empty())
        return();
    else{
        Vertex *one=minHeap.top()->first;
        Vertex *two=minHeap.top()->second;
        Vertex *fine=minHeap.top()->final;
        pair<int,int> st=minHeap.top()->match;

        if(one->IsSimplified||two->IsSimplified){
              minHeap.pop();
              return;
        }
        one->IsSimplified=true;
        two->IsSimplified=true;
        Face *face1;
        Face *face2;

        if(mesh->MAPedge.count(make_pair(st.first,st.second))!=0)
        face1=mesh->MAPedge[make_pair(st.first,st.second)]->IncFace;
        else return;
        if(mesh->MAPedge.count(make_pair(st.second,st.first))!=0)
        face2=mesh->MAPedge[make_pair(st.second,st.first)]->IncFace;
        else return;
        face1->live=false;
        face2->live=false;
       int number=fine->ID;
        halfEdge* it;

        for(set<int>::iterator pp=one->neighbors.begin() ;pp!=one->neighbors.end();pp++){

            if(mesh->MAPedge.count(make_pair(st.first,*pp))!=0){
            it=mesh->MAPedge[make_pair(st.first,*pp)];
            if(it->IncFace->live){
                if(it!=NULL){
                    mesh->MAPedge.insert(map<pair<int,int>,halfEdge*>::value_type(make_pair(number,*pp),it));
                    it->origin=fine;
                    fine->edge=it;
                    fine->neighbors.insert(*pp);
                    if(*pp<mesh->nverts){
                         mesh->verts[*pp].neighbors.insert(number);
                         if(mesh->verts[*pp].neighbors.count(st.first)!=0)
                             mesh->verts[*pp].neighbors.erase(st.first);
                    }else{
                         addVertices[*pp].neighbors.insert(number);
                         if(addVertices[*pp].neighbors.count(st.first)!=0)
                            addVertices[*pp].neighbors.erase(st.first);
                    }
                      VertexPairs* a=computePosition(make_pair(number,*pp),it);
                     twiceHeap.push(a);
                     //该面的法向量计算

                     Face& face=*it->IncFace;
                     for(int index=0;index<face.nverts;index++){
                         if(face.record[index]==st.first){
                             face.record[index]=number;
                             break;}
                     }

                     face.normal[0] = face.normal[1] = face.normal[2] = 0;
                     Vertex *v1;
                      Vertex *v2;
                     for (int i = 0; i < face.nverts; i++) {
                         if(face.record[i]<mesh->nverts){
                               v1 = &mesh->verts[face.record[i]];
                         }else{
                             v1=&addVertices[face.record[i]];
                         }
                         if(face.record[(i+1)%face.nverts]<mesh->nverts){
                               v2 = &mesh->verts[face.record[(i+1)%face.nverts]];
                         }else{
                             v2=&addVertices[face.record[(i+1)%face.nverts]];
                         }
                       face.normal[0] += (v1->y - v2->y) * (v1->z + v2->z);
                       face.normal[1] += (v1->z - v2->z) * (v1->x + v2->x);
                       face.normal[2] += (v1->x - v2->x) * (v1->y + v2->y);
                     }
                     // Normalize normal for face
                     float squared_normal_length = 0.0;
                     squared_normal_length += face.normal[0]*face.normal[0];
                     squared_normal_length += face.normal[1]*face.normal[1];
                     squared_normal_length += face.normal[2]*face.normal[2];
                     float normal_length = sqrt(squared_normal_length);
                     if (normal_length > 1.0E-6) {
                       face.normal[0] /= normal_length;
                       face.normal[1] /= normal_length;
                       face.normal[2] /= normal_length;
                     }
                     mesh->MAPedge.erase(make_pair(st.first,*pp));
                }
            }
            }
             if(mesh->MAPedge.count(make_pair(*pp,st.first))!=0){
                 it=mesh->MAPedge[make_pair(*pp,st.first)];
                 if(it->IncFace->live){
                     if(it!=NULL){
                         if(it->IncFace->live){
                             Face &face=*it->IncFace;
                             for(int index=0;index<face.nverts;index++){
                                 if(face.record[index]==st.first){
                                     face.record[index]=number;
                                     break;}
                             }
                         }
                          mesh->MAPedge.insert(map<pair<int,int>,halfEdge*>::value_type(make_pair(*pp,number),it));
                          //if(*pp!=st.second)
                            mesh->MAPedge.erase(make_pair(*pp,st.first));
                     }
                 }
             }
        }
          for(set<int>::iterator pp=two->neighbors.begin() ;pp!=two->neighbors.end();pp++){
           if(mesh->MAPedge.count(make_pair(st.second,*pp))!=0){
           it=mesh->MAPedge[make_pair(st.second,*pp)];
           if(it->IncFace->live){
               if(it!=NULL){
                   mesh->MAPedge.insert(map<pair<int,int>,halfEdge*>::value_type(make_pair(number,*pp),it));


                   it->origin=fine;

                   fine->neighbors.insert(*pp);
                   if(*pp<mesh->nverts){
                        mesh->verts[*pp].neighbors.insert(number);
                        if(mesh->verts[*pp].neighbors.count(st.second)!=0)
                            mesh->verts[*pp].neighbors.erase(st.second);
                   }else{
                        addVertices[*pp].neighbors.insert(number);
                        if(addVertices[*pp].neighbors.count(st.second)!=0)
                           addVertices[*pp].neighbors.erase(st.second);
                   }

                     VertexPairs* a=computePosition(make_pair(number,*pp),it);
                     twiceHeap.push(a);
                    //计算该面的法向量
                    Face &face=*it->IncFace;
                    face=*it->IncFace;

                     for(int index=0;index<face.nverts;index++){
                         if(face.record[index]==st.second){
                             face.record[index]=number;
                             break;}
                     }
                    face.normal[0] = face.normal[1] = face.normal[2] = 0;
                    Vertex *v1;
                     Vertex *v2;
                    for (int i = 0; i < face.nverts; i++) {
                        if(face.record[i]<mesh->nverts){
                              v1 = &mesh->verts[face.record[i]];
                        }else{
                            v1=&addVertices[face.record[i]];
                        }
                        if(face.record[(i+1)%face.nverts]<mesh->nverts){
                              v2 = &mesh->verts[face.record[(i+1)%face.nverts]];
                        }else{
                            v2=&addVertices[face.record[(i+1)%face.nverts]];
                        }
                      face.normal[0] += (v1->y - v2->y) * (v1->z + v2->z);
                      face.normal[1] += (v1->z - v2->z) * (v1->x + v2->x);
                      face.normal[2] += (v1->x - v2->x) * (v1->y + v2->y);
                    }
                    // Normalize normal for face
                    float squared_normal_length = 0.0;
                    squared_normal_length += face.normal[0]*face.normal[0];
                    squared_normal_length += face.normal[1]*face.normal[1];
                    squared_normal_length += face.normal[2]*face.normal[2];
                    float normal_length = sqrt(squared_normal_length);
                    if (normal_length > 1.0E-6) {
                      face.normal[0] /= normal_length;
                      face.normal[1] /= normal_length;
                      face.normal[2] /= normal_length;
                    }
                    mesh->MAPedge.erase(make_pair(st.second,*pp));
                   }
           }
           }
           if(mesh->MAPedge.count(make_pair(*pp,st.second))!=0){
             it=mesh->MAPedge[make_pair(*pp,st.second)];

                 if(it!=NULL){
                     if(it->IncFace->live){
                         Face& face=*it->IncFace;
                          for(int index=0;index<face.nverts;index++){
                              if(face.record[index]==st.second){
                                  face.record[index]=number;
                                  break;}
                          }
                     mesh->MAPedge.insert(map<pair<int,int>,halfEdge*>::value_type(make_pair(*pp,number),it));
                      mesh->MAPedge.erase(make_pair(*pp,st.second));
                 }
             }
           }
         }
          minHeap.pop();
    }
}
      原模型： ：处理后的模型


有鲛人在岸
关注
三维网格精简算法java版_几种常见算法的精简版-
weixin_39663378的博客
01-12 126
1 packagetest;23 importjava.nio.channels.SelectableChannel;45 importcom.itqf.bean.User;67 public classcTypeCode {89 /********************************************希尔排序和插入排序*******推荐严慧敏的那本数据结构，思想步骤我都...
三维网格精简算法java版_三维网格精简算法（Quadric Error Metrics）附源码
weixin_39576066的博客
12-19 418
在计算机图形应用中，为了尽可能真实呈现虚拟物体，往往需要高精度的三维模型。然而，模型的复杂性直接关系到它的计算成本，因此高精度的模型在几何运算时并不是必须的，取而代之的是一个相对简化的三维模型，那么如何自动计算生成这些三维简化模型就是网格精简算法所关注的目标。[Garland et al. 1997]提出了一种基于二次误差作为度量代价的边收缩算法，其计算速度快并且简化质量较高。该方法在选择一条合适...
三维网格精简算法（Quadric Error Metrics）附源码（二）
拉风小宇的博客
10-06 9369
最近在研究网格简化，之前转载的一篇博文利用的是QEM度量误差进行网格简化，具体的算法在三维网格精简算法（Quadric Error Metrics）附源码（一）一文中说明的已经很清楚了。 在上一篇博文中边收缩的方式是选取三个点，分别是边的端点和中点，计算其QEM，从中选择最小的，将边收缩为一点，即为上篇博文中策略一。本文将其扩展为策略二，即每条边都计算使其二次误差矩阵最小的点，如果得不到的话，再运用策略一，从端点和中点中选择二次误差最小的点。
QEM三位网格精简算法实现
06-14
三维网格精简算法QEM对原始边的缩减的实现，在Qt中实现。
Quadric-error-metric网格简化
senjay的博客
09-11 1246
1.推导   (以下向量均为列向量)   设平面pip_ipi​的法向量为nin_ini​,xix_ixi​为该平面上任一点，则其在齐次坐标下的方程为： nˉi=(ni,−ni⋅xi) \bar n_i=(n_i,-n_i \cdot x_i) nˉi​=(ni​,−ni​⋅xi​) 设空间中任意一点xxx的齐次坐标为xˉ=(x,1)\bar x=(x, 1)xˉ=(x,1) 由几何关系可知xxx到pip_ipi​的距离的平方d(x,pi)d(x,p_i)d(x,pi​)为： d(x,pi)=((x−xi
三维网格精简算法（Quadric Error Metrics）附源码
weixin_30619101的博客
03-23 1193
　　在计算机图形应用中，为了尽可能真实呈现虚拟物体，往往需要高精度的三维模型。然而，模型的复杂性直接关系到它的计算成本，因此高精度的模型在几何运算时并不是必须的，取而代之的是一个相对简化的三维模型，那么如何自动计算生成这些三维简化模型就是网格精简算法所关注的目标。 　　[Garland et al. 1997]提出了一种基于二次误差作为度量代价的边收缩算法，其计算速度快并且简化质量较高。该方法在...
三维网格精简算法（Quadric Error Metrics）附源码（一）
热门推荐
拉风小宇的博客
05-30 2万+
本文转自：http://www.cnblogs.com/shushen/p/5311828.html 我发现他的一系列文章都挺好，就是总缺点东西，所以没法执行 本文的算法来源于 Michael Garland在97年的文章 Surface simplification using quadric error metrics 算法介绍在计算机图形应用中，为了尽可能真实呈现虚拟物体，往往
三维网格精简算法java版_三维网格精简算法（Quadric Error Metrics）附源码（转载）...
weixin_39638464的博客
12-19 285
%%surface simplification using quadratic error metricsclcclear allclose allload('bunny.mat');V=surfdata.point;F=surfdata.face;nv= size(V,1); %total vertex numbernp= 0.1*nv; %remained vertex number%fun...
Surface simplification using quadric error metrics.zip
07-22
Surface simplification using quadric error metrics[C]//Proceedings of the 24th annual conference on Computer graphics and interactive techniques. ACM Press/Addison-Wesley Publishing Co., 1997: 209-...
基于二次误差的网格简化
11-12
总结来说，基于二次误差的网格简化是计算机图形学中的一种高效技术，通过四元数误差度量和优化算法，实现了在保持模型视觉质量的同时，有效地减少模型的多边形数量。这种方法在现代3D图形处理中扮演着重要的角色，是...
三维点云精简的均匀网格法&不均匀网格法，matlab实现，带例程
04-04
自己实现的均匀&不均匀网格法。使用bunny数据进行了测试。欢迎交流指正。
三维模型网格简化源码
07-10
This program implements four different mesh simplification algorithms. After loading a mesh, the user can easily remove triangles from the mesh and the results are displayed in real time. The mesh can also be rotated and moved closer to or farther away from the viewer. The goal of mesh simplification is to display a 3D polygonal mesh with fewer triangles while retaining the same shape. In the example above, the original cow model (upper left) is made up of over 5800 triangles. We can easily remove thousands of triangles from this mesh and still display a very similar cow model. While the 500 triangle cow is a cruder representation, this may not make a difference if the cow is far away from the viewer.
带属性的三角网格模型简化算法
04-25
此文档来自于南京航空航天大学CAD/CAM工程研究中心 在计算机视觉、计算机仿真、网络传输中, 经常遇到带有颜色、纹理等属性的三角网格模型的简化问题. 文 中提出一种带属性的三角网格模型简化的算法, 该算法将表征网格顶点信息的向量由简单的三维几何信息扩展到 包含颜色、纹理等附加信息的多维向量, 在Rn空间中用对称Hausdo rff 距离控制网格简化顺序和精度, 既保证了简化 网格模型在几何上与初始网格模型尽可能地相似, 又较好地保存了初始网格模型的颜色、纹理等信
opengl实现三维网格光顺（Laplacian算法）
04-12
计算机图形学课程设计实验，OpenGL+VS对obj文件实现三维网格光顺操作（用拉普拉斯算法）,使用OpenGL类库对三维模型进行绘制，增加采用鼠标交互方式对三维模型进行旋转、放缩、平移等操作；包含完整的代码和我的实验报告
QEM曲面简化算法
07-07
本程序是对QEM曲面简化算法的实现，采用qt+opengl的框架来执行。文件中详细的阐述了算法的具体过程和实验流程，并配有实验结果视频。
带属性的三角网格模型简化算法研究_三角网格简化算法_
10-01
常见的三角网格简化方法包括 Quadric Error Metrics（四元误差度量） 和 Screen Space Error Metrics（屏幕空间误差度量）。四元误差度量通过衡量每个顶点周围的表面曲率来决定哪些顶点可以被合并，以减少多边形数量...
QEM网格简化算法
闪电彬彬的博客
05-10 1万+
欢迎关注更多精彩 关注我，学习常用算法与数据结构，一题多解，降维打击。 qem 全称Quadic Error Metrics 网格简化。 它是一种基于二次度量误差的优化算法。 边塌缩算法 qem算法的基本思想是对某一边进行塌缩，将边的2点合成一个点，如下图。 那么要选择哪条边进行塌缩呢。 就是基于二次度量误差。 上图表示。 假设pi,pj点边塌缩前的端点，px为塌缩后的点坐标假设p_i,p_j点边塌缩前的端点，p_x为塌缩后的点坐标假设pi​,pj​点边塌缩前的端点，px​为塌缩后的点坐标 那么px需要
曲面细分（loop曲面细分，catmull曲面细分）（计算机图形学学习笔记）
dx1313113的博客
09-03 2935
曲面细分，目标：尽量减少三角形的数量并保留整体的形状。作用可类似于mipmap，对场景中不同距离的物体使用不同数量的三角形建模，来减少计算机的运算量。再次分割可以发现奇异点还是4个，可以发现规律，每次分割奇异点增多的个数就是非四边形的个数，所以当非不存在非四边形的时候，不论分割多少次奇异点都不会增加。Loop细分只能解决三角形网格的细分问题，对于一般的情况可以采用Catmull-Clark细分。每次都坍缩分数最小的边，然后更新被影响的边的二次误差。二次误差：新的点应该与它相关联的面的距离的平方和最小。
games101学习笔记_Geometry3(几何)
weixin_43789369的博客
11-18 845
games101学习笔记_几何
经典三角网格细分算法详解：Loop方法与交互式优化
本文主要探讨了"loop网格细分算法"在三维模型构建中的重要应用。三维模型的精细度对于设计和渲染的准确性和真实感至关重要。Loop算法作为一种经典的三角网格细分方法，它通过对原始三角形网格进行迭代操作，增加新...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值