cura-engine学习（2）

在函数prepareModel(SliceDataStorage& storage, const std::vector<std::string> &files)中，在读取文件过后，有一个很关键的步骤，就是优化模型操作，是通过class OptimizedModel的构造函数OptimizedModel(model, Point3(config.objectPosition.X, config.objectPosition.Y, -config.objectSink));实现的。在本篇中就学习class OptimizedModel。

　　在optimizedModel.h和.cpp中记载着这个类的实现。

 1 class OptimizedModel
 2 {
 3 public:
 4     vector<OptimizedVolume> volumes;
 5     Point3 modelSize;
 6     Point3 vMin, vMax;
 7 
 8     OptimizedModel(SimpleModel* model, Point3 center)
 9     {
10         for(unsigned int i=0; i<model->volumes.size(); i++)
11             volumes.push_back(OptimizedVolume(&model->volumes[i], this));
12         vMin = model->min();
13         vMax = model->max();
14 
15         Point3 vOffset((vMin.x + vMax.x) / 2, (vMin.y + vMax.y) / 2, vMin.z);
16         //vOffset -= center;
17         if(ConfigSettings::config->autoCenter != 1)
18         {
19             vOffset.x = 0;
20             vOffset.y = 0;
21             if(ConfigSettings::config->autoCenter == 2)
22                 vOffset.z = 0;
23         }
24         vOffset -= center;
25         for(unsigned int i=0; i<volumes.size(); i++)
26             for(unsigned int n=0; n<volumes[i].points.size(); n++)
27                 volumes[i].points[n].p -= vOffset;
28 
29         modelSize = vMax - vMin;
30         vMin -= vOffset;
31         vMax -= vOffset;
32     }
33 
34     void saveDebugSTL(const char* filename);
35 };

　　这个类中包含的主要内容是vector<OptimizedVolume> volumes;下面的构造函数实现了把每一个model->volumes全部进行OptimizedVolume（）操作，然后在根据设置调整一下几何体的位置，之后保存调整之后的几何体信息的文件。关键步骤在于OptimizedVolume（）。下面我们看class OptimizedVolume，这个类里面包含着一些算法方面的内容。

class OptimizedVolume
{
public:
    OptimizedModel* model;
    vector<OptimizedPoint3> points;
    vector<OptimizedFace> faces;

    OptimizedVolume(SimpleVolume* volume, OptimizedModel* model);

    int getFaceIdxWithPoints(int idx0, int idx1, int notFaceIdx)
    {
        for(unsigned int i=0;i<points[idx0].faceIndexList.size();i++)
        {
            int f0 = points[idx0].faceIndexList[i];
            if (f0 == notFaceIdx) continue;
            for(unsigned int j=0;j<points[idx1].faceIndexList.size();j++)
            {
                int f1 = points[idx1].faceIndexList[j];
                if (f1 == notFaceIdx) continue;
                if (f0 == f1) return f0;
            }
        }
        return -1;
    }
};

　　

此类代表着经过优化的几何体数据，但其实所谓优化，只是去除了STL文件中多余的顶点，而后建立了面与点之间的对应关系存入成员points和faces中。实际的STL文件优化还有很多内容，如质

量检测，空洞检测，修复等等，此处均无涉及。
下面重点研究一下函数OptimizedVolume(SimpleVolume* volume, OptimizedModel* model); 

OptimizedVolume::OptimizedVolume(SimpleVolume* volume, OptimizedModel* model)
: model(model)
{
    points.reserve(volume->faces.size() * 3);
    faces.reserve(volume->faces.size());

    std::map<uint32_t, std::vector<uint32_t> > indexMap;
    
    double t = getTime();
    for(uint32_t i=0; i<volume->faces.size(); i++)
    {
        OptimizedFace f;
        if((i%1000==0) && (getTime()-t)>2.0) cura::logProgress("optimized", i + 1, volume->faces.size());
        for(uint32_t j=0; j<3; j++)
        {
            Point3 p = volume->faces[i].v[j];
            int hash = ((p.x + MELD_DIST/2) / MELD_DIST) ^ (((p.y + MELD_DIST/2) / MELD_DIST) << 10) ^ (((p.z + MELD_DIST/2) / MELD_DIST) << 20);
            uint32_t idx;
            bool add = true;
            for(unsigned int n = 0; n < indexMap[hash].size(); n++)
            {
                if ((points[indexMap[hash][n]].p - p).testLength(MELD_DIST))
                {
                    idx = indexMap[hash][n];
                    add = false;
                    break;
                }
            }
            if (add)
            {
                indexMap[hash].push_back(points.size());
                idx = points.size();
                points.push_back(p);
            }
            f.index[j] = idx;
        }
        if (f.index[0] != f.index[1] && f.index[0] != f.index[2] && f.index[1] != f.index[2])
        {
        
            points[f.index[0]].faceIndexList.push_back(faces.size());
            points[f.index[1]].faceIndexList.push_back(faces.size());
            points[f.index[2]].faceIndexList.push_back(faces.size());
            faces.push_back(f);
            //}
        }
    }
    //fprintf(stdout, "\rAll faces are optimized in %5.1fs.\n",timeElapsed(t));

    int openFacesCount = 0;
    for(unsigned int i=0;i<faces.size();i++)
    {
        OptimizedFace* f = &faces[i];
        f->touching[0] = getFaceIdxWithPoints(f->index[0], f->index[1], i);
        f->touching[1] = getFaceIdxWithPoints(f->index[1], f->index[2], i);
        f->touching[2] = getFaceIdxWithPoints(f->index[2], f->index[0], i);
        if (f->touching[0] == -1)
            openFacesCount++;
        if (f->touching[1] == -1)
            openFacesCount++;
        if (f->touching[2] == -1)
            openFacesCount++;
    }
    //fprintf(stdout, "  Number of open faces: %i\n", openFacesCount);
}

 

　　此部分代码好长啊，它实现了利用hash表对多余的节点进行过滤和点面数据建立对应关系。

过程如下：

　　首先 利用容器std::map<uint32_t, std::vector<uint32_t> > indexMap;建立一个hashtable；

　　Point3 p = volume->faces[i].v[j];逐一取出待处理几何体中的每个面的每个节点。

　　通过哈希函数计算出一个键值，赋予int hash；

　　indexMap中的hash这个位置存储的是一个整型的vector数组，数据indexMap[hash][n]代表在hash位置上数组的第n个数，这个数代表着点p在points数组中的位置。恩，就是这么的绕。

　　

 for(unsigned int n = 0; n < indexMap[hash].size(); n++)
            {
                if ((points[indexMap[hash][n]].p - p).testLength(MELD_DIST))
                {
                    idx = indexMap[hash][n];
                    add = false;
                    break;
                }
            }

 

 　　将点p逐一与表中hash位置的每一个索引对应的p进行比较，如果相同，就不进行处理，即add赋值为false

　　如果经过比较后add不是false，则执行

if (add)
            {
                indexMap[hash].push_back(points.size());
                idx = points.size();
                points.push_back(p);
            }
            f.index[j] = idx;

　　就是说将当前points的大小（也就是马上要插入的p的位置）压入indexMap表中hash位置的数组，记录p的索引值（位置）idx，然后将p压入points数组，然后将idx赋予面类型f的索引中，使面中保存其三个顶点的索引值。经过此过程，重复的节点全部被去掉，后一个个存入points数组中。

points[f.index[0]].faceIndexList.push_back(faces.size());
            points[f.index[1]].faceIndexList.push_back(faces.size());
            points[f.index[2]].faceIndexList.push_back(faces.size());
            faces.push_back(f);

　　然后经过如上代码把face的索引存入points数组中的每个点，然后将f压入faces中，至此points数组记录着所有点（无相同）的坐标，对应的面；faces数组中记录着每个面对应的点。

　　最后几行代码不列出了，它帮助每个面找到与其相邻的三个面，至此全部结束。

 这部分包含多个数据类，现连同上篇对其总结（就列出吧，用于都很短，倒是不难懂）

class OptimizedFace
{
public:
    int index[3];
    int touching[3];
};
class OptimizedPoint3
{
public:
    Point3 p;
    vector<uint32_t> faceIndexList;

    OptimizedPoint3(Point3 p): p(p) {}
};

上一篇涉及到的

class SimpleFace
{
public:
    Point3 v[3];

    SimpleFace(Point3& v0, Point3& v1, Point3& v2) { v[0] = v0; v[1] = v1; v[2] = v2; }
};

/* A SimpleVolume is the most basic reprisentation of a 3D model. It contains all the faces as SimpleTriangles, with nothing fancy. */
class SimpleVolume
{
public:
    vector<SimpleFace> faces;

    void addFace(Point3& v0, Point3& v1, Point3& v2)
    {
        faces.push_back(SimpleFace(v0, v1, v2));
    }

    Point3 min()；//删去了实现，要不有点长
    
    Point3 max()；
   
};

//A SimpleModel is a 3D model with 1 or more 3D volumes.
class SimpleModel
{
public:
    vector<SimpleVolume> volumes;

    Point3 min()；
  
    Point3 max()；
   
};