Implemented Fuselage Profile Type: Rectangle (Issue #909)

src/common/tiglcommonfunctions.cpp

@@ -42,6 +42,7 @@
 #include "CTiglRelativelyPositionedComponent.h"
 #include "CTiglProjectPointOnCurveAtAngle.h"
 #include "CTiglBSplineAlgorithms.h"
+#include "CTiglPointsToBSplineInterpolation.h"
 
 #include "Standard_Version.hxx"
 
@@ -119,6 +120,7 @@
 #include <ShapeAnalysis_FreeBounds.hxx>
 
 
+
 #include <list>
 #include <algorithm>
 #include <cassert>
@@ -127,6 +129,7 @@
 
 #include "Debugging.h"
 
+
 namespace
 {
     struct IsSame
@@ -1156,6 +1159,122 @@ TopoDS_Wire BuildWireFromEdges(const TopoDS_Shape& edges)
     return result;
 }
 
+opencascade::handle<Geom_BSplineCurve> ApproximateArcOfCircleToRationalBSpline(double radius, size_t nb_points, double uMin, double uMax, double y_position, double z_position)
+{
+    std::vector<gp_Pnt> arcPnts(nb_points);
+    std::vector<double> alpha = LinspaceWithBreaks(uMin, uMax, nb_points);
+    size_t index = 0;
+    for (double a : alpha){
+        arcPnts.at(index++) = (gp_Pnt(0., y_position + radius * std::cos(a), z_position + radius* std::sin(a)));
+            }
+    return tigl::CTiglPointsToBSplineInterpolation(arcPnts).Curve();
+}
+
+TopoDS_Wire BuildWireRectangle(const double heightToWidthRatio, const double cornerRadius, const double tol)
+{
+    int nb_points(0);
+
+    if(cornerRadius<0.||cornerRadius>0.5){
+        throw tigl::CTiglError("Invalid input for corner radius. Must be in range: 0 <= cornerRadius <= 0.5");
+    }
+
+    std::vector<Handle(Geom_BSplineCurve)> curves;
+
+    // build half upper line from gp_points
+    std::vector<gp_Pnt> linePntsUpperRightHalf;
+    linePntsUpperRightHalf.push_back(gp_Pnt(0.,0.,0.5*heightToWidthRatio));
+    linePntsUpperRightHalf.push_back(gp_Pnt(0.,0.5-cornerRadius,0.5*heightToWidthRatio));
+    opencascade::handle<Geom_BSplineCurve> lowerLineRightHalf = tigl::CTiglPointsToBSplineInterpolation(linePntsUpperRightHalf).Curve();
+    curves.push_back(lowerLineRightHalf);
+
+    if (!(cornerRadius == 0.0)){
+        //calculate the number of points required to maintain the minimum distance (<tol) between the bisector of two neighboring points on an arc circle
+        nb_points = std::round(M_PI/(acos(1-tol/cornerRadius)));
+        //build upper right arc
+        double y0 = 0.5 - cornerRadius;
+        double z0 = 0.5 * heightToWidthRatio - cornerRadius;
+        auto ArcCurve = ApproximateArcOfCircleToRationalBSpline(cornerRadius, nb_points, 0., M_PI/2., y0, z0);
+        ArcCurve->Reverse();
+        curves.push_back(ArcCurve);
+    }
+
+    // build right line from gp_Pnts
+    std::vector<gp_Pnt> linePnts_right;
+    linePnts_right.push_back(gp_Pnt(0., 0.5, 0.5 * heightToWidthRatio - cornerRadius));
+    linePnts_right.push_back(gp_Pnt(0., 0.5, -0.5 * heightToWidthRatio + cornerRadius));
+    opencascade::handle<Geom_BSplineCurve> rightLine = tigl::CTiglPointsToBSplineInterpolation(linePnts_right).Curve();
+    curves.push_back(rightLine);
+
+    if (!(cornerRadius == 0.0)){
+        //build lower right arc
+        double y0 = 0.5 - cornerRadius;
+        double z0 = - 0.5 * heightToWidthRatio + cornerRadius;
+        auto ArcCurve = ApproximateArcOfCircleToRationalBSpline(cornerRadius, nb_points, M_PI*(3./2.), M_PI*2., y0, z0);
+        ArcCurve->Reverse();
+        curves.push_back(ArcCurve);
+    }
+
+    // build lower line from gp_points
+    std::vector<gp_Pnt> linePnts_lower;
+    linePnts_lower.push_back(gp_Pnt(0.,(0.5-cornerRadius),-0.5*heightToWidthRatio));
+    linePnts_lower.push_back(gp_Pnt(0.,(-0.5+cornerRadius),-0.5*heightToWidthRatio));
+    opencascade::handle<Geom_BSplineCurve> lowerLine = tigl::CTiglPointsToBSplineInterpolation(linePnts_lower).Curve();
+
+    curves.push_back(lowerLine);
+
+    if (!(cornerRadius == 0.)){
+        // build lower left arc
+        double y0 = - 0.5 + cornerRadius;
+        double z0 = -0.5 * heightToWidthRatio + cornerRadius;
+        auto ArcCurve = ApproximateArcOfCircleToRationalBSpline(cornerRadius, nb_points, M_PI, M_PI*(3./2.), y0, z0);
+        ArcCurve->Reverse();
+        curves.push_back(ArcCurve);
+    }
+
+    //build left line from gp_points
+    std::vector<gp_Pnt> linePnts_left;
+    linePnts_left.push_back(gp_Pnt(0.,-0.5,-0.5 * heightToWidthRatio + cornerRadius));
+    linePnts_left.push_back(gp_Pnt(0.,-0.5,0.5 * heightToWidthRatio - cornerRadius));
+    opencascade::handle<Geom_BSplineCurve> leftLine = tigl::CTiglPointsToBSplineInterpolation(linePnts_left).Curve();
+    curves.push_back(leftLine);
+
+    if (!(cornerRadius == 0.)) {
+        // build upper left arc
+        double y0 = - 0.5 + cornerRadius;
+        double z0 = 0.5 * heightToWidthRatio - cornerRadius;
+        auto ArcCurve = ApproximateArcOfCircleToRationalBSpline(cornerRadius, nb_points, M_PI/2., M_PI, y0, z0);
+        ArcCurve->Reverse();
+        curves.push_back(ArcCurve);
+    }
+
+    // build half upper line from gp_points
+    std::vector<gp_Pnt> linePntsUpperLeftHalf;
+    linePntsUpperLeftHalf.push_back(gp_Pnt(0.,-(0.5-cornerRadius),0.5*heightToWidthRatio));
+    linePntsUpperLeftHalf.push_back(gp_Pnt(0.,0.,0.5*heightToWidthRatio));
+    opencascade::handle<Geom_BSplineCurve> upperLineLeftHalf = tigl::CTiglPointsToBSplineInterpolation(linePntsUpperLeftHalf).Curve();
+    curves.push_back(upperLineLeftHalf);
+
+    opencascade::handle<Geom_BSplineCurve> curve = tigl::CTiglBSplineAlgorithms::concatCurves(curves);
+
+    // workaround for lofting algorithm not working with  curves of degree '1' (i.e. concatenated lines)
+    // if guide curves are involved, the lofter doesn't generate a valid geometry without thowing an error
+    // This only occurs if the cornerRadius is zero and the profile is a rectangle, which in theory could
+    // just have degree 1.
+    if (curve->Degree()<2){
+        curve->IncreaseDegree(2);
+    }
+
+    TopoDS_Wire wire;
+    if(!curve.IsNull())
+        {
+        wire = BuildWireFromEdges(BRepBuilderAPI_MakeEdge(curve).Edge());
+    }
+    if(wire.IsNull()){
+        throw tigl::CTiglError("Error building profile wire");
+    }
+    return wire;
+}
+
 void BuildWiresFromConnectedEdges(const TopoDS_Shape& shape, TopTools_ListOfShape& wireList)
 {
     // get list of edges from passed shape

src/common/tiglcommonfunctions.h

@@ -46,6 +46,8 @@
 #include <algorithm>
 #include "UniquePtr.h"
 
+
+
 typedef std::map<std::string, PNamedShape> ShapeMap;
 
 // helper function for std::find
@@ -269,6 +271,31 @@ TIGL_EXPORT TopoDS_Wire BuildWire(const gp_Pnt& p1, const gp_Pnt& p2);
 // Method for building a wire out of the edges from the passed geometry
 TIGL_EXPORT TopoDS_Wire BuildWireFromEdges(const TopoDS_Shape& edges);
 
+/**
+ * @brief ApproximateArcOfCircleToRationalBSpline
+ * The result of this function is a non-rational B-Spline curve that approximates an arc of circle in the y-z plane. Its center is given by the y- and z-position.
+ * The angle is given in rad.
+ * The direction of rotation is counter-clockwise, starting with alpha=0 on the positive y-axis,  with z=0.
+ * @param cornerRadius    Radius of the circle
+ * @param nb_points Number of points used for interpolation
+ * @param uMin      Starting parameter in rad. Range: [0,2*Pi]
+ * @param uMax
+ * @param y_position
+ * @param z_position
+ * @return opencascade::handle<Geom_BSplineCurve>
+ */
+TIGL_EXPORT opencascade::handle<Geom_BSplineCurve> ApproximateArcOfCircleToRationalBSpline(double cornerRadius, size_t nb_points, double uMin = 0, double uMax = M_PI/4 ,
+                                                                                           double y_position = 0., double z_position = 0.);
+
+/**
+ * @brief BuildWireRectangle Builds a rectangular wire in (y,z) - plane with width 1, center of coordinate system is the center of the rectangle
+ * @param heightToWidthRatio
+ * @param cornerRadius
+ * @param tol
+ * @return
+ */
+TIGL_EXPORT TopoDS_Wire BuildWireRectangle(const double heightToWidthRatio, const double cornerRadius =0.0, const double tol= 1e-3);
+
 // Returns a list of wires built from all connected edges in the passed shape
 TIGL_EXPORT void BuildWiresFromConnectedEdges(const TopoDS_Shape& shape, TopTools_ListOfShape& wireList);
 
@@ -358,7 +385,7 @@ TIGL_EXPORT double NormalizeAngleDeg(double angleDeg);
 // Creates a linear spaces array but with some additional breaking points
 // If the breaking points are very close to a point, the point will be replaced
 // Else, the breaking point will be inserted
-TIGL_EXPORT std::vector<double> LinspaceWithBreaks(double umin, double umax, size_t n_values, const std::vector<double>& breaks);
+TIGL_EXPORT std::vector<double> LinspaceWithBreaks(double umin, double umax, size_t n_values, const std::vector<double>& breaks = {});
 
 // Transforms a shape accourding to the given coordinate transformation
 TIGL_EXPORT TopoDS_Shape TransformedShape(const tigl::CTiglTransformation& transformationToGlobal, TiglCoordinateSystem cs, const TopoDS_Shape& shape);