从源头看Dust3d | （九）meshgenerator：网格生成

最新推荐文章于 2024-05-07 17:39:21 发布
最新推荐文章于 2024-05-07 17:39:21 发布
阅读量4.3k 收藏
点赞数
分类专栏： Dust3d学习 文章标签： 1024程序员节 3d c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46273149/article/details/121650188
版权

2021SC@SDUSC

目录

一、MeshGenerator类

（一）QObject类

（二）MeshGenerator类

二、重要函数

1.generate函数

2.reverseUuid函数

3.collectIncombinableMesh函数

一、MeshGenerator类

继承QObject类

（一）QObject类

   QObject类是所有QT对象的基类，还是“Qt中的对象模型”的核心类，其中最重要的功能就是“信号-槽”机制，“信号-槽”机制实现Qt对象之间的无缝交互

   以往点击按钮实现功能是通过回调函数与处理函数进行的，处理函数可以在适合的时候调用回调函数，但回调函数并不是类型安全的；并且回调函数与处理函数是强耦合的，处理函数必须要知道调用哪个回调函数

   信号与槽能代替上面的机制：在发生某一个特定事件的时候会产生一个信号，槽函数会接收特定的信号并且发出响应。因此，信号-槽机制是类型安全的，因为信号的签名与接收此信号的槽的签名一定是匹配的，不然无法实现接收功能

（二）MeshGenerator类

    MeshGenerator类的信号函数：void finished();

    槽函数：void process();

class MeshGenerator : public QObject
{
    Q_OBJECT
public:
    MeshGenerator(Snapshot *snapshot);
    ~MeshGenerator();
    bool isSuccessful();
    Model *takeResultMesh();
    Model *takePartPreviewMesh(const QUuid &partId);
    QImage *takePartPreviewImage(const QUuid &partId);
    const std::set<QUuid> &generatedPreviewPartIds();
    const std::set<QUuid> &generatedPreviewImagePartIds();
    Object *takeObject();
    std::map<QUuid, StrokeMeshBuilder::CutFaceTransform> *takeCutFaceTransforms();
    std::map<QUuid, std::map<QString, QVector2D>> *takeNodesCutFaces();
    void generate();
    void setGeneratedCacheContext(GeneratedCacheContext *cacheContext);
    void setSmoothShadingThresholdAngleDegrees(float degrees);
    void setInterpolationEnabled(bool interpolationEnabled);
    void setDefaultPartColor(const QColor &color);
    void setId(quint64 id);
    void setWeldEnabled(bool enabled);
    quint64 id();
signals:
    void finished();
public slots:
    void process();
    
private:
    QColor m_defaultPartColor = Qt::white;
    Snapshot *m_snapshot = nullptr;
    GeneratedCacheContext *m_cacheContext = nullptr;
    //脏标记位
    std::set<QString> m_dirtyComponentIds;
    std::set<QString> m_dirtyPartIds;
    float m_mainProfileMiddleX = 0;
    float m_sideProfileMiddleX = 0;
    float m_mainProfileMiddleY = 0;
    Object *m_object = nullptr;
    std::vector<std::pair<QVector3D, std::pair<QUuid, QUuid>>> m_nodeVertices;//顶点的位置及索引
    std::map<QString, std::set<QString>> m_partNodeIds;//存储顶点信息
    std::map<QString, std::set<QString>> m_partEdgeIds;//存储边信息
    std::set<QUuid> m_generatedPreviewPartIds;
    std::set<QUuid> m_generatedPreviewImagePartIds;
    Model *m_resultMesh = nullptr;
    std::map<QUuid, Model *> m_partPreviewMeshes;
    std::map<QUuid, QImage *> m_partPreviewImages;
    bool m_isSuccessful = false;
    bool m_cacheEnabled = false;
    float m_smoothShadingThresholdAngleDegrees = 60;//渲染角度阈值
    std::map<QUuid, StrokeMeshBuilder::CutFaceTransform> *m_cutFaceTransforms = nullptr;
    std::map<QUuid, std::map<QString, QVector2D>> *m_nodesCutFaces = nullptr;
    quint64 m_id = 0;
    std::vector<QVector3D> m_clothCollisionVertices;
    std::vector<std::vector<size_t>> m_clothCollisionTriangles;
    //焊接与插值
    bool m_weldEnabled = true;
    bool m_interpolationEnabled = true;
    
    //
    void collectParts();
    void collectIncombinableComponentMeshes(const QString &componentIdString);
    void collectIncombinableMesh(const MeshCombiner::Mesh *mesh, const GeneratedComponent &componentCache);
    //与脏标记相关：
    bool checkIsComponentDirty(const QString &componentIdString);
    bool checkIsPartDirty(const QString &partIdString);
    bool checkIsPartDependencyDirty(const QString &partIdString);
    void checkDirtyFlags();
    bool fillPartWithMesh(GeneratedPart &partCache, 
        const QUuid &fillMeshFileId,
        float deformThickness,
        float deformWidth,
        float cutRotation,
        const StrokeMeshBuilder *strokeMeshBuilder);
    MeshCombiner::Mesh *combinePartMesh(const QString &partIdString, bool *hasError, bool *retryable, bool addIntermediateNodes=true);
    MeshCombiner::Mesh *combineComponentMesh(const QString &componentIdString, CombineMode *combineMode);
    void makeXmirror(const std::vector<QVector3D> &sourceVertices, const std::vector<std::vector<size_t>> &sourceFaces,
        std::vector<QVector3D> *destVertices, std::vector<std::vector<size_t>> *destFaces);
    void collectSharedQuadEdges(const std::vector<QVector3D> &vertices, const std::vector<std::vector<size_t>> &faces,
        std::set<std::pair<PositionKey, PositionKey>> *sharedQuadEdges);
    MeshCombiner::Mesh *combineTwoMeshes(const MeshCombiner::Mesh &first, const MeshCombiner::Mesh &second,
        MeshCombiner::Method method,
        bool recombine=true);
    void generateSmoothTriangleVertexNormals(const std::vector<QVector3D> &vertices, const std::vector<std::vector<size_t>> &triangles,
        const std::vector<QVector3D> &triangleNormals,
        std::vector<std::vector<QVector3D>> *triangleVertexNormals);
    const std::map<QString, QString> *findComponent(const QString &componentIdString);
    CombineMode componentCombineMode(const std::map<QString, QString> *component);
    MeshCombiner::Mesh *combineComponentChildGroupMesh(const std::vector<QString> &componentIdStrings,
        GeneratedComponent &componentCache);
    MeshCombiner::Mesh *combineMultipleMeshes(const std::vector<std::tuple<MeshCombiner::Mesh *, CombineMode, QString>> &multipleMeshes, bool recombine=true);
    QString componentColorName(const std::map<QString, QString> *component);
    void collectUncombinedComponent(const QString &componentIdString);
    void cutFaceStringToCutTemplate(const QString &cutFaceString, std::vector<QVector2D> &cutTemplate);
    void postprocessObject(Object *object);//后处理
    void collectErroredParts();
    void preprocessMirror();//镜面处理
    QString reverseUuid(const QString &uuidString);
};

二、重要函数

1.generate函数

     首先进行镜像处理，之后不断循环迭代cacheContext，得到它们的镜像部分，直到形成完整对称的几何体，完成镜像处理，之后再对合并网格进行焊接并再检查没有进行合并的网格，对没有进行合并的网格进行处理。最后，使用后处理完善模型m_object，生成新的模型

void MeshGenerator::generate()
{
    if (nullptr == m_snapshot)
        return;

    m_isSuccessful = true;
    
    QElapsedTimer countTimeConsumed;//添加计时器
    countTimeConsumed.start();
    
    //获得canvas的位置
    m_mainProfileMiddleX = valueOfKeyInMapOrEmpty(m_snapshot->canvas, "originX").toFloat();
    m_mainProfileMiddleY = valueOfKeyInMapOrEmpty(m_snapshot->canvas, "originY").toFloat();
    m_sideProfileMiddleX = valueOfKeyInMapOrEmpty(m_snapshot->canvas, "originZ").toFloat();
    
    preprocessMirror();//镜像处理
    
    m_object = new Object;
    m_object->meshId = m_id;
    //m_cutFaceTransforms = new std::map<QUuid, nodemesh::Builder::CutFaceTransform>;
    //m_nodesCutFaces = new std::map<QUuid, std::map<QString, QVector2D>>;
    
    bool needDeleteCacheContext = false;//用于表示CacheContext是否存在
    if (nullptr == m_cacheContext) {
        m_cacheContext = new GeneratedCacheContext;
        needDeleteCacheContext = true;
    } else {
        
        m_cacheEnabled = true;
        //parts
        for (auto it = m_cacheContext->parts.begin(); it != m_cacheContext->parts.end(); ) {
            if (m_snapshot->parts.find(it->first) == m_snapshot->parts.end()) {
                //在partMirrorIdMap中找到mirrorFrom并加进cacheContext
                auto mirrorFrom = m_cacheContext->partMirrorIdMap.find(it->first);
                if (mirrorFrom != m_cacheContext->partMirrorIdMap.end()) {
                    if (m_snapshot->parts.find(mirrorFrom->second) != m_snapshot->parts.end()) {
                        it++;
                        continue;
                    }
                    m_cacheContext->partMirrorIdMap.erase(mirrorFrom);
                }
                it->second.releaseMeshes();
                it = m_cacheContext->parts.erase(it);
                continue;
            }
            it++;
        }
        //components
        for (auto it = m_cacheContext->components.begin(); it != m_cacheContext->components.end(); ) {
            if (m_snapshot->components.find(it->first) == m_snapshot->components.end()) {
                for (auto combinationIt = m_cacheContext->cachedCombination.begin(); combinationIt != m_cacheContext->cachedCombination.end(); ) {
                    if (-1 != combinationIt->first.indexOf(it->first)) {
                        //qDebug() << "Removed cached combination:" << combinationIt->first;
                        delete combinationIt->second;
                        combinationIt = m_cacheContext->cachedCombination.erase(combinationIt);
                        continue;
                    }
                    combinationIt++;
                }
                it->second.releaseMeshes();
                it = m_cacheContext->components.erase(it);
                continue;
            }
            it++;
        }
    }
    
    collectParts();//存储点和边的信息
    checkDirtyFlags();
    
    //用dirty位进行优化加速
    for (const auto &dirtyComponentId: m_dirtyComponentIds) {
        for (auto combinationIt = m_cacheContext->cachedCombination.begin(); combinationIt != m_cacheContext->cachedCombination.end(); ) {
            if (-1 != combinationIt->first.indexOf(dirtyComponentId)) {
                //qDebug() << "Removed dirty cached combination:" << combinationIt->first;
                delete combinationIt->second;
                combinationIt = m_cacheContext->cachedCombination.erase(combinationIt);
                continue;
            }
            combinationIt++;
        }
    }
    
    m_dirtyComponentIds.insert(QUuid().toString());
    //进行组合
    
    CombineMode combineMode;
    auto combinedMesh = combineComponentMesh(QUuid().toString(), &combineMode);
    
    const auto &componentCache = m_cacheContext->components[QUuid().toString()];
    
    m_object->nodes = componentCache.objectNodes;
    m_object->edges = componentCache.objectEdges;
    m_nodeVertices = componentCache.objectNodeVertices;
        
    std::vector<QVector3D> combinedVertices;
    std::vector<std::vector<size_t>> combinedFaces;
    if (nullptr != combinedMesh) {
        combinedMesh->fetch(combinedVertices, combinedFaces);
        //焊接
        if (m_weldEnabled) {
            size_t totalAffectedNum = 0;
            size_t affectedNum = 0;
            do {
                std::vector<QVector3D> weldedVertices;
                std::vector<std::vector<size_t>> weldedFaces;
                affectedNum = weldSeam(combinedVertices, combinedFaces,
                    0.025, componentCache.noneSeamVertices,
                    weldedVertices, weldedFaces);
                //将两个面焊接起来
                combinedVertices = weldedVertices;
                combinedFaces = weldedFaces;
                totalAffectedNum += affectedNum;
            } while (affectedNum > 0);
        }
        recoverQuads(combinedVertices, combinedFaces, componentCache.sharedQuadEdges, m_object->triangleAndQuads);
        //处理经过焊接的部分
        m_object->vertices = combinedVertices;
        m_object->triangles = combinedFaces;
    }
    
    // 递归检查未组合的组件
    collectUncombinedComponent(QUuid().toString());
    collectIncombinableComponentMeshes(QUuid().toString());
    
    collectErroredParts();
    postprocessObject(m_object);//后处理
    
    m_resultMesh = new Model(*m_object);//生成新模型
    
    delete combinedMesh;

    if (needDeleteCacheContext) {
        delete m_cacheContext;
        m_cacheContext = nullptr;
    }
    
    qDebug() << "The mesh generation took" << countTimeConsumed.elapsed() << "milliseconds";
}

2.reverseUuid函数

    实现Uuid（唯一码）的倒转，用于实现镜面效果

QString MeshGenerator::reverseUuid(const QString &uuidString)
{
    QUuid uuid(uuidString);
    QString newIdString = uuid.toString();
    QString newRawId = newIdString.mid(1, 8) +
        newIdString.mid(10, 4) +
        newIdString.mid(15, 4) +
        newIdString.mid(20, 4) +
        newIdString.mid(25, 12);
    std::reverse(newRawId.begin(), newRawId.end());
    return "{" + newRawId.mid(0, 8) + "-" +
        newRawId.mid(8, 4) + "-" +
        newRawId.mid(12, 4) + "-" +
        newRawId.mid(16, 4) + "-" +
        newRawId.mid(20, 12) + "}";
}

3.collectIncombinableMesh函数

    调用recoverQuads将没有合并的四边形与三角形面都放入到uncombinedTriangleAndQuads中

    用updateVertexIndices经过两次循环得到所有没有合并的面数

    最后将没有合并的点、面与m_object进行合并

void MeshGenerator::collectIncombinableMesh(const MeshCombiner::Mesh *mesh, const GeneratedComponent &componentCache)
{
    if (nullptr == mesh)
        return;
    //获取未合并点与面的信息

    std::vector<QVector3D> uncombinedVertices;
    std::vector<std::vector<size_t>> uncombinedFaces;
    mesh->fetch(uncombinedVertices, uncombinedFaces);
    std::vector<std::vector<size_t>> uncombinedTriangleAndQuads;
    
    //将没有合并的四边形与三角形面合并
    recoverQuads(uncombinedVertices, uncombinedFaces, componentCache.sharedQuadEdges, uncombinedTriangleAndQuads);
    
    //迭代得出所有数量
    auto vertexStartIndex = m_object->vertices.size();
    auto updateVertexIndices = [=](std::vector<std::vector<size_t>> &faces) {
        for (auto &it: faces) {
            for (auto &subIt: it)
                subIt += vertexStartIndex;
        }
    };

    //使用updateVertexIndices得出未合并的所有面数
    updateVertexIndices(uncombinedFaces);
    updateVertexIndices(uncombinedTriangleAndQuads);
    
    //将未合并的点、面与m_object合并
    m_object->vertices.insert(m_object->vertices.end(), uncombinedVertices.begin(), uncombinedVertices.end());
    m_object->triangles.insert(m_object->triangles.end(), uncombinedFaces.begin(), uncombinedFaces.end());
    m_object->triangleAndQuads.insert(m_object->triangleAndQuads.end(), uncombinedTriangleAndQuads.begin(), uncombinedTriangleAndQuads.end());
}

苏打不是糖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MIKE 21 教程 1.1 网格搭建界面介绍之点线面的创建 （Mesh Generator 工具）
Hello Word
11-29 1万+
DHI MIKE 21 手把手入门系列 网格搭建方法 （Mesh Generator 工具） 1 打开网格创建界面 为河道创建网格文件，是MIKE21建模的第一步。
Flat Mesh Generator 1.1 facated风格模仿多边形网格效果插件
06-30
是一种转换成facated风格模仿多边形网格效果的工具。 转换非常简单明了：网格是以每个三角形的所有3个顶点变得唯一的方式再生的（如果顶点被更多的一个三角形使用，它就会分裂。最终网格顶点计数=三角形计数* 3）。对于每个顶点，然后从材质或颜色中计算顶点颜色。重新计算每个三角形的法线。最终网格使用着色器的顶点颜色支持，揭示“多边形”效应。 这是生成刻面网格的唯一可能方法，而资产商店上可用的所有工具都是这样做的。 以下是使平面网格生成器优于所有这些功能的特点： 在编辑器和运行时工作的超快速转换器。 地形转换是使用先进的地形到网格算法，总的控制顶点数量和块。 网格顶点计数没有限制（如果顶点计数> 21，大多数工具都失败） 保留原始网格顶点颜色。 选择烘焙质地和颜色的可能性。 不需要制备网格或创建预置，工具会为你做的一切只是在一个点击。 支持像SpeedTree复杂的网格。 支持物质烘焙成顶点颜色。 将最终网格合并为一个网格。 合并多个子料实现一次抽签优化。 顶点颜色着色范围广：移动（亮灯和一个定向光），遗产和标准着色模型。
MIKE 21 教程 1.3 网格搭建界面介绍之网格生成 （Mesh Generator 工具）
Hello Word
11-30 2045
MIKE 21 教程 手把手教学系列 1.3 网格搭建界面介绍之网格生成 （Mesh Generator 工具）。 上一篇文章讲解了点线面要素的一些高阶处理与breakline的插入，本节讲解如何生成网格文件。
从源头看Dust3d | （八）meshgenerator：网格生成预备知识
weixin_46273149的博客
12-01 4504
meshgenerator类源码分析预备知识
MIKE 21 教程 1.2 网格搭建界面介绍之点线面要素的高阶处理 （Mesh Generator 工具）
Hello Word
11-30 1913
MIKE 21 教程 手把手教学系列 1.1 网格搭建界面介绍之点线面要素的高阶处理 （Mesh Generator 工具） ​ 上一篇文章讲解了如何创建基本的点、线、面要素 MIKE 21 教程 1.1 网格搭建界面介绍之点线面的创建 本节来讲一下对点线面要素的高阶处理，主要包括要素修改与打断线（break line）的讲解 ​
从源头看Dust3d | （十）meshsplitter：网格切割
weixin_46273149的博客
12-09 926
Dust3D源码分析：meshsplitter
Dust3d:一个开源免费的3D建模软件
07-14
官网地址：https://docs.dust3d.org/en/latest/install.html 此版本为dust3d-1.0.0-rc.6
DUSt3R: Geometric 3D Vision Made Easy 的Pytorch实现
03-04
DUSt3R: Geometric 3D Vision Made Easy 的Pytorch实现 交互性演示： 在此演示中，您应该能够在计算机上运行 DUSt3R 来重建场景。 首先选择描绘相同场景的图像。 您可以调整全局对齐计划及其迭代次数。 注意：如果...
3D-dust3d.zip
09-16
3D-dust3d.zip,dust3d是一个跨平台的开源三维建模软件。自动紫外线展开，自动装配与PBR材料支持，姿势和运动创作在一起。,3D建模使用专门的软件来创建物理对象的数字模型。它是3D计算机图形的一个方面，用于视频游戏...
dust3d：Dust3D是跨平台的开源3D建模软件。 自动UV展开，带有PBR的自动绑定材料支持，姿势和动作创作全部合而为一
01-31
dust3d：Dust3D是跨平台的开源3D建模软件。 自动UV展开，带有PBR的自动绑定材料支持，姿势和动作创作全部合而为一
gulp-dust:预编译除尘模板
05-26
const dust = require ( 'gulp-dust' ) ;gulp . task ( 'default' , ( ) =>gulp . src ( 'templates/list.html' ). pipe ( dust ( ) ). pipe ( gulp . dest ( 'dist' ) )) ;原料药灰尘（[选项]）选项类型： Object...
Unity3d5.6 SpriteRenderer high SpriteMeshGenerator.TraceShape app Crash
atgczcl的专栏
07-06 2959
Unity3d5.6 SpriteRenderer 内存占用不断增加，apk程序奔溃的问题SpriteMeshGenerator.TraceShape SpriteMeshGenerator.Simplify 以上两个是Profile中SpriteRenderer的主要查看对象2d, 3d设计游戏中子弹始终会用到SpriteRenderer SpriteRenderer: Renders a
my-room-in-3d中的电脑，电视，桌面光带发光原理
webMinStudent的博客
05-04 684
我们会发现，这个高光纹理，他的颜色就三种颜色，分别是：r(红色), g(绿色), b(蓝色)最后我们发现，他这么做的原因，是因为他这样可以获取到，需要高光处的片源的的位置信息。最近在github中，看到了这样的一个项目；我看到的时候，蛮好奇他这个光带时怎么做的。好，我们来看看这个纹理和普通纹理有什么区别。知道了这些，这个高光效果就很简单了。最后发现，他是通过，加载一个。这个就是最核心的代码。
深入探索DreamFusion：文本到3D生成的革命性技术
windowshht的博客
04-30 1041
其次，DreamFusion利用2D扩散模型来实现文本到3D生成的任务。这一方法的关键在于通过已有的2D生成模型，根据给定的文本描述生成对应的3D模型。Imagen模型是一个先进的文本到图像生成模型，能够深入理解文本中的语义信息，并将其转化为高质量的图像。通过结合Imagen模型和2D扩散模型，DreamFusion能够在没有3D数据监督的情况下，根据文本描述生成对应的3D模型。通过对DreamFusion的技术原理、特点、应用场景以及未来展望的详细解读，我们可以更加深入地了解这项技术的重要性和潜力。
显卡矩阵计算能不能替代3dmark 的甜甜圈烤机
东方佑
05-04 1006
显卡矩阵计算通常是指利用显卡的并行处理能力来进行大规模的数学运算，这在科学计算、大数据处理、以及深度学习等领域非常常见。而3DMark的甜甜圈烤机（Dynamoometer）则是一种专门用于测试显卡在连续运行高负载3D图形渲染时的性能和稳定性的工具。
中科院突破：TalkingGaussian技术实现3D人脸动态无失真，高效同步嘴唇运动！
math_bearrr的博客
04-29 1555
3D高斯喷溅（3D Gaussian Splatting, 3DGS）是一种用于表达三维空间信息的技术，通过一组3D高斯原始数据来实现。这些高斯原始数据包括中心位置、缩放因子、旋转四元数、不透明度和颜色特征。在渲染过程中，根据相机模型信息，这些高斯原始数据被用来计算观察视图下的像素颜色。3DGS的核心优势在于其明确的空间表达和优化策略。通过梯度下降法优化高斯原始数据的参数，结合密集化策略控制原始数据的增长，并剪除不必要的数据，从而实现高效的颜色监督。
平滑 3d 坐标
jacke121的专栏
05-07 346
平滑 3d 坐标
绘画作品3d数字云展厅提升大众的艺术鉴赏和欣赏能力
最新发布
VRARvrnew3d的博客
05-07 175
3D虚拟艺术品展厅以其独特的魅力、永久保存的优势以及实时互动的功能，正逐渐成为艺术展示的新趋势。它打破了传统艺术展览的局限性，让艺术真正走进了每个人的生活。在未来的发展中，我们期待3D虚拟艺术品展厅能够继续创新和完善，为全球的艺术文化交流搭建一个更加广阔的平台。
Error: Argument "-dust". Value is missing Error: (CArgException::eNoArg) Argument "-dust". Value is missing
06-10
这个错误是由于使用了`-dust`参数，但未提供其值所致。`-dust`参数用于过滤低复杂度序列，其值应为`yes`或`no`。如果未提供该参数的值，则会出现所述错误。 要解决此错误，请在`-dust`参数后提供其值。例如，以下命令使用`-dust no`参数来禁用低复杂度序列过滤： ``` blastn -query query.fasta -db nr -out output.txt -dust no ``` 请注意，`-dust`参数仅适用于`blastn`和`tblastx`任务。如果您使用其他任务或程序，请确保不使用`-dust`参数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值