Resolve: Enable to use more than 3 wing guide curves

TIGLViewer/src/TIGLScriptEngine.cpp

@@ -1,5 +1,3 @@
-#include <utility>
-
 /*
 * Copyright (C) 2007-2013 German Aerospace Center (DLR/SC)
 *

TIGLViewer/src/TIGLViewerDocument.cpp

@@ -1969,16 +1969,7 @@ void TIGLViewerDocument::drawWingComponentSegment()
         return;
     }
 
-    for (int i = 1; i <= GetConfiguration().GetWingCount();++i) {
-        tigl::CCPACSWing& wing = GetConfiguration().GetWing(i);
-        for (int j = 1; j <= wing.GetComponentSegmentCount();++j) {
-            auto& segment = static_cast<tigl::CCPACSWingComponentSegment&>(wing.GetComponentSegment(j));
-            if (segment.GetUID() == csUid.toStdString()) {
-                drawWingComponentSegment(segment);
-                break;
-            }
-        }
-    }
+    drawComponentByUID(csUid);
 }
 
 void TIGLViewerDocument::drawWingComponentSegmentPoints()

bindings/python_internal/geometry.i

@@ -69,6 +69,8 @@
 #include "CTiglIntersectBSplines.h"
 #include "CTiglInterpolatePointsWithKinks.h"
 #include "CTiglApproxResult.h"
+#include "SurfTools.hxx"
+#include "CTiglConcatSurfaces.h"
 %}
 
 
@@ -80,7 +82,9 @@
 
 %template(CPointContainer) std::vector<gp_Pnt>;
 %template(BSplineCurveList) std::vector<Handle_Geom_BSplineCurve>;
+%template(BSplineSurfaceList) std::vector<Handle_Geom_BSplineSurface>;
 %template(CurveList) std::vector<Handle_Geom_Curve>;
+%template(SurfaceList) std::vector<Handle_Geom_Surface>;
 %template(CurveIntersectionResultList) std::vector<tigl::CurveIntersectionResult>;
 
 %boost_optional(tigl::CCPACSPointAbsRel)
@@ -89,6 +93,8 @@
 %boost_optional(tigl::generated::CPACSPointX)
 %boost_optional(tigl::generated::CPACSPointXYZ)
 
+%include "CTiglConcatSurfaces.h"
+%include "SurfTools.hxx"
 %include "CTiglApproxResult.h"
 %include "CTiglIntersectBSplines.h"
 %include "CTiglPointsToBSplineInterpolation.h"

src/CMakeLists.txt

@@ -79,6 +79,7 @@ endforeach()
 
 # object library containing just the compiled sources
 add_library(tigl3_objects OBJECT ${TIGL_SRC})
+target_compile_features(tigl3_objects PRIVATE cxx_std_11)
 set_property(TARGET tigl3_objects PROPERTY POSITION_INDEPENDENT_CODE ON) # needed for shared libraries
 
 target_include_directories(tigl3_objects
@@ -207,6 +208,7 @@ target_include_directories(tigl3_cpp INTERFACE
 )
 
 target_link_libraries(tigl3_cpp INTERFACE ${OpenCASCADE_LIBRARIES} Boost::boost Boost::disable_autolinking)
+target_compile_features(tigl3_cpp INTERFACE cxx_std_11)
 
 if (TARGET glog::glog)
   target_link_libraries (tigl3_cpp INTERFACE glog::glog)

src/common/tiglcommonfunctions.h

@@ -324,6 +324,44 @@ size_t IndexFromUid(const std::vector<std::unique_ptr<T> >& vectorOfPointers, co
     return found - vectorOfPointers.begin();
 }
 
+/**
+ * @brief Searches for a entry in a range and returns its index
+ *
+ * This function can be used with std::arrays, std::vectors
+ * and also possible other containers supported by std::distance
+ *
+ * If the index is not found, the size of the range will be returned instead
+ */
+template <typename ForwardIter, typename Compare>
+size_t FindIndex(ForwardIter begin, ForwardIter end, Compare comp)
+{
+    const auto it = std::find_if(begin, end, comp);
+    if (it != end) {
+        return std::distance(begin, it);
+    }
+    else {
+        return std::distance(begin, end);
+    }
+}
+
+/**
+ * @brief Checks, whether an array contains a value or not
+ *
+ * @param array The array to be searched in
+ * @param val The value to be saerched for
+ * @param tolerance This functions is typically used with floating point values. The tolerance allows
+ *                  to search for a value within the specified tolerance.
+ */
+template <typename ArrayLike, typename ValueType>
+bool Contains(const ArrayLike& array, ValueType val, ValueType tolerance)
+{
+    auto idx = FindIndex(std::begin(array), std::end(array), [val, tolerance](const typename ArrayLike::value_type& cval) {
+        return fabs(cval - val) < tolerance;
+    });
+
+    return idx < array.size();
+}
+
 template <class ArrayType, typename BinaryPredicate, typename BinaryMerge>
 void ReplaceAdjacentWithMerged(ArrayType& list, BinaryPredicate is_adjacent, BinaryMerge merged)
 {

src/geometry/CTiglBSplineAlgorithms.cpp

@@ -25,6 +25,7 @@
 #include "CTiglPointsToBSplineInterpolation.h"
 #include "to_string.h"
 #include "tiglcommonfunctions.h"
+#include "Debugging.h"
 
 #include <Standard_Version.hxx>
 #include <Geom2d_BSplineCurve.hxx>
@@ -534,24 +535,24 @@ std::vector<Handle(Geom_BSplineCurve)> CTiglBSplineAlgorithms::createCommonKnots
     return std::vector<Handle(Geom_BSplineCurve)>(splines_adapter.begin(), splines_adapter.end());
 }
 
-std::vector<Handle(Geom_BSplineSurface) > CTiglBSplineAlgorithms::createCommonKnotsVectorSurface(const std::vector<Handle(Geom_BSplineSurface) >& old_surfaces_vector)
+std::vector<Handle(Geom_BSplineSurface) > CTiglBSplineAlgorithms::createCommonKnotsVectorSurface(const std::vector<Handle(Geom_BSplineSurface) >& old_surfaces_vector, SurfaceDirection dir)
 {
-    // all B-spline surfaces must have the same parameter range in u- and v-direction
-    // TODO: Match parameter range
-
     // Create a copy that we can modify
     std::vector<SurfAdapterView> adapterSplines;
     for (size_t i = 0; i < old_surfaces_vector.size(); ++i) {
         adapterSplines.push_back(SurfAdapterView(Handle(Geom_BSplineSurface)::DownCast(old_surfaces_vector[i]->Copy()), udir));
     }
 
-    // first in u direction
-    makeGeometryCompatibleImpl(adapterSplines, 1e-15);
-
-    for (size_t i = 0; i < old_surfaces_vector.size(); ++i) adapterSplines[i].setDir(vdir);
+    if (dir == SurfaceDirection::u || dir == SurfaceDirection::both) {
+        // first in u direction
+        makeGeometryCompatibleImpl(adapterSplines, 1e-14);
+    }
 
-    // now in v direction
-    makeGeometryCompatibleImpl(adapterSplines, 1e-15);
+    if (dir == SurfaceDirection::v || dir == SurfaceDirection::both) {
+         // now in v direction
+        for (size_t i = 0; i < old_surfaces_vector.size(); ++i) adapterSplines[i].setDir(vdir);
+        makeGeometryCompatibleImpl(adapterSplines, 1e-14);
+    }
 
     return std::vector<Handle(Geom_BSplineSurface)>(adapterSplines.begin(), adapterSplines.end());
 }
@@ -818,6 +819,23 @@ void CTiglBSplineAlgorithms::reparametrizeBSpline(Geom_BSplineCurve& spline, dou
     }
 }
 
+void CTiglBSplineAlgorithms::reparametrizeBSpline(Geom_BSplineSurface& spline, double umin, double umax, double vmin, double vmax, double tol)
+{
+    if (std::abs(spline.UKnot(1) - umin) > tol || std::abs(spline.UKnot(spline.NbUKnots()) - umax) > tol) {
+        TColStd_Array1OfReal aKnots (1, spline.NbUKnots());
+        spline.UKnots (aKnots);
+        BSplCLib::Reparametrize (umin, umax, aKnots);
+        spline.SetUKnots (aKnots);
+    }
+
+    if (std::abs(spline.VKnot(1) - vmin) > tol || std::abs(spline.VKnot(spline.NbVKnots()) - vmax) > tol) {
+        TColStd_Array1OfReal aKnots (1, spline.NbVKnots());
+        spline.VKnots (aKnots);
+        BSplCLib::Reparametrize (vmin, vmax, aKnots);
+        spline.SetVKnots (aKnots);
+    }
+}
+
 CTiglApproxResult CTiglBSplineAlgorithms::reparametrizeBSplineNiceKnots(Handle(Geom_BSplineCurve) spline)
 {
     if (spline.IsNull()) {
@@ -1139,4 +1157,140 @@ Handle(Geom_BSplineCurve) CTiglBSplineAlgorithms::concatCurves(std::vector<Handl
     return result;
 }
 
+Handle(Geom_BSplineSurface) CTiglBSplineAlgorithms::concatSurfacesUDir(Handle(Geom_BSplineSurface) bspl1,
+                                                                       Handle(Geom_BSplineSurface) bspl2,
+                                                                       double space_tol)
+{
+
+    DEBUG_SCOPE(debug);
+    debug.addShape(BRepBuilderAPI_MakeFace(bspl1, 1e-6).Face(), "surf1");
+    debug.addShape(BRepBuilderAPI_MakeFace(bspl2, 1e-6).Face(), "surf2");
+
+    // the surfaces must not be periodic in u direction
+    assert (bspl1->IsUPeriodic() == false);
+    assert (bspl2->IsUPeriodic() == false);
+
+    // we dont have nurbs implemented right now
+    assert (bspl1->IsURational() == false);
+    assert (bspl2->IsURational() == false);
+    assert (bspl1->IsVRational() == false);
+    assert (bspl2->IsVRational() == false);
+
+    double param_tol = 1e-14;
+
+    // check that surfaces are following parametrically
+    double umin1, umax1, vmin1, vmax1;
+    bspl1->Bounds(umin1, umax1, vmin1, vmax1);
+    double umin2, umax2, vmin2, vmax2;
+    bspl2->Bounds(umin2, umax2, vmin2, vmax2);
+
+    if (std::abs(umax1 - umin2) > param_tol) {
+        std::stringstream str;
+        str << "Surfaces do not follow in u-parametric direction in CTiglBSplineAlgorithms::concatSurfacesUDir. ";
+        str << "Surface 1 ends at " << umax1 << ", Surface 2 begins at " << umin2 << "!";
+        throw CTiglError(str.str(), TIGL_MATH_ERROR);
+    }
+
+    bspl1->SetVNotPeriodic();
+    bspl2->SetVNotPeriodic();
+
+    auto u_degree = std::max(bspl1->UDegree(), bspl2->UDegree());
+    auto v_degree = std::max(bspl1->VDegree(), bspl2->VDegree());
+
+    bspl1->IncreaseDegree(u_degree, v_degree);
+    bspl2->IncreaseDegree(u_degree, v_degree);
+
+    // check that corner points match
+    auto leftCornerDist = bspl1->Value(umax1, vmin1).Distance(bspl2->Value(umin2, vmin2));
+    auto rightCornerDist = bspl1->Value(umax1, vmax1).Distance(bspl2->Value(umin2, vmax2)) ;
+    if (leftCornerDist > space_tol || rightCornerDist > space_tol) {
+        throw CTiglError("Surfaces don't match within tolerances in CTiglBSplineAlgorithms::concatSurfacesUDir.", TIGL_MATH_ERROR);
+    }
+
+    auto spl_vec = CTiglBSplineAlgorithms::createCommonKnotsVectorSurface({bspl1, bspl2}, SurfaceDirection::v);
+    bspl1 = spl_vec[0];
+    bspl2 = spl_vec[1];
+
+    assert(bspl1->NbVPoles() == bspl2->NbVPoles());
+
+    // concat control points
+    TColgp_Array2OfPnt cpsNew(1, bspl1->NbUPoles() + bspl2->NbUPoles() - 1, 1, bspl1->NbVPoles());
+    for (int iv = 0; iv < bspl1->NbVPoles(); ++iv) {
+        for (int iu = 0; iu < bspl1->NbUPoles() - 1; ++iu) {
+            cpsNew.SetValue(iu+1, iv+1, bspl1->Pole(iu+1, iv+1));
+        }
+        auto offset = bspl1->NbUPoles();
+        for (int iu = 0; iu < bspl2->NbUPoles(); ++iu) {
+            cpsNew.SetValue(iu + offset, iv+1, bspl2->Pole(iu+1, iv+1));
+        }
+    }
+
+    // concat knots and mults
+    TColStd_Array1OfReal uknots_new(1, bspl1->NbUKnots() + bspl2->NbUKnots() - 1);
+    TColStd_Array1OfInteger umults_new(1, bspl1->NbUKnots() + bspl2->NbUKnots() - 1);
+
+    for (int i = 0; i < bspl1->NbUKnots()-1; ++i) {
+        uknots_new.SetValue(i+1, bspl1->UKnot(i+1));
+        umults_new.SetValue(i+1, bspl1->UMultiplicity(i+1));
+    }
+
+    int middleIdx = bspl1->NbUKnots();
+    uknots_new.SetValue(middleIdx, 0.5 * (bspl1->UKnot(middleIdx) + bspl2->UKnot(1)));
+    umults_new.SetValue(middleIdx, bspl1->UMultiplicity(middleIdx) - 1);
+
+    for (int i = 1; i < bspl2->NbUKnots(); ++i) {
+        uknots_new.SetValue(i + middleIdx, bspl2->UKnot(i+1));
+        umults_new.SetValue(i + middleIdx, bspl2->UMultiplicity(i+1));
+    }
+
+    // we simply take the v-knots of the first spline
+    TColStd_Array1OfReal vknots_new(1, bspl1->NbVKnots());
+    TColStd_Array1OfInteger vmults_new(1, bspl1->NbVKnots());
+    bspl1->VKnots(vknots_new);
+    bspl1->VMultiplicities(vmults_new);
+
+#ifdef DEBUG
+    int sum_umults = 0;
+    for (int i = umults_new.Lower(); i <= umults_new.Upper(); ++i) {
+        sum_umults += umults_new.Value(i);
+    }
+
+    int sum_vmults = 0;
+    for (int i = vmults_new.Lower(); i <= vmults_new.Upper(); ++i) {
+        sum_vmults += vmults_new.Value(i);
+    }
+
+    assert(cpsNew.ColLength() + u_degree + 1 == sum_umults);
+    assert(cpsNew.RowLength() + v_degree + 1 == sum_vmults);
+#endif
+
+    return new Geom_BSplineSurface(cpsNew, uknots_new, vknots_new,
+                                   umults_new, vmults_new,
+                                   u_degree, v_degree, false, false);
+}
+
+Handle(Geom_BSplineSurface) CTiglBSplineAlgorithms::makeKnotsUniform(Handle(Geom_BSplineSurface) surf, unsigned int nseg_u, unsigned int nseg_v)
+{
+    double u1, u2, v1, v2;
+    surf->Bounds(u1, u2, v1, v2);
+
+    // we create a degree 3 approximation in all directions
+    auto ncp_u = std::max(4, static_cast<int>(nseg_u + 1));
+    auto ncp_v = std::max(4, static_cast<int>(nseg_v + 1));
+
+    auto u = LinspaceWithBreaks(u1, u2, ncp_u, {});
+    auto v = LinspaceWithBreaks(v1, v2, ncp_v, {});
+
+    TColgp_Array2OfPnt points(1, ncp_u, 1, ncp_v);
+
+    for (size_t i = 0; i < u.size(); ++i) {
+        for (size_t j = 0; j < v.size(); ++j) {
+            auto pnt = surf->Value(u[i], v[j]);
+            points.SetValue(static_cast<Standard_Integer>(i+1), static_cast<Standard_Integer>(j+1), pnt);
+        }
+    }
+
+    return CTiglBSplineAlgorithms::pointsToSurface(points, u, v, true, true);
+}
+
 } // namespace tigl