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,13 +120,16 @@
 #include <ShapeAnalysis_FreeBounds.hxx>
 
 
+
 #include <list>
 #include <algorithm>
 #include <cassert>
 #include <limits>
 #include <cmath>
 
 #include "Debugging.h"
+#include <GC_MakeArcOfCircle.hxx>
+
 
 namespace
 {
@@ -1156,6 +1160,125 @@ TopoDS_Wire BuildWireFromEdges(const TopoDS_Shape& edges)
     return result;
 }
 
+opencascade::handle<Geom_BSplineCurve> ApproximateArcOfCircleToRationalBSpline(double radius, double uMin, double uMax,double y_position, double z_position)
+{
+    std::vector<gp_Pnt> ArcPnts;
+    std::vector<double> alpha = Linspace(uMin, uMax, 64);
+    for (double a : alpha){
+        ArcPnts.push_back(gp_Pnt(0., y_position + radius * std::cos(a), z_position + radius* std::sin(a)));
+            }
+    return tigl::CTiglPointsToBSplineInterpolation(ArcPnts).Curve();
+}
+
+
+//gp_Pnt startUpper(0., (-0.5 + radius), 0.5 * heightToWidthRatio);
+//gp_Pnt endUpper(0., (0.5 - radius), 0.5 * heightToWidthRatio);
+//gp_Pnt startRight(0., 0.5, 0.5 * heightToWidthRatio - radius);
+//gp_Pnt endRight(0., 0.5, -0.5 * heightToWidthRatio + radius);
+//gp_Pnt startLower(0., (0.5 - radius), -0.5 * heightToWidthRatio);
+//gp_Pnt endLower(0., (-0.5 + radius), -0.5 * heightToWidthRatio);
+//gp_Pnt startLeft(0., -0.5, -0.5 * heightToWidthRatio + radius);
+//gp_Pnt endLeft(0., -0.5, 0.5 * heightToWidthRatio - radius);
+
+TopoDS_Wire BuildWireRectangle(const double& heightToWidthRatio, const double& cornerRadius)
+{
+    double radius = cornerRadius;
+    if(cornerRadius<0.){
+        radius*= -1;
+    }
+    std::vector<Handle(Geom_BSplineCurve)> curves;
+
+    // build half upper line from gp_points
+    std::vector<gp_Pnt> linePntsUpperRightHalf;
+    std::vector<double> y_UpperRightHalf = Linspace(0.,(0.5-radius),5);
+    for (double y: y_UpperRightHalf){
+        linePntsUpperRightHalf.push_back(gp_Pnt(0., y, 0.5 * heightToWidthRatio));
+    }
+    opencascade::handle<Geom_BSplineCurve> lowerLineRightHalf = tigl::CTiglPointsToBSplineInterpolation(linePntsUpperRightHalf).Curve();
+    curves.push_back(lowerLineRightHalf);
+
+    if (!(cornerRadius == 0.0)){
+        //build upper right arc
+        double y0 = 0.5 - radius;
+        double z0 = 0.5 * heightToWidthRatio - radius;
+        auto ArcCurve = ApproximateArcOfCircleToRationalBSpline(radius, 0., M_PI/2., y0, z0);
+        ArcCurve->Reverse();
+        curves.push_back(ArcCurve);
+    }
+
+    // build right line from gp_Pnts
+    std::vector<gp_Pnt> linePnts_right;
+    std::vector<double> z_right = Linspace( 0.5 * heightToWidthRatio - radius, -0.5 * heightToWidthRatio + radius, 5);
+    for (double z: z_right){
+        linePnts_right.push_back(gp_Pnt(0., 0.5, z));
+    }
+    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 - radius;
+        double z0 = - 0.5 * heightToWidthRatio + radius;
+        auto ArcCurve = ApproximateArcOfCircleToRationalBSpline(radius, 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;
+    std::vector<double> y_upper = Linspace((0.5-radius),(-0.5+radius),5);
+    for (double y: y_upper){
+        linePnts_lower.push_back(gp_Pnt(0., y, -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 + radius;
+        double z0 = -0.5 * heightToWidthRatio + radius;
+        auto ArcCurve = ApproximateArcOfCircleToRationalBSpline(radius, 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;
+    std::vector<double> z_left = Linspace(-0.5 * heightToWidthRatio + radius, 0.5 * heightToWidthRatio - radius, 5);
+    for (double z: z_left){
+        linePnts_left.push_back(gp_Pnt(0., -0.5, z));
+    }
+    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 + radius;
+        double z0 = 0.5 * heightToWidthRatio - radius;
+        auto ArcCurve = ApproximateArcOfCircleToRationalBSpline(radius, 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;
+    std::vector<double> y_UpperLeftHalf = Linspace(-(0.5-radius),0.,5);
+    for (double y: y_UpperLeftHalf){
+        linePntsUpperLeftHalf.push_back(gp_Pnt(0., y, 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);
+    TopoDS_Wire wire;
+    if(!curve.IsNull())
+        {
+        wire = BuildWireFromEdges(BRepBuilderAPI_MakeEdge(curve).Edge());
+    }
+    return wire;
+}
+
 void BuildWiresFromConnectedEdges(const TopoDS_Shape& shape, TopTools_ListOfShape& wireList)
 {
     // get list of edges from passed shape
@@ -1719,6 +1842,17 @@ bool IsPointAbovePlane(const gp_Pln& pln, gp_Pnt point)
     return gp_Vec(pln.Location(), point).Dot(gp_Vec(pln.Axis().Direction())) > 0;
 }
 
+std::vector<double> Linspace(double umin, double umax, size_t n_values)
+{
+    double du = (umax - umin) / static_cast<double>(n_values - 1);
+
+    std::vector<double> result(n_values);
+    for (int i = 0; i < n_values; ++i) {
+        result[i] = i * du + umin;
+    }
+    return result;
+}
+
 std::vector<double> LinspaceWithBreaks(double umin, double umax, size_t n_values, const std::vector<double>& breaks)
 {
     double du = (umax - umin) / static_cast<double>(n_values - 1);

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,28 @@ 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 radius    Radius of the circle
+ * @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, 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
+ * @return
+ */
+TIGL_EXPORT TopoDS_Wire BuildWireRectangle(const double& heightToWidthRatio, const double& cornerRadius =0.0);
+
 // 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);
 
@@ -355,6 +379,9 @@ TIGL_EXPORT double Mix(double x, double y, double a);
 // Normalizes the input angle into the range [0, 360)
 TIGL_EXPORT double NormalizeAngleDeg(double angleDeg);
 
+// Creates a linear spaces array
+TIGL_EXPORT std::vector<double> Linspace(double umin, double umax, size_t n_values);
+
 // 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