All: Reformat according to new standard

src/Mod/Mesh/App/Mesh.cpp

@@ -127,25 +127,30 @@ Data::Segment* MeshObject::getSubElement(const char* Type, unsigned long n) cons
         MeshSegment* segm = new MeshSegment();
         segm->mesh = new MeshObject(*this);
         const Segment& faces = getSegment(n);
-        segm->segment = std::make_unique<Segment>(static_cast<MeshObject*>(segm->mesh),
-                                                  faces.getIndices(),
-                                                  false);
+        segm->segment = std::make_unique<Segment>(
+            static_cast<MeshObject*>(segm->mesh),
+            faces.getIndices(),
+            false
+        );
         return segm;
     }
 
     return nullptr;
 }
 
-void MeshObject::getFacesFromSubElement(const Data::Segment* element,
-                                        std::vector<Base::Vector3d>& points,
-                                        std::vector<Base::Vector3d>& /*pointNormals*/,
-                                        std::vector<Facet>& faces) const
+void MeshObject::getFacesFromSubElement(
+    const Data::Segment* element,
+    std::vector<Base::Vector3d>& points,
+    std::vector<Base::Vector3d>& /*pointNormals*/,
+    std::vector<Facet>& faces
+) const
 {
     if (element && element->is<MeshSegment>()) {
         const MeshSegment* segm = static_cast<const MeshSegment*>(element);
         if (segm->segment) {
             Base::Reference<MeshObject> submesh(
-                segm->mesh->meshFromSegment(segm->segment->getIndices()));
+                segm->mesh->meshFromSegment(segm->segment->getIndices())
+            );
             submesh->getFaces(points, faces, 0.0);
         }
         else {
@@ -328,10 +333,12 @@ MeshPoint MeshObject::getMeshPoint(PointIndex index) const
     return point;
 }
 
-void MeshObject::getPoints(std::vector<Base::Vector3d>& Points,
-                           std::vector<Base::Vector3d>& Normals,
-                           double /*Accuracy*/,
-                           uint16_t /*flags*/) const
+void MeshObject::getPoints(
+    std::vector<Base::Vector3d>& Points,
+    std::vector<Base::Vector3d>& Normals,
+    double /*Accuracy*/,
+    uint16_t /*flags*/
+) const
 {
     Points = transformPointsToOutside(_kernel.GetPoints());
     MeshCore::MeshRefNormalToPoints ptNormals(_kernel);
@@ -344,10 +351,8 @@ Mesh::Facet MeshObject::getMeshFacet(FacetIndex index) const
     return face;
 }
 
-void MeshObject::getFaces(std::vector<Base::Vector3d>& Points,
-                          std::vector<Facet>& Topo,
-                          double /*Accuracy*/,
-                          uint16_t /*flags*/) const
+void MeshObject::
+    getFaces(std::vector<Base::Vector3d>& Points, std::vector<Facet>& Topo, double /*Accuracy*/, uint16_t /*flags*/) const
 {
     unsigned long ctpoints = _kernel.CountPoints();
     Points.reserve(ctpoints);
@@ -392,10 +397,12 @@ void MeshObject::RestoreDocFile(Base::Reader& reader)
     load(reader);
 }
 
-void MeshObject::save(const char* file,
-                      MeshCore::MeshIO::Format f,
-                      const MeshCore::Material* mat,
-                      const char* objectname) const
+void MeshObject::save(
+    const char* file,
+    MeshCore::MeshIO::Format f,
+    const MeshCore::Material* mat,
+    const char* objectname
+) const
 {
     MeshCore::MeshOutput aWriter(this->_kernel, mat);
     if (objectname) {
@@ -423,10 +430,12 @@ void MeshObject::save(const char* file,
     aWriter.SaveAny(file, f);
 }
 
-void MeshObject::save(std::ostream& str,
-                      MeshCore::MeshIO::Format f,
-                      const MeshCore::Material* mat,
-                      const char* objectname) const
+void MeshObject::save(
+    std::ostream& str,
+    MeshCore::MeshIO::Format f,
+    const MeshCore::Material* mat,
+    const char* objectname
+) const
 {
     MeshCore::MeshOutput aWriter(this->_kernel, mat);
     if (objectname) {
@@ -586,16 +595,20 @@ void MeshObject::addFacets(const std::vector<MeshCore::MeshFacet>& facets, bool
     _kernel.AddFacets(facets, checkManifolds);
 }
 
-void MeshObject::addFacets(const std::vector<MeshCore::MeshFacet>& facets,
-                           const std::vector<Base::Vector3f>& points,
-                           bool checkManifolds)
+void MeshObject::addFacets(
+    const std::vector<MeshCore::MeshFacet>& facets,
+    const std::vector<Base::Vector3f>& points,
+    bool checkManifolds
+)
 {
     _kernel.AddFacets(facets, points, checkManifolds);
 }
 
-void MeshObject::addFacets(const std::vector<Data::ComplexGeoData::Facet>& facets,
-                           const std::vector<Base::Vector3d>& points,
-                           bool checkManifolds)
+void MeshObject::addFacets(
+    const std::vector<Data::ComplexGeoData::Facet>& facets,
+    const std::vector<Base::Vector3d>& points,
+    bool checkManifolds
+)
 {
     std::vector<MeshCore::MeshFacet> facet_v;
     facet_v.reserve(facets.size());
@@ -622,8 +635,10 @@ void MeshObject::setFacets(const std::vector<MeshCore::MeshGeomFacet>& facets)
     _kernel = facets;
 }
 
-void MeshObject::setFacets(const std::vector<Data::ComplexGeoData::Facet>& facets,
-                           const std::vector<Base::Vector3d>& points)
+void MeshObject::setFacets(
+    const std::vector<Data::ComplexGeoData::Facet>& facets,
+    const std::vector<Base::Vector3d>& points
+)
 {
     MeshCore::MeshFacetArray facet_v;
     facet_v.reserve(facets.size());
@@ -792,9 +807,11 @@ std::vector<PointIndex> MeshObject::getPointsFromFacets(const std::vector<FacetI
     return _kernel.GetFacetPoints(facets);
 }
 
-bool MeshObject::nearestFacetOnRay(const MeshObject::TRay& ray,
-                                   double maxAngle,
-                                   MeshObject::TFaceSection& output) const
+bool MeshObject::nearestFacetOnRay(
+    const MeshObject::TRay& ray,
+    double maxAngle,
+    MeshObject::TFaceSection& output
+) const
 {
     Base::Vector3f pnt = Base::toVector<float>(ray.first);
     Base::Vector3f dir = Base::toVector<float>(ray.second);
@@ -898,8 +915,10 @@ void MeshObject::removeComponents(unsigned long count)
     deletedFacets(removeIndices);
 }
 
-unsigned long MeshObject::getPointDegree(const std::vector<FacetIndex>& indices,
-                                         std::vector<PointIndex>& point_degree) const
+unsigned long MeshObject::getPointDegree(
+    const std::vector<FacetIndex>& indices,
+    std::vector<PointIndex>& point_degree
+) const
 {
     const MeshCore::MeshFacetArray& faces = _kernel.GetFacets();
     std::vector<PointIndex> pointDeg(_kernel.CountPoints());
@@ -925,9 +944,7 @@ unsigned long MeshObject::getPointDegree(const std::vector<FacetIndex>& indices,
     return countInvalids;
 }
 
-void MeshObject::fillupHoles(unsigned long length,
-                             int level,
-                             MeshCore::AbstractPolygonTriangulator& cTria)
+void MeshObject::fillupHoles(unsigned long length, int level, MeshCore::AbstractPolygonTriangulator& cTria)
 {
     std::list<std::vector<PointIndex>> aFailed;
     MeshCore::MeshTopoAlgorithm topalg(_kernel);
@@ -979,14 +996,18 @@ void MeshObject::offsetSpecial2(float fSize)
                 continue;
             }
             // calculate the angle between them
-            float angle = acos((FaceNormals[i] * it->GetNormal())
-                               / (it->GetNormal().Length() * FaceNormals[i].Length()));
+            float angle = acos(
+                (FaceNormals[i] * it->GetNormal())
+                / (it->GetNormal().Length() * FaceNormals[i].Length())
+            );
             if (angle > 1.6) {
                 Base::DrawStyle drawStyle;
                 drawStyle.pointSize = 4.0F;
-                Base::PointItem item {it->GetGravityPoint(),
-                                      drawStyle,
-                                      Base::ColorRGB {1.0F, 0.0F, 0.0F}};
+                Base::PointItem item {
+                    it->GetGravityPoint(),
+                    drawStyle,
+                    Base::ColorRGB {1.0F, 0.0F, 0.0F}
+                };
                 builder.addNode(item);
                 flipped.insert(it.Position());
             }
@@ -1107,10 +1128,12 @@ std::vector<Base::Vector3d> MeshObject::getPointNormals() const
     return normals;
 }
 
-void MeshObject::crossSections(const std::vector<MeshObject::TPlane>& planes,
-                               std::vector<MeshObject::TPolylines>& sections,
-                               float fMinEps,
-                               bool bConnectPolygons) const
+void MeshObject::crossSections(
+    const std::vector<MeshObject::TPlane>& planes,
+    std::vector<MeshObject::TPolylines>& sections,
+    float fMinEps,
+    bool bConnectPolygons
+) const
 {
     MeshCore::MeshKernel kernel(this->_kernel);
     kernel.Transform(this->_Mtrx);
@@ -1124,9 +1147,11 @@ void MeshObject::crossSections(const std::vector<MeshObject::TPlane>& planes,
     }
 }
 
-void MeshObject::cut(const Base::Polygon2d& polygon2d,
-                     const Base::ViewProjMethod& proj,
-                     MeshObject::CutType type)
+void MeshObject::cut(
+    const Base::Polygon2d& polygon2d,
+    const Base::ViewProjMethod& proj,
+    MeshObject::CutType type
+)
 {
     MeshCore::MeshKernel kernel(this->_kernel);
     kernel.Transform(getTransform());
@@ -1154,9 +1179,11 @@ void MeshObject::cut(const Base::Polygon2d& polygon2d,
     }
 }
 
-void MeshObject::trim(const Base::Polygon2d& polygon2d,
-                      const Base::ViewProjMethod& proj,
-                      MeshObject::CutType type)
+void MeshObject::trim(
+    const Base::Polygon2d& polygon2d,
+    const Base::ViewProjMethod& proj,
+    MeshObject::CutType type
+)
 {
     MeshCore::MeshKernel kernel(this->_kernel);
     kernel.Transform(getTransform());
@@ -1224,11 +1251,7 @@ MeshObject* MeshObject::unite(const MeshObject& mesh) const
     kernel1.Transform(this->_Mtrx);
     MeshCore::MeshKernel kernel2(mesh._kernel);
     kernel2.Transform(mesh._Mtrx);
-    MeshCore::SetOperations setOp(kernel1,
-                                  kernel2,
-                                  result,
-                                  MeshCore::SetOperations::Union,
-                                  Epsilon);
+    MeshCore::SetOperations setOp(kernel1, kernel2, result, MeshCore::SetOperations::Union, Epsilon);
     setOp.Do();
     return new MeshObject(result);
 }
@@ -1240,11 +1263,7 @@ MeshObject* MeshObject::intersect(const MeshObject& mesh) const
     kernel1.Transform(this->_Mtrx);
     MeshCore::MeshKernel kernel2(mesh._kernel);
     kernel2.Transform(mesh._Mtrx);
-    MeshCore::SetOperations setOp(kernel1,
-                                  kernel2,
-                                  result,
-                                  MeshCore::SetOperations::Intersect,
-                                  Epsilon);
+    MeshCore::SetOperations setOp(kernel1, kernel2, result, MeshCore::SetOperations::Intersect, Epsilon);
     setOp.Do();
     return new MeshObject(result);
 }
@@ -1256,11 +1275,7 @@ MeshObject* MeshObject::subtract(const MeshObject& mesh) const
     kernel1.Transform(this->_Mtrx);
     MeshCore::MeshKernel kernel2(mesh._kernel);
     kernel2.Transform(mesh._Mtrx);
-    MeshCore::SetOperations setOp(kernel1,
-                                  kernel2,
-                                  result,
-                                  MeshCore::SetOperations::Difference,
-                                  Epsilon);
+    MeshCore::SetOperations setOp(kernel1, kernel2, result, MeshCore::SetOperations::Difference, Epsilon);
     setOp.Do();
     return new MeshObject(result);
 }
@@ -1272,11 +1287,7 @@ MeshObject* MeshObject::inner(const MeshObject& mesh) const
     kernel1.Transform(this->_Mtrx);
     MeshCore::MeshKernel kernel2(mesh._kernel);
     kernel2.Transform(mesh._Mtrx);
-    MeshCore::SetOperations setOp(kernel1,
-                                  kernel2,
-                                  result,
-                                  MeshCore::SetOperations::Inner,
-                                  Epsilon);
+    MeshCore::SetOperations setOp(kernel1, kernel2, result, MeshCore::SetOperations::Inner, Epsilon);
     setOp.Do();
     return new MeshObject(result);
 }
@@ -1288,17 +1299,16 @@ MeshObject* MeshObject::outer(const MeshObject& mesh) const
     kernel1.Transform(this->_Mtrx);
     MeshCore::MeshKernel kernel2(mesh._kernel);
     kernel2.Transform(mesh._Mtrx);
-    MeshCore::SetOperations setOp(kernel1,
-                                  kernel2,
-                                  result,
-                                  MeshCore::SetOperations::Outer,
-                                  Epsilon);
+    MeshCore::SetOperations setOp(kernel1, kernel2, result, MeshCore::SetOperations::Outer, Epsilon);
     setOp.Do();
     return new MeshObject(result);
 }
 
-std::vector<std::vector<Base::Vector3f>>
-MeshObject::section(const MeshObject& mesh, bool connectLines, float fMinDist) const
+std::vector<std::vector<Base::Vector3f>> MeshObject::section(
+    const MeshObject& mesh,
+    bool connectLines,
+    float fMinDist
+) const
 {
     MeshCore::MeshKernel kernel1(this->_kernel);
     kernel1.Transform(this->_Mtrx);
@@ -1402,8 +1412,7 @@ void MeshObject::splitEdges()
         int id = 2;
         if (pF->_aulNeighbours[id] != MeshCore::FACET_INDEX_MAX) {
             const MeshCore::MeshFacet& rFace = rFacets[pF->_aulNeighbours[id]];
-            if (!pF->IsFlag(MeshCore::MeshFacet::VISIT)
-                && !rFace.IsFlag(MeshCore::MeshFacet::VISIT)) {
+            if (!pF->IsFlag(MeshCore::MeshFacet::VISIT) && !rFace.IsFlag(MeshCore::MeshFacet::VISIT)) {
                 pF->SetFlag(MeshCore::MeshFacet::VISIT);
                 rFace.SetFlag(MeshCore::MeshFacet::VISIT);
                 adjacentFacet.emplace_back(pF - rFacets.begin(), pF->_aulNeighbours[id]);
@@ -1544,8 +1553,7 @@ MeshObject::TFacePairs MeshObject::getSelfIntersections() const
     return pairs;
 }
 
-std::vector<Base::Line3d>
-MeshObject::getSelfIntersections(const MeshObject::TFacePairs& facets) const
+std::vector<Base::Line3d> MeshObject::getSelfIntersections(const MeshObject::TFacePairs& facets) const
 {
     MeshCore::MeshEvalSelfIntersection eval(getKernel());
     using Section = std::pair<Base::Vector3f, Base::Vector3f>;
@@ -1556,13 +1564,17 @@ MeshObject::getSelfIntersections(const MeshObject::TFacePairs& facets) const
     lines.reserve(selfPoints.size());
 
     Base::Matrix4D mat(getTransform());
-    std::transform(selfPoints.begin(),
-                   selfPoints.end(),
-                   std::back_inserter(lines),
-                   [&mat](const Section& l) {
-                       return Base::Line3d(mat * Base::convertTo<Base::Vector3d>(l.first),
-                                           mat * Base::convertTo<Base::Vector3d>(l.second));
-                   });
+    std::transform(
+        selfPoints.begin(),
+        selfPoints.end(),
+        std::back_inserter(lines),
+        [&mat](const Section& l) {
+            return Base::Line3d(
+                mat * Base::convertTo<Base::Vector3d>(l.first),
+                mat * Base::convertTo<Base::Vector3d>(l.second)
+            );
+        }
+    );
     return lines;
 }
 
@@ -1585,11 +1597,11 @@ void MeshObject::removeSelfIntersections(const std::vector<FacetIndex>& indices)
         return;
     }
     unsigned long cntfacets = _kernel.CountFacets();
-    if (std::find_if(indices.begin(),
-                     indices.end(),
-                     [cntfacets](FacetIndex v) {
-                         return v >= cntfacets;
-                     })
+    if (std::find_if(
+            indices.begin(),
+            indices.end(),
+            [cntfacets](FacetIndex v) { return v >= cntfacets; }
+        )
         < indices.end()) {
         return;
     }
@@ -1745,11 +1757,8 @@ bool MeshObject::hasCorruptedFacets() const
 void MeshObject::validateDeformations(float fMaxAngle, float fEps)
 {
     unsigned long count = _kernel.CountFacets();
-    MeshCore::MeshFixDeformedFacets eval(_kernel,
-                                         Base::toRadians(15.0F),
-                                         Base::toRadians(150.0F),
-                                         fMaxAngle,
-                                         fEps);
+    MeshCore::MeshFixDeformedFacets
+        eval(_kernel, Base::toRadians(15.0F), Base::toRadians(150.0F), fMaxAngle, fEps);
     eval.Fixup();
     if (_kernel.CountFacets() < count) {
         this->_segments.clear();
@@ -1860,8 +1869,7 @@ MeshObject* MeshObject::createEllipsoid(float radius1, float radius2, int sampli
     return nullptr;
 }
 
-MeshObject*
-MeshObject::createCylinder(float radius, float length, int closed, float edgelen, int sampling)
+MeshObject* MeshObject::createCylinder(float radius, float length, int closed, float edgelen, int sampling)
 {
     // load the 'BuildRegularGeoms' module
     Base::PyGILStateLocker lock;
@@ -1888,12 +1896,14 @@ MeshObject::createCylinder(float radius, float length, int closed, float edgelen
     return nullptr;
 }
 
-MeshObject* MeshObject::createCone(float radius1,
-                                   float radius2,
-                                   float len,
-                                   int closed,
-                                   float edgelen,
-                                   int sampling)
+MeshObject* MeshObject::createCone(
+    float radius1,
+    float radius2,
+    float len,
+    int closed,
+    float edgelen,
+    int sampling
+)
 {
     // load the 'BuildRegularGeoms' module
     Base::PyGILStateLocker lock;
@@ -2076,9 +2086,11 @@ MeshObject* MeshObject::meshFromSegment(const std::vector<FacetIndex>& indices)
     return new MeshObject(kernel, _Mtrx);
 }
 
-std::vector<Segment> MeshObject::getSegmentsOfType(MeshObject::GeometryType type,
-                                                   float dev,
-                                                   unsigned long minFacets) const
+std::vector<Segment> MeshObject::getSegmentsOfType(
+    MeshObject::GeometryType type,
+    float dev,
+    unsigned long minFacets
+) const
 {
     std::vector<Segment> segm;
     if (this->_kernel.CountFacets() == 0) {
@@ -2089,25 +2101,28 @@ std::vector<Segment> MeshObject::getSegmentsOfType(MeshObject::GeometryType type
     std::shared_ptr<MeshCore::MeshDistanceSurfaceSegment> surf;
     switch (type) {
         case PLANE:
-            surf.reset(
-                new MeshCore::MeshDistanceGenericSurfaceFitSegment(new MeshCore::PlaneSurfaceFit,
-                                                                   this->_kernel,
-                                                                   minFacets,
-                                                                   dev));
+            surf.reset(new MeshCore::MeshDistanceGenericSurfaceFitSegment(
+                new MeshCore::PlaneSurfaceFit,
+                this->_kernel,
+                minFacets,
+                dev
+            ));
             break;
         case CYLINDER:
-            surf.reset(
-                new MeshCore::MeshDistanceGenericSurfaceFitSegment(new MeshCore::CylinderSurfaceFit,
-                                                                   this->_kernel,
-                                                                   minFacets,
-                                                                   dev));
+            surf.reset(new MeshCore::MeshDistanceGenericSurfaceFitSegment(
+                new MeshCore::CylinderSurfaceFit,
+                this->_kernel,
+                minFacets,
+                dev
+            ));
             break;
         case SPHERE:
-            surf.reset(
-                new MeshCore::MeshDistanceGenericSurfaceFitSegment(new MeshCore::SphereSurfaceFit,
-                                                                   this->_kernel,
-                                                                   minFacets,
-                                                                   dev));
+            surf.reset(new MeshCore::MeshDistanceGenericSurfaceFitSegment(
+                new MeshCore::SphereSurfaceFit,
+                this->_kernel,
+                minFacets,
+                dev
+            ));
             break;
         default:
             break;
@@ -2138,19 +2153,21 @@ MeshObject::const_point_iterator::const_point_iterator(const MeshObject* mesh, P
     this->_point.Mesh = _mesh;
 }
 
-MeshObject::const_point_iterator::const_point_iterator(const MeshObject::const_point_iterator& pi) =
-    default;
+MeshObject::const_point_iterator::const_point_iterator(
+    const MeshObject::const_point_iterator& pi
+) = default;
 
-MeshObject::const_point_iterator::const_point_iterator(MeshObject::const_point_iterator&& pi) =
-    default;
+MeshObject::const_point_iterator::const_point_iterator(MeshObject::const_point_iterator&& pi) = default;
 
 MeshObject::const_point_iterator::~const_point_iterator() = default;
 
-MeshObject::const_point_iterator&
-MeshObject::const_point_iterator::operator=(const MeshObject::const_point_iterator& pi) = default;
+MeshObject::const_point_iterator& MeshObject::const_point_iterator::operator=(
+    const MeshObject::const_point_iterator& pi
+) = default;
 
-MeshObject::const_point_iterator&
-MeshObject::const_point_iterator::operator=(MeshObject::const_point_iterator&& pi) = default;
+MeshObject::const_point_iterator& MeshObject::const_point_iterator::operator=(
+    MeshObject::const_point_iterator&& pi
+) = default;
 
 void MeshObject::const_point_iterator::dereference()
 {
@@ -2205,19 +2222,21 @@ MeshObject::const_facet_iterator::const_facet_iterator(const MeshObject* mesh, F
     this->_facet.Mesh = _mesh;
 }
 
-MeshObject::const_facet_iterator::const_facet_iterator(const MeshObject::const_facet_iterator& fi) =
-    default;
+MeshObject::const_facet_iterator::const_facet_iterator(
+    const MeshObject::const_facet_iterator& fi
+) = default;
 
-MeshObject::const_facet_iterator::const_facet_iterator(MeshObject::const_facet_iterator&& fi) =
-    default;
+MeshObject::const_facet_iterator::const_facet_iterator(MeshObject::const_facet_iterator&& fi) = default;
 
 MeshObject::const_facet_iterator::~const_facet_iterator() = default;
 
-MeshObject::const_facet_iterator&
-MeshObject::const_facet_iterator::operator=(const MeshObject::const_facet_iterator& fi) = default;
+MeshObject::const_facet_iterator& MeshObject::const_facet_iterator::operator=(
+    const MeshObject::const_facet_iterator& fi
+) = default;
 
-MeshObject::const_facet_iterator&
-MeshObject::const_facet_iterator::operator=(MeshObject::const_facet_iterator&& fi) = default;
+MeshObject::const_facet_iterator& MeshObject::const_facet_iterator::operator=(
+    MeshObject::const_facet_iterator&& fi
+) = default;
 
 void MeshObject::const_facet_iterator::dereference()
 {