diff --git a/src/Base/BoundBox.h b/src/Base/BoundBox.h
index dd086a4b8..74b464fa2 100644
--- a/src/Base/BoundBox.h
+++ b/src/Base/BoundBox.h
@@ -29,7 +29,7 @@
 #include "ViewProj.h"
 #include "Tools2D.h"
 #include <iostream>
-#include <limits>
+#include <limits>
 
 namespace Base {
 
@@ -833,7 +833,7 @@ inline Vector3<_Precision> BoundBox3<_Precision>::ClosestPoint (const Vector3<_P
     for (int i = 0; i < 6; i++) {
         Vector3<_Precision> clTemp = rclPt;
         CalcPlane(i, cBase, cNormal);
-        clTemp.ProjToPlane(cBase, cNormal);
+        clTemp.ProjectToPlane(cBase, cNormal);
         _Precision fDist = (clTemp - rclPt).Length();
         if (fDist < fMinDist) {
             fMinDist = fDist;
@@ -843,31 +843,31 @@ inline Vector3<_Precision> BoundBox3<_Precision>::ClosestPoint (const Vector3<_P
 
     return clRet;
 #else
-    Vector3<_Precision> closest = rclPt;
-
-    Vector3<_Precision> center = GetCenter();
-    _Precision devx = closest.x - center.x;
-    _Precision devy = closest.y - center.y;
-    _Precision devz = closest.z - center.z;
-
-    _Precision halfwidth  = (MaxX - MinX) / 2;
-    _Precision halfheight = (MaxY - MinY) / 2;
-    _Precision halfdepth  = (MaxZ - MinZ) / 2;
-
-    // Move point to be on the nearest plane of the box.
-    if ((fabs(devx) > fabs(devy)) && (fabs(devx) > fabs(devz)))
-        closest.x = center.x + halfwidth * ((devx < 0.0) ? -1.0 : 1.0);
-    else if (fabs(devy) > fabs(devz))
-        closest.y = center.y + halfheight * ((devy < 0.0) ? -1.0 : 1.0);
-    else
-        closest.z = center.z + halfdepth * ((devz < 0.0) ? -1.0 : 1.0);
-
-    // Clamp to be inside box.
-    closest.x = std::min<_Precision>(std::max<_Precision>(closest.x, MinX), MaxX);
-    closest.y = std::min<_Precision>(std::max<_Precision>(closest.y, MinY), MaxY);
-    closest.z = std::min<_Precision>(std::max<_Precision>(closest.z, MinZ), MaxZ);
-
-    return closest;
+    Vector3<_Precision> closest = rclPt;
+
+    Vector3<_Precision> center = GetCenter();
+    _Precision devx = closest.x - center.x;
+    _Precision devy = closest.y - center.y;
+    _Precision devz = closest.z - center.z;
+
+    _Precision halfwidth  = (MaxX - MinX) / 2;
+    _Precision halfheight = (MaxY - MinY) / 2;
+    _Precision halfdepth  = (MaxZ - MinZ) / 2;
+
+    // Move point to be on the nearest plane of the box.
+    if ((fabs(devx) > fabs(devy)) && (fabs(devx) > fabs(devz)))
+        closest.x = center.x + halfwidth * ((devx < 0.0) ? -1.0 : 1.0);
+    else if (fabs(devy) > fabs(devz))
+        closest.y = center.y + halfheight * ((devy < 0.0) ? -1.0 : 1.0);
+    else
+        closest.z = center.z + halfdepth * ((devz < 0.0) ? -1.0 : 1.0);
+
+    // Clamp to be inside box.
+    closest.x = std::min<_Precision>(std::max<_Precision>(closest.x, MinX), MaxX);
+    closest.y = std::min<_Precision>(std::max<_Precision>(closest.y, MinY), MaxY);
+    closest.z = std::min<_Precision>(std::max<_Precision>(closest.z, MinZ), MaxZ);
+
+    return closest;
 #endif
 }
 
diff --git a/src/Base/Tools2D.cpp b/src/Base/Tools2D.cpp
index dafc605d3..ca7c84495 100644
--- a/src/Base/Tools2D.cpp
+++ b/src/Base/Tools2D.cpp
@@ -54,7 +54,7 @@ double Vector2D::GetAngle (const Vector2D &rclVect) const
     return -FLOAT_MAX; // division by zero
 }
 
-void Vector2D::ProjToLine (const Vector2D &rclPt, const Vector2D &rclLine)
+void Vector2D::ProjectToLine (const Vector2D &rclPt, const Vector2D &rclLine)
 {
   double l  = rclLine.Length();
   double t1 = (rclPt * rclLine) / l;
diff --git a/src/Base/Tools2D.h b/src/Base/Tools2D.h
index 062e7a58f..3fc82a145 100644
--- a/src/Base/Tools2D.h
+++ b/src/Base/Tools2D.h
@@ -68,7 +68,7 @@ public:
   inline void Scale (double fS);
   inline void Normalize (void);
   double GetAngle (const Vector2D &rclVect) const;
-  void  ProjToLine (const Vector2D &rclPt, const Vector2D &rclLine);
+  void  ProjectToLine (const Vector2D &rclPt, const Vector2D &rclLine);
 };
 
 /** BoundBox2D ********************************************/
diff --git a/src/Base/Vector3D.cpp b/src/Base/Vector3D.cpp
index 5d11e61d9..e22fc58f2 100644
--- a/src/Base/Vector3D.cpp
+++ b/src/Base/Vector3D.cpp
@@ -22,6 +22,7 @@
 
 
 #include "PreCompiled.h"
+#include "Tools.h"
 #include "Vector3D.h"
 
 using namespace Base;
@@ -116,7 +117,7 @@ Vector3<_Precision>& Vector3<_Precision>::operator -= (const Vector3<_Precision>
 {
     x -= rcVct.x;
     y -= rcVct.y;
-    z -= rcVct.z;                    
+    z -= rcVct.z;
     return *this;
 }
 
@@ -165,6 +166,12 @@ _Precision Vector3<_Precision>::operator *  (const Vector3<_Precision>& rcVct) c
     return (x * rcVct.x) + (y * rcVct.y) + (z * rcVct.z);
 }
 
+template <class _Precision>
+_Precision Vector3<_Precision>::Dot (const Vector3<_Precision>& rcVct) const
+{
+    return (x * rcVct.x) + (y * rcVct.y) + (z * rcVct.z);
+}
+
 template <class _Precision>
 Vector3<_Precision> Vector3<_Precision>::operator %  (const Vector3<_Precision>& rcVct) const
 {
@@ -175,6 +182,16 @@ Vector3<_Precision> Vector3<_Precision>::operator %  (const Vector3<_Precision>&
     return cVctRes;
 }
 
+template <class _Precision>
+Vector3<_Precision> Vector3<_Precision>::Cross(const Vector3<_Precision>& rcVct) const
+{
+    Vector3<_Precision> cVctRes;
+    cVctRes.x = (y * rcVct.z) - (z * rcVct.y);
+    cVctRes.y = (z * rcVct.x) - (x * rcVct.z);
+    cVctRes.z = (x * rcVct.y) - (y * rcVct.x);
+    return cVctRes;
+}
+
 template <class _Precision>
 bool Vector3<_Precision>::operator != (const Vector3<_Precision>& rcVct) const
 { 
@@ -190,14 +207,23 @@ bool Vector3<_Precision>::operator == (const Vector3<_Precision>& rcVct) const
 }  
 
 template <class _Precision>
-Vector3<_Precision>& Vector3<_Precision>::ProjToPlane (const Vector3<_Precision> &rclBase, 
-                                                       const Vector3<_Precision> &rclNorm)
+Vector3<_Precision>& Vector3<_Precision>::ProjectToPlane (const Vector3<_Precision> &rclBase, 
+                                                          const Vector3<_Precision> &rclNorm)
 {
     Vector3<_Precision> clTemp(rclNorm);
     *this = *this - (clTemp *= ((*this - rclBase) * clTemp) / clTemp.Sqr());
     return *this;
 }
 
+template <class _Precision>
+void Vector3<_Precision>::ProjectToPlane (const Vector3 &rclBase,
+                                          const Vector3 &rclNorm,
+                                          Vector3 &rclProj) const
+{
+    Vector3<_Precision> clTemp(rclNorm);
+    rclProj = *this - (clTemp *= ((*this - rclBase) * clTemp) / clTemp.Sqr());
+}
+
 template <class _Precision>
 _Precision Vector3<_Precision>::DistanceToPlane (const Vector3<_Precision> &rclBase, 
                                                  const Vector3<_Precision> &rclNorm) const
@@ -219,30 +245,24 @@ _Precision Vector3<_Precision>::DistanceToLine (const Vector3<_Precision> &rclBa
 }
 
 template <class _Precision>
-Vector3<_Precision> Vector3<_Precision>::DistanceToLineSegment (const Vector3& rclP1,
-                                                                const Vector3& rclP2) const
+Vector3<_Precision> Vector3<_Precision>::DistanceToLineSegment(const Vector3& rclP1,
+                                                               const Vector3& rclP2) const
 {
-    Vector3<_Precision> dir = rclP2-rclP1;
-    Vector3<_Precision> beg = *this-rclP1;
-    Vector3<_Precision> end = beg+dir;
+    _Precision len2 = Base::DistanceP2(rclP1, rclP2);
+    if (len2 == 0)
+        return rclP1;
 
-    Vector3<_Precision> proj, len;
-    proj.ProjToLine(beg, dir);
-    len = proj + beg;
-    if (len * dir < 0 || len.Length() > dir.Length()) {
-        if (beg.Length() < end.Length())
-            return beg;
-        else
-            return end;
-    }
-    else {
-        return proj;
-    }
+    Vector3<_Precision> p2p1 = rclP2-rclP1;
+    Vector3<_Precision> pXp1 = *this-rclP1;
+    _Precision dot = pXp1 * p2p1;
+    _Precision t = clamp<_Precision>(dot/len2, 0, 1);
+    Vector3<_Precision> dist = t * p2p1 - pXp1;
+    return dist;
 }
 
 template <class _Precision>
-Vector3<_Precision>& Vector3<_Precision>::ProjToLine (const Vector3<_Precision> &rclPoint,
-                                                      const Vector3<_Precision> &rclLine)
+Vector3<_Precision>& Vector3<_Precision>::ProjectToLine (const Vector3<_Precision> &rclPoint,
+                                                         const Vector3<_Precision> &rclLine)
 {
     return (*this = ((((rclPoint * rclLine) / rclLine.Sqr()) * rclLine) - rclPoint));
 }
diff --git a/src/Base/Vector3D.h b/src/Base/Vector3D.h
index de582c676..e8de88663 100644
--- a/src/Base/Vector3D.h
+++ b/src/Base/Vector3D.h
@@ -117,8 +117,12 @@ public:
     Vector3 & operator =  (const Vector3<_Precision>& rcVct);
     /// Scalar product
     _Precision operator *  (const Vector3<_Precision>& rcVct) const;
+    /// Scalar product
+    _Precision Dot (const Vector3<_Precision>& rcVct) const;
     /// Cross product
     Vector3 operator %  (const Vector3<_Precision>& rcVct) const;
+    /// Cross product
+    Vector3 Cross (const Vector3<_Precision>& rcVct) const;
     /// Comparing for inequality
     bool operator != (const Vector3<_Precision>& rcVct) const;
     /// Comparing for equality
@@ -159,7 +163,12 @@ public:
     void TransformToCoordinateSystem (const Vector3 &rclBase, const Vector3 &rclDirX, const Vector3 &rclDirY);
     //bool Equal(const Vector3 &rclVect) const;
     /// Projects this point onto the plane given by the base \a rclBase and the normal \a rclNorm.
-    Vector3 & ProjToPlane (const Vector3 &rclBase, const Vector3 &rclNorm);
+    Vector3 & ProjectToPlane (const Vector3 &rclBase, const Vector3 &rclNorm);
+    /**
+     * Projects this point onto the plane given by the base \a rclBase and the normal \a rclNorm
+     * and stores the result in rclProj.
+     */
+    void ProjectToPlane (const Vector3 &rclBase, const Vector3 &rclNorm, Vector3 &rclProj) const;
     /// Projects this point onto the line given by the base \a rclPoint and the direction \a rclLine.
     /**
      * Projects a point \a rclPoint onto the line defined by the origin and the direction \a rclLine.
@@ -167,10 +176,10 @@ public:
      * is the distance from \a rclPoint to the line.
      * Note: The resulting vector does not depend on the current vector.
      */
-    Vector3 & ProjToLine (const Vector3 &rclPoint, const Vector3 &rclLine);
+    Vector3 & ProjectToLine (const Vector3 &rclPoint, const Vector3 &rclLine);
     /**
      * Get the perpendicular of this point to the line defined by rclBase and rclDir.
-     * Note: Do not mix up this method with ProjToLine.
+     * Note: Do not mix up this method with ProjectToLine.
      */
     Vector3 Perpendicular(const Vector3 &rclBase, const Vector3 &rclDir) const;
     /** Computes the distance to the given plane. Depending on the side this point is located
diff --git a/src/Base/VectorPyImp.cpp b/src/Base/VectorPyImp.cpp
index 94c7342e8..b8be1da7f 100644
--- a/src/Base/VectorPyImp.cpp
+++ b/src/Base/VectorPyImp.cpp
@@ -364,7 +364,7 @@ PyObject*  VectorPy::projectToLine(PyObject *args)
     VectorPy::PointerType base_ptr = reinterpret_cast<VectorPy::PointerType>(base_vec->_pcTwinPointer);
     VectorPy::PointerType line_ptr = reinterpret_cast<VectorPy::PointerType>(line_vec->_pcTwinPointer);
 
-    this_ptr->ProjToLine(*base_ptr, *line_ptr);
+    this_ptr->ProjectToLine(*base_ptr, *line_ptr);
 
     return Py::new_reference_to(this);
 }
@@ -390,7 +390,7 @@ PyObject*  VectorPy::projectToPlane(PyObject *args)
     VectorPy::PointerType base_ptr = reinterpret_cast<VectorPy::PointerType>(base_vec->_pcTwinPointer);
     VectorPy::PointerType line_ptr = reinterpret_cast<VectorPy::PointerType>(line_vec->_pcTwinPointer);
 
-    this_ptr->ProjToPlane(*base_ptr, *line_ptr);
+    this_ptr->ProjectToPlane(*base_ptr, *line_ptr);
 
     return Py::new_reference_to(this);
 }
diff --git a/src/Mod/Mesh/App/Core/Elements.cpp b/src/Mod/Mesh/App/Core/Elements.cpp
index 9553e45c0..bf99ffcfe 100644
--- a/src/Mod/Mesh/App/Core/Elements.cpp
+++ b/src/Mod/Mesh/App/Core/Elements.cpp
@@ -252,7 +252,7 @@ bool MeshGeomFacet::IsPointOf (const Base::Vector3f &rclPoint, float fDistance)
   float     fLP, fLE;
 
   clNorm.Normalize();
-  clProjPt.ProjToPlane(_aclPoints[0], clNorm);
+  clProjPt.ProjectToPlane(_aclPoints[0], clNorm);
 
     
   // Kante P0 --> P1
@@ -351,7 +351,7 @@ bool MeshGeomFacet::Weights(const Base::Vector3f& rclP, float& w0, float& w1, fl
 
 void MeshGeomFacet::ProjectPointToPlane (Base::Vector3f &rclPoint) const
 {
-  rclPoint.ProjToPlane(_aclPoints[0], GetNormal());
+  rclPoint.ProjectToPlane(_aclPoints[0], GetNormal());
 }
 
 void MeshGeomFacet::ProjectFacetToPlane (MeshGeomFacet &rclFacet) const
diff --git a/src/Mod/Mesh/App/Core/Evaluation.cpp b/src/Mod/Mesh/App/Core/Evaluation.cpp
index 5df748bb1..954ca7a01 100644
--- a/src/Mod/Mesh/App/Core/Evaluation.cpp
+++ b/src/Mod/Mesh/App/Core/Evaluation.cpp
@@ -81,8 +81,8 @@ bool MeshOrientationCollector::Visit (const MeshFacet &rclFacet, const MeshFacet
             // mark this facet as false oriented
             rclFacet.SetFlag(MeshFacet::TMP0);
             _aulIndices.push_back( ulFInd );
-        }
-        else
+        }
+        else
             _aulComplement.push_back( ulFInd );
     }
     else {
@@ -93,8 +93,8 @@ bool MeshOrientationCollector::Visit (const MeshFacet &rclFacet, const MeshFacet
             rclFacet.SetFlag(MeshFacet::TMP0);
             _aulIndices.push_back(ulFInd);
         }
-        else
-            _aulComplement.push_back( ulFInd );
+        else
+            _aulComplement.push_back( ulFInd );
     }
 
     return true;
@@ -129,26 +129,26 @@ MeshEvalOrientation::~MeshEvalOrientation()
 
 bool MeshEvalOrientation::Evaluate ()
 {
-    const MeshFacetArray& rFAry = _rclMesh.GetFacets();
-    MeshFacetArray::_TConstIterator iBeg = rFAry.begin();
-    MeshFacetArray::_TConstIterator iEnd = rFAry.end();
-    for (MeshFacetArray::_TConstIterator it = iBeg; it != iEnd; ++it) {
-        for (int i = 0; i < 3; i++) {
-            if (it->_aulNeighbours[i] != ULONG_MAX) {
-                const MeshFacet& rclFacet = iBeg[it->_aulNeighbours[i]];
-                for (int j = 0; j < 3; j++) {
-                    if (it->_aulPoints[i] == rclFacet._aulPoints[j]) {
-                        if ((it->_aulPoints[(i+1)%3] == rclFacet._aulPoints[(j+1)%3]) ||
-                            (it->_aulPoints[(i+2)%3] == rclFacet._aulPoints[(j+2)%3])) {
-                            return false; // adjacent face with wrong orientation
-                        } 
-                    }
-                }
-            }
-        }
-    }
-
-    return true;
+    const MeshFacetArray& rFAry = _rclMesh.GetFacets();
+    MeshFacetArray::_TConstIterator iBeg = rFAry.begin();
+    MeshFacetArray::_TConstIterator iEnd = rFAry.end();
+    for (MeshFacetArray::_TConstIterator it = iBeg; it != iEnd; ++it) {
+        for (int i = 0; i < 3; i++) {
+            if (it->_aulNeighbours[i] != ULONG_MAX) {
+                const MeshFacet& rclFacet = iBeg[it->_aulNeighbours[i]];
+                for (int j = 0; j < 3; j++) {
+                    if (it->_aulPoints[i] == rclFacet._aulPoints[j]) {
+                        if ((it->_aulPoints[(i+1)%3] == rclFacet._aulPoints[(j+1)%3]) ||
+                            (it->_aulPoints[(i+2)%3] == rclFacet._aulPoints[(j+2)%3])) {
+                            return false; // adjacent face with wrong orientation
+                        } 
+                    }
+                }
+            }
+        }
+    }
+
+    return true;
 }
 
 unsigned long MeshEvalOrientation::HasFalsePositives(const std::vector<unsigned long>& inds) const
@@ -159,26 +159,26 @@ unsigned long MeshEvalOrientation::HasFalsePositives(const std::vector<unsigned
     // a false positive.
     // False-positives can occur if the mesh structure has some defects which let the region-grow
     // algorithm fail to detect the faces with wrong orientation.
-    const MeshFacetArray& rFAry = _rclMesh.GetFacets();
-    MeshFacetArray::_TConstIterator iBeg = rFAry.begin();
-    for (std::vector<unsigned long>::const_iterator it = inds.begin(); it != inds.end(); ++it) {
-        const MeshFacet& f = iBeg[*it];
-        for (int i = 0; i < 3; i++) {
-            if (f._aulNeighbours[i] != ULONG_MAX) {
-                const MeshFacet& n = iBeg[f._aulNeighbours[i]];
-                if (f.IsFlag(MeshFacet::TMP0) && !n.IsFlag(MeshFacet::TMP0)) {
-                    for (int j = 0; j < 3; j++) {
-                        if (f.HasSameOrientation(n)) {
-                            // adjacent face with same orientation => false positive
-                            return f._aulNeighbours[i];
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    return ULONG_MAX;
+    const MeshFacetArray& rFAry = _rclMesh.GetFacets();
+    MeshFacetArray::_TConstIterator iBeg = rFAry.begin();
+    for (std::vector<unsigned long>::const_iterator it = inds.begin(); it != inds.end(); ++it) {
+        const MeshFacet& f = iBeg[*it];
+        for (int i = 0; i < 3; i++) {
+            if (f._aulNeighbours[i] != ULONG_MAX) {
+                const MeshFacet& n = iBeg[f._aulNeighbours[i]];
+                if (f.IsFlag(MeshFacet::TMP0) && !n.IsFlag(MeshFacet::TMP0)) {
+                    for (int j = 0; j < 3; j++) {
+                        if (f.HasSameOrientation(n)) {
+                            // adjacent face with same orientation => false positive
+                            return f._aulNeighbours[i];
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return ULONG_MAX;
 }
 
 std::vector<unsigned long> MeshEvalOrientation::GetIndices() const
@@ -204,19 +204,19 @@ std::vector<unsigned long> MeshEvalOrientation::GetIndices() const
     MeshOrientationCollector clHarmonizer(uIndices, uComplement);
 
     while (ulStartFacet !=  ULONG_MAX) {
-        unsigned long wrongFacets = uIndices.size();
-
-        uComplement.clear();
+        unsigned long wrongFacets = uIndices.size();
+
+        uComplement.clear();
         uComplement.push_back( ulStartFacet );
         ulVisited = _rclMesh.VisitNeighbourFacets(clHarmonizer, ulStartFacet) + 1;
-
-        // In the currently visited component we have found less than 40% as correct
-        // oriented and the rest as false oriented. So, we decide that it should be the other
-        // way round and swap the indices of this component.
-        if (uComplement.size() < (unsigned long)(0.4f*(float)ulVisited)) {
-            uIndices.erase(uIndices.begin()+wrongFacets, uIndices.end());
-            uIndices.insert(uIndices.end(), uComplement.begin(), uComplement.end());
-        }
+
+        // In the currently visited component we have found less than 40% as correct
+        // oriented and the rest as false oriented. So, we decide that it should be the other
+        // way round and swap the indices of this component.
+        if (uComplement.size() < (unsigned long)(0.4f*(float)ulVisited)) {
+            uIndices.erase(uIndices.begin()+wrongFacets, uIndices.end());
+            uIndices.insert(uIndices.end(), uComplement.begin(), uComplement.end());
+        }
 
         // if the mesh consists of several topologic independent components
         // We can search from position 'iTri' on because all elements _before_ are already visited
@@ -240,14 +240,14 @@ std::vector<unsigned long> MeshEvalOrientation::GetIndices() const
         MeshSameOrientationCollector coll(falsePos);
         _rclMesh.VisitNeighbourFacets(coll, ulStartFacet);
 
-        std::sort(uIndices.begin(), uIndices.end());
-        std::sort(falsePos.begin(), falsePos.end());
-
-        std::vector<unsigned long> diff;
-        std::back_insert_iterator<std::vector<unsigned long> > biit(diff);
-        std::set_difference(uIndices.begin(), uIndices.end(), falsePos.begin(), falsePos.end(), biit);
-        uIndices = diff;
-
+        std::sort(uIndices.begin(), uIndices.end());
+        std::sort(falsePos.begin(), falsePos.end());
+
+        std::vector<unsigned long> diff;
+        std::back_insert_iterator<std::vector<unsigned long> > biit(diff);
+        std::set_difference(uIndices.begin(), uIndices.end(), falsePos.begin(), falsePos.end(), biit);
+        uIndices = diff;
+
         cAlg.ResetFacetFlag(MeshFacet::TMP0);
         cAlg.SetFacetsFlag(uIndices, MeshFacet::TMP0);
         unsigned long current = ulStartFacet;
@@ -299,32 +299,32 @@ bool MeshEvalSolid::Evaluate ()
 }
 
 // ----------------------------------------------------
-
-namespace MeshCore {
-
-struct Edge_Index
-{
-    unsigned long p0, p1, f;
-};
-
-struct Edge_Less  : public std::binary_function<const Edge_Index&, 
-                                                const Edge_Index&, bool>
-{
-    bool operator()(const Edge_Index& x, const Edge_Index& y) const
-    {
-        if (x.p0 < y.p0)
-            return true;
-        else if (x.p0 > y.p0)
-            return false;
-        else if (x.p1 < y.p1)
-            return true;
-        else if (x.p1 > y.p1)
-            return false;
-        return false;
-    }
-};
-
-}
+
+namespace MeshCore {
+
+struct Edge_Index
+{
+    unsigned long p0, p1, f;
+};
+
+struct Edge_Less  : public std::binary_function<const Edge_Index&, 
+                                                const Edge_Index&, bool>
+{
+    bool operator()(const Edge_Index& x, const Edge_Index& y) const
+    {
+        if (x.p0 < y.p0)
+            return true;
+        else if (x.p0 > y.p0)
+            return false;
+        else if (x.p1 < y.p1)
+            return true;
+        else if (x.p1 > y.p1)
+            return false;
+        return false;
+    }
+};
+
+}
 
 bool MeshEvalTopology::Evaluate ()
 {
@@ -463,29 +463,29 @@ bool MeshEvalPointManifolds::Evaluate ()
     this->nonManifoldPoints.clear();
     this->facetsOfNonManifoldPoints.clear();
 
-    MeshCore::MeshRefPointToPoints vv_it(_rclMesh);
-    MeshCore::MeshRefPointToFacets vf_it(_rclMesh);
-
-    unsigned long ctPoints = _rclMesh.CountPoints();
-    for (unsigned long index=0; index < ctPoints; index++) {
-        // get the local neighbourhood of the point
-        const std::set<unsigned long>& nf = vf_it[index];
-        const std::set<unsigned long>& np = vv_it[index];
-
-        std::set<unsigned long>::size_type sp, sf;
-        sp = np.size();
-        sf = nf.size();
-        // for an inner point the number of adjacent points is equal to the number of shared faces
-        // for a boundary point the number of adjacent points is higher by one than the number of shared faces
-        // for a non-manifold point the number of adjacent points is higher by more than one than the number of shared faces
-        if (sp > sf + 1) {
-            nonManifoldPoints.push_back(index);
-            std::vector<unsigned long> faces;
-            faces.insert(faces.end(), nf.begin(), nf.end());
-            this->facetsOfNonManifoldPoints.push_back(faces);
-        }
-    }
-
+    MeshCore::MeshRefPointToPoints vv_it(_rclMesh);
+    MeshCore::MeshRefPointToFacets vf_it(_rclMesh);
+
+    unsigned long ctPoints = _rclMesh.CountPoints();
+    for (unsigned long index=0; index < ctPoints; index++) {
+        // get the local neighbourhood of the point
+        const std::set<unsigned long>& nf = vf_it[index];
+        const std::set<unsigned long>& np = vv_it[index];
+
+        std::set<unsigned long>::size_type sp, sf;
+        sp = np.size();
+        sf = nf.size();
+        // for an inner point the number of adjacent points is equal to the number of shared faces
+        // for a boundary point the number of adjacent points is higher by one than the number of shared faces
+        // for a non-manifold point the number of adjacent points is higher by more than one than the number of shared faces
+        if (sp > sf + 1) {
+            nonManifoldPoints.push_back(index);
+            std::vector<unsigned long> faces;
+            faces.insert(faces.end(), nf.begin(), nf.end());
+            this->facetsOfNonManifoldPoints.push_back(faces);
+        }
+    }
+
     return this->nonManifoldPoints.empty();
 }
 
@@ -658,8 +658,8 @@ bool MeshEvalSelfIntersection::Evaluate ()
     return true;
 }
 
-void MeshEvalSelfIntersection::GetIntersections(const std::vector<std::pair<unsigned long, unsigned long> >& indices,
-                                                std::vector<std::pair<Base::Vector3f, Base::Vector3f> >& intersection) const
+void MeshEvalSelfIntersection::GetIntersections(const std::vector<std::pair<unsigned long, unsigned long> >& indices,
+                                                std::vector<std::pair<Base::Vector3f, Base::Vector3f> >& intersection) const
 {
     intersection.reserve(indices.size());
     MeshFacetIterator cMF1(_rclMesh);
@@ -682,7 +682,7 @@ void MeshEvalSelfIntersection::GetIntersections(const std::vector<std::pair<unsi
     }
 }
 
-void MeshEvalSelfIntersection::GetIntersections(std::vector<std::pair<unsigned long, unsigned long> >& intersection) const
+void MeshEvalSelfIntersection::GetIntersections(std::vector<std::pair<unsigned long, unsigned long> >& intersection) const
 {
     // Contains bounding boxes for every facet 
     std::vector<Base::BoundBox3f> boxes;
@@ -751,8 +751,8 @@ void MeshEvalSelfIntersection::GetIntersections(std::vector<std::pair<unsigned l
         }
     }
 }
-
-std::vector<unsigned long> MeshFixSelfIntersection::GetFacets() const
+
+std::vector<unsigned long> MeshFixSelfIntersection::GetFacets() const
 {
     std::vector<unsigned long> indices;
     const MeshFacetArray& rFaces = _rclMesh.GetFacets();
@@ -780,9 +780,9 @@ std::vector<unsigned long> MeshFixSelfIntersection::GetFacets() const
     indices.erase(std::unique(indices.begin(), indices.end()), indices.end());
 
     return indices;
-}
+}
 
-bool MeshFixSelfIntersection::Fixup()
+bool MeshFixSelfIntersection::Fixup()
 {
     _rclMesh.DeleteFacets(GetFacets());
     return true;
@@ -942,9 +942,9 @@ bool MeshFixNeighbourhood::Fixup()
     _rclMesh.RebuildNeighbours();
     return true;
 }
-
-void MeshKernel::RebuildNeighbours (unsigned long index)
-{
+
+void MeshKernel::RebuildNeighbours (unsigned long index)
+{
     std::vector<Edge_Index> edges;
     edges.reserve(3 * (this->_aclFacetArray.size() - index));
 
@@ -1012,13 +1012,13 @@ void MeshKernel::RebuildNeighbours (unsigned long index)
         unsigned short side = rFace.Side(p0,p1);
         rFace._aulNeighbours[side] = ULONG_MAX;
     }
-}
-
-void MeshKernel::RebuildNeighbours (void)
-{
-    // complete rebuild
-    RebuildNeighbours(0);
-}
+}
+
+void MeshKernel::RebuildNeighbours (void)
+{
+    // complete rebuild
+    RebuildNeighbours(0);
+}
 
 // ----------------------------------------------------------------
 
@@ -1070,7 +1070,7 @@ bool MeshEigensystem::Evaluate()
     for (MeshPointArray::_TConstIterator it = aclPoints.begin(); it!=aclPoints.end(); ++it) {
         // u-Richtung
         clVect = *it - _cC;
-        clProj.ProjToLine(clVect, _cU);
+        clProj.ProjectToLine(clVect, _cU);
         clVect = clVect + clProj;
         fH = clVect.Length();
       
@@ -1083,7 +1083,7 @@ bool MeshEigensystem::Evaluate()
 
         // v-Richtung
         clVect = *it - _cC;
-        clProj.ProjToLine(clVect, _cV);
+        clProj.ProjectToLine(clVect, _cV);
         clVect = clVect + clProj;
         fH = clVect.Length();
   
@@ -1096,7 +1096,7 @@ bool MeshEigensystem::Evaluate()
 
         // w-Richtung
         clVect = *it - _cC;
-        clProj.ProjToLine(clVect, _cW);
+        clProj.ProjectToLine(clVect, _cW);
         clVect = clVect + clProj;
         fH = clVect.Length();
   
diff --git a/src/Mod/Mesh/App/Core/Projection.cpp b/src/Mod/Mesh/App/Core/Projection.cpp
index b55837fa3..1fe9a6195 100644
--- a/src/Mod/Mesh/App/Core/Projection.cpp
+++ b/src/Mod/Mesh/App/Core/Projection.cpp
@@ -303,7 +303,7 @@ bool MeshProjection::isPointInsideDistance (const Base::Vector3f& p1,
     // project point on line
     Base::Vector3f proj, dir(p2 - p1);
     Base::Vector3f move(pt - p1);
-    proj.ProjToLine(move, dir);
+    proj.ProjectToLine(move, dir);
     proj = pt + proj;
     return (((p1 - proj) * (p2 - proj)) < 0.0f);
 }
diff --git a/src/Mod/Part/App/Geometry.cpp b/src/Mod/Part/App/Geometry.cpp
index 3403698e9..c1d399921 100644
--- a/src/Mod/Part/App/Geometry.cpp
+++ b/src/Mod/Part/App/Geometry.cpp
@@ -3537,8 +3537,8 @@ bool findFilletCenter(const GeomLineSegment *lineSeg1, const GeomLineSegment *li
 
     // Just project the given reference points onto the lines, just in case they are not already lying on
     Base::Vector3d normPnt1, normPnt2;
-    normPnt1.ProjToLine(refPnt1-l1p1, l1p2-l1p1);
-    normPnt2.ProjToLine(refPnt2-l2p1, l2p2-l2p1);
+    normPnt1.ProjectToLine(refPnt1-l1p1, l1p2-l1p1);
+    normPnt2.ProjectToLine(refPnt2-l2p1, l2p2-l2p1);
     normPnt1 += refPnt1;
     normPnt2 += refPnt2;
 
@@ -3587,8 +3587,8 @@ double suggestFilletRadius(const GeomLineSegment *lineSeg1, const GeomLineSegmen
     Base::Vector3d dirBisect = (dir1.Normalize() + dir2.Normalize()).Normalize();
 
     Base::Vector3d projPnt1, projPnt2;
-    projPnt1.ProjToLine(refPnt1-corner, dir1);
-    projPnt2.ProjToLine(refPnt2-corner, dir2);
+    projPnt1.ProjectToLine(refPnt1-corner, dir1);
+    projPnt2.ProjectToLine(refPnt2-corner, dir2);
     projPnt1 += refPnt1;
     projPnt2 += refPnt2;
 
@@ -3617,8 +3617,8 @@ GeomArcOfCircle *createFilletGeometry(const GeomLineSegment *lineSeg1, const Geo
     Base::Vector3d dir2 = lineSeg2->getEndPoint() - lineSeg2->getStartPoint();
 
     Base::Vector3d radDir1, radDir2;
-    radDir1.ProjToLine(center - corner, dir1);
-    radDir2.ProjToLine(center - corner, dir2);
+    radDir1.ProjectToLine(center - corner, dir1);
+    radDir2.ProjectToLine(center - corner, dir2);
 
     // Angle Variables
     double startAngle, endAngle, range;
diff --git a/src/Mod/Part/Gui/ViewProviderMirror.cpp b/src/Mod/Part/Gui/ViewProviderMirror.cpp
index 6b47774cb..485c18441 100644
--- a/src/Mod/Part/Gui/ViewProviderMirror.cpp
+++ b/src/Mod/Part/Gui/ViewProviderMirror.cpp
@@ -89,7 +89,7 @@ bool ViewProviderMirror::setEdit(int ModNum)
         Base::Vector3d base = mf->Base.getValue();
         Base::Vector3d norm = mf->Normal.getValue();
         Base::Vector3d cent = bbox.GetCenter();
-        base = cent.ProjToPlane(base, norm);
+        base = cent.ProjectToPlane(base, norm);
 
         // setup the graph for editing the mirror plane
         SoTransform* trans = new SoTransform;
diff --git a/src/Mod/ReverseEngineering/App/ApproxSurface.cpp b/src/Mod/ReverseEngineering/App/ApproxSurface.cpp
index 0c71916aa..e3c595644 100644
--- a/src/Mod/ReverseEngineering/App/ApproxSurface.cpp
+++ b/src/Mod/ReverseEngineering/App/ApproxSurface.cpp
@@ -702,7 +702,7 @@ void ParameterCorrection::ProjectControlPointsOnPlane()
         for (unsigned k=0;k<_usVCtrlpoints;k++) {
             gp_Pnt pole = _vCtrlPntsOfSurf(j,k);
             Base::Vector3d pnt(pole.X(), pole.Y(), pole.Z());
-            pnt.ProjToPlane(base, _clW);
+            pnt.ProjectToPlane(base, _clW);
             pole.SetX(pnt.x);
             pole.SetY(pnt.y);
             pole.SetZ(pnt.z);
diff --git a/src/Mod/Sketcher/App/SketchObject.cpp b/src/Mod/Sketcher/App/SketchObject.cpp
index e02273659..a3b8983d7 100644
--- a/src/Mod/Sketcher/App/SketchObject.cpp
+++ b/src/Mod/Sketcher/App/SketchObject.cpp
@@ -962,8 +962,8 @@ int SketchObject::fillet(int GeoId1, int GeoId2,
                 delete arc;
                 return -1;
             }
-            dist1.ProjToLine(arc->getStartPoint(/*emulateCCW=*/true)-intersection, dir1);
-            dist2.ProjToLine(arc->getStartPoint(/*emulateCCW=*/true)-intersection, dir2);
+            dist1.ProjectToLine(arc->getStartPoint(/*emulateCCW=*/true)-intersection, dir1);
+            dist2.ProjectToLine(arc->getStartPoint(/*emulateCCW=*/true)-intersection, dir2);
             Part::Geometry *newgeo = dynamic_cast<Part::Geometry* >(arc);
             filletId = addGeometry(newgeo);
             if (filletId < 0) {
diff --git a/src/Mod/Sketcher/Gui/CommandCreateGeo.cpp b/src/Mod/Sketcher/Gui/CommandCreateGeo.cpp
index bd4c86c55..e68c7eb38 100644
--- a/src/Mod/Sketcher/Gui/CommandCreateGeo.cpp
+++ b/src/Mod/Sketcher/Gui/CommandCreateGeo.cpp
@@ -759,7 +759,7 @@ public:
                 EditCurve[EditCurve.size()-1] = onSketchPos;
                 if (TransitionMode == TRANSITION_MODE_Tangent) {
                     Base::Vector2D Tangent(dirVec.x,dirVec.y);
-                    EditCurve[1].ProjToLine(EditCurve[2] - EditCurve[0], Tangent);
+                    EditCurve[1].ProjectToLine(EditCurve[2] - EditCurve[0], Tangent);
                     if (EditCurve[1] * Tangent < 0) {
                         EditCurve[1] = EditCurve[2];
                         suppressTransition = true;
@@ -770,7 +770,7 @@ public:
                 else if (TransitionMode == TRANSITION_MODE_Perpendicular_L ||
                          TransitionMode == TRANSITION_MODE_Perpendicular_R) {
                     Base::Vector2D Perpendicular(-dirVec.y,dirVec.x);
-                    EditCurve[1].ProjToLine(EditCurve[2] - EditCurve[0], Perpendicular);
+                    EditCurve[1].ProjectToLine(EditCurve[2] - EditCurve[0], Perpendicular);
                     EditCurve[1] = EditCurve[0] + EditCurve[1];
                 }
 
@@ -2452,7 +2452,7 @@ private:
                 Base::Vector2D cursor = Base::Vector2D(onSketchPos - f); // vector from f to cursor pos
                 // decompose cursor with a projection, then length of w_2 will give us b
                 Base::Vector2D w_1 = cursor;
-                w_1.ProjToLine(cursor, (periapsis - apoapsis)); // projection of cursor line onto apse line
+                w_1.ProjectToLine(cursor, (periapsis - apoapsis)); // projection of cursor line onto apse line
                 Base::Vector2D w_2 = (cursor - w_1);
                 b = w_2.Length();
 
@@ -2512,7 +2512,7 @@ private:
                 Base::Vector2D cursor = Base::Vector2D(onSketchPos - centroid); // vector from centroid to cursor pos
                 // decompose cursor with a projection, then length of w_2 will give us b
                 Base::Vector2D w_1 = cursor;
-                w_1.ProjToLine(cursor, (fixedAxis - centroid)); // projection of cursor line onto fixed axis line
+                w_1.ProjectToLine(cursor, (fixedAxis - centroid)); // projection of cursor line onto fixed axis line
                 Base::Vector2D w_2 = (cursor - w_1);
                 if (w_2.Length() > fixedAxisLength) {
                     // b is fixed, we are seeking a
diff --git a/src/Mod/Sketcher/Gui/DrawSketchHandler.cpp b/src/Mod/Sketcher/Gui/DrawSketchHandler.cpp
index 302a64d6f..1d5fd4ac6 100644
--- a/src/Mod/Sketcher/Gui/DrawSketchHandler.cpp
+++ b/src/Mod/Sketcher/Gui/DrawSketchHandler.cpp
@@ -263,7 +263,7 @@ int DrawSketchHandler::seekAutoConstraint(std::vector<AutoConstraint> &suggested
                 continue;
 
             Base::Vector3d projPnt(0.f, 0.f, 0.f);
-            projPnt = projPnt.ProjToLine(center - tmpPos, tmpDir);
+            projPnt = projPnt.ProjectToLine(center - tmpPos, tmpDir);
             double projDist = std::abs(projPnt.Length() - radius);
 
             // Find if nearest
@@ -311,7 +311,7 @@ int DrawSketchHandler::seekAutoConstraint(std::vector<AutoConstraint> &suggested
                 continue;
 
             Base::Vector3d projPnt(0.f, 0.f, 0.f);
-            projPnt = projPnt.ProjToLine(center - tmpPos, tmpDir);
+            projPnt = projPnt.ProjectToLine(center - tmpPos, tmpDir);
             double projDist = std::abs(projPnt.Length() - radius);
 
             if (projDist < tangDeviation) {
diff --git a/src/Mod/Sketcher/Gui/ViewProviderSketch.cpp b/src/Mod/Sketcher/Gui/ViewProviderSketch.cpp
index 19c301e6d..a43698704 100644
--- a/src/Mod/Sketcher/Gui/ViewProviderSketch.cpp
+++ b/src/Mod/Sketcher/Gui/ViewProviderSketch.cpp
@@ -1204,7 +1204,7 @@ void ViewProviderSketch::moveConstraint(int constNum, const Base::Vector2D &toPo
                 Base::Vector3d l2p1 = lineSeg->getStartPoint();
                 Base::Vector3d l2p2 = lineSeg->getEndPoint();
                 // calculate the projection of p1 onto line2
-                p2.ProjToLine(p1-l2p1, l2p2-l2p1);
+                p2.ProjectToLine(p1-l2p1, l2p2-l2p1);
                 p2 += p1;
             } else
                 return;
@@ -3516,7 +3516,7 @@ Restart:
                                 Base::Vector3d l2p1 = lineSeg->getStartPoint();
                                 Base::Vector3d l2p2 = lineSeg->getEndPoint();
                                 // calculate the projection of p1 onto line2
-                                pnt2.ProjToLine(pnt1-l2p1, l2p2-l2p1);
+                                pnt2.ProjectToLine(pnt1-l2p1, l2p2-l2p1);
                                 pnt2 += pnt1;
                             } else
                                 break;
diff --git a/src/Mod/TechDraw/App/DrawViewSection.cpp b/src/Mod/TechDraw/App/DrawViewSection.cpp
index 313e2f210..3dd2aeb3c 100644
--- a/src/Mod/TechDraw/App/DrawViewSection.cpp
+++ b/src/Mod/TechDraw/App/DrawViewSection.cpp
@@ -164,7 +164,7 @@ App::DocumentObjectExecReturn *DrawViewSection::execute(void)
         // Project each bounding box point onto projection plane and find larges u,v values
 
         Base::Vector3d pnt = (*it);
-        pnt.ProjToPlane(plnPnt, plnNorm);
+        pnt.ProjectToPlane(plnPnt, plnNorm);
 
         uMax = std::max(uMax, std::abs(plnPnt[0] - pnt[0]));
         vMax = std::max(vMax, std::abs(plnPnt[1] - pnt[1]));
diff --git a/src/Mod/TechDraw/Gui/QGIViewDimension.cpp b/src/Mod/TechDraw/Gui/QGIViewDimension.cpp
index e84f24f59..426e09f55 100644
--- a/src/Mod/TechDraw/Gui/QGIViewDimension.cpp
+++ b/src/Mod/TechDraw/Gui/QGIViewDimension.cpp
@@ -1190,8 +1190,8 @@ void QGIViewDimension::draw()
 
                 Base::Vector3d avg = (norm1 + norm2) / 2.;
 
-                norm1 = norm1.ProjToLine(avg, norm1);
-                norm2 = norm2.ProjToLine(avg, norm2);
+                norm1 = norm1.ProjectToLine(avg, norm1);
+                norm2 = norm2.ProjectToLine(avg, norm2);
 
                 ar1->setPos(ar1Pos.x,ar1Pos.y );
                 ar2->setPos(ar2Pos.x,ar2Pos.y );