removed gp_* conversion code from TechDraw workbench

removed toVecto3d method from DrawUtil.h
removed duplicate template specialization
removed duplicated header inclusion
removed a comment block

Author: captain0xff

src/Mod/TechDraw/App/CenterLine.cpp

@@ -32,6 +32,7 @@
 #include <BRepTools.hxx>
 
 #include <Base/Console.h>
+#include <Base/Converter.h>
 
 #include "CenterLine.h"
 #include "DrawUtil.h"
@@ -320,8 +321,8 @@ TechDraw::BaseGeomPtr CenterLine::scaledAndRotatedGeometry(TechDraw::DrawViewPar
 
     TopoDS_Edge newEdge;
     if (getType() == Type::FACE ) {
-        gp_Pnt gp1(DU::to<gp_Pnt>(p1));
-        gp_Pnt gp2(DU::to<gp_Pnt>(p2));
+        gp_Pnt gp1(Base::convertTo<gp_Pnt>(p1));
+        gp_Pnt gp2(Base::convertTo<gp_Pnt>(p2));
         TopoDS_Edge e = BRepBuilderAPI_MakeEdge(gp1, gp2);
         // Mirror shape in Y and scale
         TopoDS_Shape s = ShapeUtils::mirrorShape(e, gp_Pnt(0.0, 0.0, 0.0), scale);
@@ -330,8 +331,8 @@ TechDraw::BaseGeomPtr CenterLine::scaledAndRotatedGeometry(TechDraw::DrawViewPar
         newEdge = TopoDS::Edge(s);
     } else if (getType() == Type::EDGE  ||
                getType() == Type::VERTEX) {
-        gp_Pnt gp1(DU::to<gp_Pnt>(DU::invertY(p1 * scale)));
-        gp_Pnt gp2(DU::to<gp_Pnt>(DU::invertY(p2 * scale)));
+        gp_Pnt gp1(Base::convertTo<gp_Pnt>(DU::invertY(p1 * scale)));
+        gp_Pnt gp2(Base::convertTo<gp_Pnt>(DU::invertY(p2 * scale)));
         newEdge = BRepBuilderAPI_MakeEdge(gp1, gp2);
     }
 

src/Mod/TechDraw/App/Cosmetic.cpp

@@ -27,6 +27,7 @@
 #endif
 
 #include <App/Application.h>
+#include <Base/Converter.h>
 #include <Base/Vector3D.h>
 #include <Mod/TechDraw/App/CosmeticEdgePy.h>
 #include <Mod/TechDraw/App/GeomFormatPy.h>
@@ -160,17 +161,17 @@ TechDraw::BaseGeomPtr CosmeticEdge::makeCanonicalLine(DrawViewPart* dvp, Base::V
 {
     Base::Vector3d cStart = CosmeticVertex::makeCanonicalPoint(dvp, start);
     Base::Vector3d cEnd   = CosmeticVertex::makeCanonicalPoint(dvp, end);
-    gp_Pnt gStart  = DU::to<gp_Pnt>(cStart);
-    gp_Pnt gEnd    = DU::to<gp_Pnt>(cEnd);
+    gp_Pnt gStart  = Base::convertTo<gp_Pnt>(cStart);
+    gp_Pnt gEnd    = Base::convertTo<gp_Pnt>(cEnd);
     TopoDS_Edge edge = BRepBuilderAPI_MakeEdge(gStart, gEnd);
     return TechDraw::BaseGeom::baseFactory(edge);
 }
 
 //! makes an unscaled, unrotated line from two canonical points.
 TechDraw::BaseGeomPtr CosmeticEdge::makeLineFromCanonicalPoints(Base::Vector3d start, Base::Vector3d end)
 {
-    gp_Pnt gStart  = DU::to<gp_Pnt>(start);
-    gp_Pnt gEnd    = DU::to<gp_Pnt>(end);
+    gp_Pnt gStart  = Base::convertTo<gp_Pnt>(start);
+    gp_Pnt gEnd    = Base::convertTo<gp_Pnt>(end);
     TopoDS_Edge edge = BRepBuilderAPI_MakeEdge(gStart, gEnd);
     return TechDraw::BaseGeom::baseFactory(edge);
 }

src/Mod/TechDraw/App/DimensionGeometry.cpp

@@ -28,6 +28,7 @@
 #endif
 
 #include <Base/Console.h>
+#include <Base/Converter.h>
 #include <Base/Tools.h>
 
 #include "DimensionGeometry.h"
@@ -97,10 +98,10 @@ void pointPair::mapToPage(const DrawViewPart* dvp)
     gp_Ax3 OXYZ;
     xOXYZ.SetTransformation(OXYZ, gp_Ax3(dvp->getRotatedCS()));
 
-    gp_Vec gvFirst = DU::to<gp_Vec>(m_first).Transformed(xOXYZ);
-    m_first = DU::toVector3d(gvFirst);
-    gp_Vec gvSecond = DU::to<gp_Vec>(m_second).Transformed(xOXYZ);
-    m_second = DU::toVector3d(gvSecond);
+    gp_Vec gvFirst = Base::convertTo<gp_Vec>(m_first).Transformed(xOXYZ);
+    m_first = Base::convertTo<Base::Vector3d>(gvFirst);
+    gp_Vec gvSecond = Base::convertTo<gp_Vec>(m_second).Transformed(xOXYZ);
+    m_second = Base::convertTo<Base::Vector3d>(gvSecond);
 }
 
 // this routine is no longer needed since we now use the dvp's projectPoint
@@ -194,8 +195,8 @@ void anglePoints::mapToPage(const DrawViewPart* dvp)
     gp_Trsf xOXYZ;
     gp_Ax3 OXYZ;
     xOXYZ.SetTransformation(OXYZ, gp_Ax3(dvp->getRotatedCS()));
-    gp_Vec gvVertex = DU::to<gp_Vec>(m_vertex).Transformed(xOXYZ);
-    m_vertex = DU::toVector3d(gvVertex);
+    gp_Vec gvVertex = Base::convertTo<gp_Vec>(m_vertex).Transformed(xOXYZ);
+    m_vertex = Base::convertTo<Base::Vector3d>(gvVertex);
 }
 
 // map the points onto the coordinate system used for drawing where -Y direction is "up"
@@ -291,18 +292,18 @@ void arcPoints::mapToPage(const DrawViewPart* dvp)
     gp_Ax3 OXYZ;
     xOXYZ.SetTransformation(OXYZ, gp_Ax3(dvp->getRotatedCS()));
 
-    gp_Vec gvCenter = DU::to<gp_Vec>(center).Transformed(xOXYZ);
-    center = DU::toVector3d(gvCenter);
-    gp_Vec gvOnCurve1 = DU::to<gp_Vec>(onCurve.first()).Transformed(xOXYZ);
-    onCurve.first(DU::toVector3d(gvOnCurve1));
-    gp_Vec gvOnCurve2 = DU::to<gp_Vec>(onCurve.second()).Transformed(xOXYZ);
-    onCurve.second(DU::toVector3d(gvOnCurve2));
-    gp_Vec gvArcEnds1 = DU::to<gp_Vec>(arcEnds.first()).Transformed(xOXYZ);
-    arcEnds.first(DU::toVector3d(gvArcEnds1));
-    gp_Vec gvArcEnds2 = DU::to<gp_Vec>(arcEnds.second()).Transformed(xOXYZ);
-    arcEnds.second(DU::toVector3d(gvArcEnds2));
-    gp_Vec gvMidArc = DU::to<gp_Vec>(midArc).Transformed(xOXYZ);
-    midArc = DU::toVector3d(gvMidArc);
+    gp_Vec gvCenter = Base::convertTo<gp_Vec>(center).Transformed(xOXYZ);
+    center = Base::convertTo<Base::Vector3d>(gvCenter);
+    gp_Vec gvOnCurve1 = Base::convertTo<gp_Vec>(onCurve.first()).Transformed(xOXYZ);
+    onCurve.first(Base::convertTo<Base::Vector3d>(gvOnCurve1));
+    gp_Vec gvOnCurve2 = Base::convertTo<gp_Vec>(onCurve.second()).Transformed(xOXYZ);
+    onCurve.second(Base::convertTo<Base::Vector3d>(gvOnCurve2));
+    gp_Vec gvArcEnds1 = Base::convertTo<gp_Vec>(arcEnds.first()).Transformed(xOXYZ);
+    arcEnds.first(Base::convertTo<Base::Vector3d>(gvArcEnds1));
+    gp_Vec gvArcEnds2 = Base::convertTo<gp_Vec>(arcEnds.second()).Transformed(xOXYZ);
+    arcEnds.second(Base::convertTo<Base::Vector3d>(gvArcEnds2));
+    gp_Vec gvMidArc = Base::convertTo<gp_Vec>(midArc).Transformed(xOXYZ);
+    midArc = Base::convertTo<Base::Vector3d>(gvMidArc);
 }
 
 // obsolete. see above

src/Mod/TechDraw/App/DrawBrokenView.cpp

@@ -73,6 +73,7 @@
 #include <App/Document.h>
 #include <Base/BoundBox.h>
 #include <Base/Console.h>
+#include <Base/Converter.h>
 #include <Base/FileInfo.h>
 #include <Base/Parameter.h>
 
@@ -244,7 +245,7 @@ TopoDS_Shape  DrawBrokenView::compressHorizontal(const TopoDS_Shape& shapeToComp
 {
     auto pieces = getPieces(shapeToCompress);
     auto breaksAll = Breaks.getValues();
-    auto moveDirection = DU::closestBasisOriented(DU::toVector3d(getProjectionCS().XDirection()));
+    auto moveDirection = DU::closestBasisOriented(Base::convertTo<Base::Vector3d>(getProjectionCS().XDirection()));
     bool descend = false;
     auto sortedBreaks = makeSortedBreakList(breaksAll, moveDirection, descend);
     auto limits = getPieceLimits(pieces, moveDirection);
@@ -283,7 +284,7 @@ TopoDS_Shape  DrawBrokenView::compressVertical(const TopoDS_Shape& shapeToCompre
     auto pieces = getPieces(shapeToCompress);
     auto breaksAll = Breaks.getValues();
     // not sure about using closestBasis here. may prevent oblique breaks later.
-    auto moveDirection = DU::closestBasisOriented(DU::toVector3d(getProjectionCS().YDirection()));
+    auto moveDirection = DU::closestBasisOriented(Base::convertTo<Base::Vector3d>(getProjectionCS().YDirection()));
 
     bool descend = false;
     auto sortedBreaks = makeSortedBreakList(breaksAll, moveDirection, descend);
@@ -323,11 +324,11 @@ TopoDS_Shape DrawBrokenView::makeHalfSpace(const Base::Vector3d& planePoint,
                                            const Base::Vector3d& planeNormal,
                                            const Base::Vector3d& pointInSpace) const
 {
-    auto origin = DU::to<gp_Pnt>(planePoint);
-    auto axis   = DU::to<gp_Dir>(planeNormal);
+    auto origin = Base::convertTo<gp_Pnt>(planePoint);
+    auto axis   = Base::convertTo<gp_Dir>(planeNormal);
     gp_Pln plane(origin, axis);
     BRepBuilderAPI_MakeFace mkFace(plane);
-    BRepPrimAPI_MakeHalfSpace mkHalf(mkFace.Face(), DU::to<gp_Pnt>(pointInSpace));
+    BRepPrimAPI_MakeHalfSpace mkHalf(mkFace.Face(), Base::convertTo<gp_Pnt>(pointInSpace));
 
     return mkHalf.Solid();
 }
@@ -478,7 +479,7 @@ std::pair<Base::Vector3d, Base::Vector3d> DrawBrokenView::breakPointsFromEdge(co
     TopoDS_Edge edge = TopoDS::Edge(locShape);
     gp_Pnt start = BRep_Tool::Pnt(TopExp::FirstVertex(edge));
     gp_Pnt end = BRep_Tool::Pnt(TopExp::LastVertex(edge));
-    return {DU::toVector3d(start), DU::toVector3d(end)};
+    return {Base::convertTo<Base::Vector3d>(start), Base::convertTo<Base::Vector3d>(end)};
 }
 
 
@@ -641,7 +642,7 @@ bool DrawBrokenView::isVertical(const TopoDS_Edge& edge, const bool projected) c
     auto edgeDir = ends.second - ends.first;
     edgeDir.Normalize();
 
-    auto upDir = DU::toVector3d(getProjectionCS().YDirection());
+    auto upDir = Base::convertTo<Base::Vector3d>(getProjectionCS().YDirection());
     if (projected) {
         upDir = stdY;
     }
@@ -657,7 +658,7 @@ bool DrawBrokenView::isVertical(std::pair<Base::Vector3d, Base::Vector3d> inPoin
     auto pointDir = inPoints.second - inPoints.first;
     pointDir.Normalize();
 
-    auto upDir = DU::toVector3d(getProjectionCS().YDirection());
+    auto upDir = Base::convertTo<Base::Vector3d>(getProjectionCS().YDirection());
     if (projected) {
         upDir = stdY;
     }
@@ -673,7 +674,7 @@ bool DrawBrokenView::isHorizontal(const TopoDS_Edge& edge, bool projected) const
     auto edgeDir = ends.second - ends.first;
     edgeDir.Normalize();
 
-    auto sideDir = DU::toVector3d(getProjectionCS().XDirection());
+    auto sideDir = Base::convertTo<Base::Vector3d>(getProjectionCS().XDirection());
     if (projected) {
         sideDir = stdX;
     }
@@ -876,7 +877,7 @@ Base::Vector3d DrawBrokenView::mapPoint3dToView(Base::Vector3d point3d) const
 
     auto breaksAll = Breaks.getValues();
     bool descend = false;
-    auto moveXDirection = DU::closestBasisOriented(DU::toVector3d(getProjectionCS().XDirection()));
+    auto moveXDirection = DU::closestBasisOriented(Base::convertTo<Base::Vector3d>(getProjectionCS().XDirection()));
 
     // get the breaks that move us in X
     auto sortedXBreaks = makeSortedBreakList(breaksAll, moveXDirection, descend);
@@ -885,7 +886,7 @@ Base::Vector3d DrawBrokenView::mapPoint3dToView(Base::Vector3d point3d) const
     double xShift = shiftAmountShrink(xLimit, moveXDirection, sortedXBreaks);
     Base::Vector3d xMove = moveXDirection * xShift;    // move to the right (+X)
 
-    auto moveYDirection = DU::closestBasisOriented(DU::toVector3d(getProjectionCS().YDirection()));
+    auto moveYDirection = DU::closestBasisOriented(Base::convertTo<Base::Vector3d>(getProjectionCS().YDirection()));
     descend = false;
     // get the breaks that move us in Y
     auto sortedYBreaks = makeSortedBreakList(breaksAll, moveYDirection, descend);
@@ -913,12 +914,12 @@ Base::Vector3d DrawBrokenView::mapPoint2dFromView(Base::Vector3d point2d) const
     gp_Ax3 projCS3(getProjectionCS(getCompressedCentroid()));
     gp_Trsf xTo3d;
     xTo3d.SetTransformation(projCS3, OXYZ);
-    auto pseudo3d = DU::toVector3d(DU::to<gp_Pnt>(point2d).Transformed(xTo3d));
+    auto pseudo3d = Base::convertTo<Base::Vector3d>(Base::convertTo<gp_Pnt>(point2d).Transformed(xTo3d));
 
     // now shift down and left
     auto breaksAll = Breaks.getValues();
 
-    auto moveXDirection = DU::closestBasisOriented(DU::toVector3d(getProjectionCS().XDirection()));
+    auto moveXDirection = DU::closestBasisOriented(Base::convertTo<Base::Vector3d>(getProjectionCS().XDirection()));
     // we are expanding, so the direction should be to the "left"/"down" which is the opposite of
     // our XDirection
     auto moveXReverser = isDirectionReversed(moveXDirection) ? 1.0 : -1.0;
@@ -941,7 +942,7 @@ Base::Vector3d DrawBrokenView::mapPoint2dFromView(Base::Vector3d point2d) const
     }
     double xCoord2 = xLimit + breakSum * moveXReverser;
 
-    auto moveYDirection = DU::closestBasisOriented(DU::toVector3d(getProjectionCS().YDirection()));
+    auto moveYDirection = DU::closestBasisOriented(Base::convertTo<Base::Vector3d>(getProjectionCS().YDirection()));
     auto moveYReverser = isDirectionReversed(moveYDirection) ? 1.0 : -1.0;
     descend = false;
     auto sortedYBreaks = makeSortedBreakList(breaksAll, moveYDirection, descend);
@@ -1102,18 +1103,18 @@ Base::Vector3d DrawBrokenView::getCompressedCentroid() const
     }
     gp_Ax2 cs = getProjectionCS();
     gp_Pnt gCenter = ShapeUtils::findCentroid(m_compressedShape, cs);
-    return DU::toVector3d(gCenter);
+    return Base::convertTo<Base::Vector3d>(gCenter);
 }
 
 //! construct a perpendicular direction in the projection CS
 Base::Vector3d  DrawBrokenView::makePerpendicular(Base::Vector3d inDir) const
 {
-    auto gDir = DU::to<gp_Dir>(inDir);
+    auto gDir = Base::convertTo<gp_Dir>(inDir);
     gp_Pnt origin(0.0, 0.0, 0.0);
     auto dir = getProjectionCS().Direction();
     gp_Ax1 axis(origin, dir);
     auto gRotated = gDir.Rotated(axis,  M_PI_2);
-    return DU::toVector3d(gRotated);
+    return Base::convertTo<Base::Vector3d>(gRotated);
 }
 
 //! true if this piece should be moved

src/Mod/TechDraw/App/DrawComplexSection.cpp

@@ -110,6 +110,7 @@
 #include <App/Material.h>
 #include <Base/BoundBox.h>
 #include <Base/Console.h>
+#include <Base/Converter.h>
 #include <Base/Exception.h>
 #include <Base/FileInfo.h>
 #include <Base/Interpreter.h>
@@ -550,7 +551,7 @@ void DrawComplexSection::makeAlignedPieces(const TopoDS_Shape& rawShape)
     }
 
     //center the compound along SectionCS XDirection
-    Base::Vector3d centerVector = DU::toVector3d(gMovementVector) * distanceToMove / -2.0;
+    Base::Vector3d centerVector = Base::convertTo<Base::Vector3d>(gMovementVector) * distanceToMove / -2.0;
     TopoDS_Shape centeredCompound = ShapeUtils::moveShape(comp, centerVector);
 
     if (debugSection()) {
@@ -796,7 +797,7 @@ std::pair<Base::Vector3d, Base::Vector3d> DrawComplexSection::sectionArrowDirs()
     }
 
     gp_Vec gProfileVector = makeProfileVector(profileWire);
-    gp_Vec gSectionNormal = gp_Vec(DU::to<gp_Dir>(SectionNormal.getValue()));
+    gp_Vec gSectionNormal = gp_Vec(Base::convertTo<gp_Dir>(SectionNormal.getValue()));
     gp_Vec gExtrudeVector = (gSectionNormal.Crossed(gProfileVector)).Normalized();
     Base::Vector3d vClosestBasis = DrawUtil::closestBasis(gp_Dir(gExtrudeVector), getSectionCS());
     gp_Dir gExtrudeDir = gp_Dir(vClosestBasis.x, vClosestBasis.y, vClosestBasis.z);
@@ -826,8 +827,8 @@ std::pair<Base::Vector3d, Base::Vector3d> DrawComplexSection::sectionArrowDirs()
     }
 
     //TODO: similar code elsewhere. Opportunity for reuse.
-    Base::Vector3d vDir0 = DU::toVector3d(gDir0);
-    Base::Vector3d vDir1 = DU::toVector3d(gDir1);
+    Base::Vector3d vDir0 = Base::convertTo<Base::Vector3d>(gDir0);
+    Base::Vector3d vDir1 = Base::convertTo<Base::Vector3d>(gDir1);
     vDir0.Normalize();
     vDir1.Normalize();
     DrawViewPart* baseDvp = dynamic_cast<DrawViewPart*>(BaseView.getValue());
@@ -981,8 +982,8 @@ std::pair<Base::Vector3d, Base::Vector3d> DrawComplexSection::getSegmentEnds(Top
     gp_Pnt gpFirst = BRep_Tool::Pnt(tvFirst);
     gp_Pnt gpLast = BRep_Tool::Pnt(tvLast);
     std::pair<Base::Vector3d, Base::Vector3d> result;
-    result.first = DU::toVector3d(gpFirst);
-    result.second = DU::toVector3d(gpLast);
+    result.first = Base::convertTo<Base::Vector3d>(gpFirst);
+    result.second = Base::convertTo<Base::Vector3d>(gpLast);
     return result;
 }
 

src/Mod/TechDraw/App/DrawGeomHatch.cpp

@@ -49,6 +49,7 @@
 #include <App/Application.h>
 #include <App/Document.h>
 #include <Base/Console.h>
+#include <Base/Converter.h>
 #include <Base/FileInfo.h>
 #include <Base/Parameter.h>
 
@@ -336,7 +337,7 @@ std::vector<LineSet> DrawGeomHatch::getTrimmedLines(DrawViewPart* source,
 
         TopoDS_Shape grid = gridComp;
         gp_Trsf xGridTranslate;
-        xGridTranslate.SetTranslation(DrawUtil::to<gp_Vec>(hatchOffset));
+        xGridTranslate.SetTranslation(Base::convertTo<gp_Vec>(hatchOffset));
         BRepBuilderAPI_Transform mkTransTranslate(grid, xGridTranslate, true);
         grid = mkTransTranslate.Shape();
 

src/Mod/TechDraw/App/DrawUtil.cpp

@@ -58,6 +58,7 @@
 #endif
 
 #include <Base/Console.h>
+#include <Base/Converter.h>
 #include <Base/FileInfo.h>
 #include <Base/Parameter.h>
 #include <Base/Stream.h>
@@ -414,7 +415,7 @@ bool DrawUtil::apparentIntersection(const Handle(Geom_Curve) curve1,
     //for our purposes, only one intersection point is required.
     gp_Pnt p1, p2;
     intersector.Points(1, p1, p2);
-    result = toVector3d(p1);
+    result = Base::convertTo<Base::Vector3d>(p1);
     return true;
 }
 
@@ -520,6 +521,15 @@ std::string DrawUtil::formatVector(const Base::Vector3d& v)
 }
 //template std::string DrawUtil::formatVector<Base::Vector3d>(const Base::Vector3d &v);
 
+// template specialization
+std::string DrawUtil::formatVector(const QPointF& v)
+{
+    std::stringstream builder;
+    builder << std::fixed << std::setprecision(Base::UnitsApi::getDecimals());
+    builder << " (" << v.x() << ", " << v.y() << ") ";
+    return builder.str();
+}
+
 //! compare 2 vectors for sorting - true if v1 < v2
 //! precision::Confusion() is too strict for vertex - vertex comparisons
 bool DrawUtil::vectorLess(const Base::Vector3d& v1, const Base::Vector3d& v2)
@@ -648,7 +658,7 @@ Base::Vector3d DrawUtil::vecRotate(Base::Vector3d vec, double angle, Base::Vecto
 
 gp_Vec DrawUtil::closestBasis(gp_Vec inVec)
 {
-    return gp_Vec(to<gp_Dir>(closestBasis(toVector3d(inVec))));
+    return gp_Vec(Base::convertTo<gp_Dir>(closestBasis(Base::convertTo<Base::Vector3d>(inVec))));
 }
 
 //! returns stdX, stdY or stdZ.
@@ -836,7 +846,7 @@ double DrawUtil::getWidthInDirection(gp_Dir direction, TopoDS_Shape& shape)
     Base::Vector3d stdXr(-1.0, 0.0, 0.0);
     Base::Vector3d stdYr(0.0, -1.0, 0.0);
     Base::Vector3d stdZr(0.0, 0.0, -1.0);
-    Base::Vector3d vClosestBasis = closestBasis(toVector3d(direction));
+    Base::Vector3d vClosestBasis = closestBasis(Base::convertTo<Base::Vector3d>(direction));
 
     Bnd_Box shapeBox;
     shapeBox.SetGap(0.0);
@@ -888,7 +898,7 @@ gp_Vec DrawUtil::maskDirection(gp_Vec inVec, gp_Dir directionToMask)
 
 Base::Vector3d DrawUtil::maskDirection(Base::Vector3d inVec, Base::Vector3d directionToMask)
 {
-    return toVector3d(maskDirection(to<gp_Vec>(inVec), to<gp_Vec>(directionToMask)));
+    return Base::convertTo<Base::Vector3d>(maskDirection(Base::convertTo<gp_Vec>(inVec), Base::convertTo<gp_Vec>(directionToMask)));
 }
 
 //! get the coordinate of inPoint for the cardinal unit direction.