cura-engine学习（2）

来源：互联网发布：synthesia piano mac 编辑：程序博客网时间：2024/06/16 12:24

在函数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，这个类里面包含着一些算法方面的内容。

 1 class OptimizedVolume 2 { 3 public: 4     OptimizedModel* model; 5     vector<OptimizedPoint3> points; 6     vector<OptimizedFace> faces; 7  8     OptimizedVolume(SimpleVolume* volume, OptimizedModel* model); 9 10     int getFaceIdxWithPoints(int idx0, int idx1, int notFaceIdx)11     {12         for(unsigned int i=0;i<points[idx0].faceIndexList.size();i++)13         {14             int f0 = points[idx0].faceIndexList[i];15             if (f0 == notFaceIdx) continue;16             for(unsigned int j=0;j<points[idx1].faceIndexList.size();j++)17             {18                 int f1 = points[idx1].faceIndexList[j];19                 if (f1 == notFaceIdx) continue;20                 if (f0 == f1) return f0;21             }22         }23         return -1;24     }25 };

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

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

 1 OptimizedVolume::OptimizedVolume(SimpleVolume* volume, OptimizedModel* model) 2 : model(model) 3 { 4     points.reserve(volume->faces.size() * 3); 5     faces.reserve(volume->faces.size()); 6  7     std::map<uint32_t, std::vector<uint32_t> > indexMap; 8      9     double t = getTime();10     for(uint32_t i=0; i<volume->faces.size(); i++)11     {12         OptimizedFace f;13         if((i%1000==0) && (getTime()-t)>2.0) cura::logProgress("optimized", i + 1, volume->faces.size());14         for(uint32_t j=0; j<3; j++)15         {16             Point3 p = volume->faces[i].v[j];17             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);18             uint32_t idx;19             bool add = true;20             for(unsigned int n = 0; n < indexMap[hash].size(); n++)21             {22                 if ((points[indexMap[hash][n]].p - p).testLength(MELD_DIST))23                 {24                     idx = indexMap[hash][n];25                     add = false;26                     break;27                 }28             }29             if (add)30             {31                 indexMap[hash].push_back(points.size());32                 idx = points.size();33                 points.push_back(p);34             }35             f.index[j] = idx;36         }37         if (f.index[0] != f.index[1] && f.index[0] != f.index[2] && f.index[1] != f.index[2])38         {39         40             points[f.index[0]].faceIndexList.push_back(faces.size());41             points[f.index[1]].faceIndexList.push_back(faces.size());42             points[f.index[2]].faceIndexList.push_back(faces.size());43             faces.push_back(f);44             //}45         }46     }47     //fprintf(stdout, "\rAll faces are optimized in %5.1fs.\n",timeElapsed(t));48 49     int openFacesCount = 0;50     for(unsigned int i=0;i<faces.size();i++)51     {52         OptimizedFace* f = &faces[i];53         f->touching[0] = getFaceIdxWithPoints(f->index[0], f->index[1], i);54         f->touching[1] = getFaceIdxWithPoints(f->index[1], f->index[2], i);55         f->touching[2] = getFaceIdxWithPoints(f->index[2], f->index[0], i);56         if (f->touching[0] == -1)57             openFacesCount++;58         if (f->touching[1] == -1)59             openFacesCount++;60         if (f->touching[2] == -1)61             openFacesCount++;62     }63     //fprintf(stdout, "  Number of open faces: %i\n", openFacesCount);64 }

　　此部分代码好长啊，它实现了利用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数组中的位置。恩，就是这么的绕。

1  for(unsigned int n = 0; n < indexMap[hash].size(); n++)2             {3                 if ((points[indexMap[hash][n]].p - p).testLength(MELD_DIST))4                 {5                     idx = indexMap[hash][n];6                     add = false;7                     break;8                 }9             }

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

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

1 if (add)2             {3                 indexMap[hash].push_back(points.size());4                 idx = points.size();5                 points.push_back(p);6             }7             f.index[j] = idx;

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

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

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

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

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

 1 class OptimizedFace 2 { 3 public: 4     int index[3]; 5     int touching[3]; 6 }; 7 class OptimizedPoint3 8 { 9 public:10     Point3 p;11     vector<uint32_t> faceIndexList;12 13     OptimizedPoint3(Point3 p): p(p) {}14 };

上一篇涉及到的

 1 class SimpleFace 2 { 3 public: 4     Point3 v[3]; 5  6     SimpleFace(Point3& v0, Point3& v1, Point3& v2) { v[0] = v0; v[1] = v1; v[2] = v2; } 7 }; 8  9 /* A SimpleVolume is the most basic reprisentation of a 3D model. It contains all the faces as SimpleTriangles, with nothing fancy. */10 class SimpleVolume11 {12 public:13     vector<SimpleFace> faces;14 15     void addFace(Point3& v0, Point3& v1, Point3& v2)16     {17         faces.push_back(SimpleFace(v0, v1, v2));18     }19 20     Point3 min()；//删去了实现，要不有点长21     22     Point3 max()；23    24 };25 26 //A SimpleModel is a 3D model with 1 or more 3D volumes.27 class SimpleModel28 {29 public:30     vector<SimpleVolume> volumes;31 32     Point3 min()；33   34     Point3 max()；35    36 };

0 0