OpenCASCADE v7.6.3+

[agodemar]

@joergbrech @rainman110
the following are my modifications (marked as agodemar) to compile TiGL with OCCT v7.6.3:

File cmake/UseOpenCASCADE.cmake:

if(OCE_FOUND)
  ...
else(OCE_FOUND)
  message("OCE not found! Searching for OpenCASCADE.")
  # find_package(OpenCASCADE 7.4.0 CONFIG REQUIRED) # agodemar avoid limitation on OCCT
  find_package(OpenCASCADE)

  ...
endif(OCE_FOUND)

File common/tiglcommonfunctions.cpp:

...
#include <Approx_Curve3d.hxx>
/* agodemar #include <BRepAdaptor_HCompCurve.hxx> */
#include <BRepAlgoAPI_Section.hxx>
...
    // Wrap the adaptor in a class which manages curve access via handle (HCurve). According to doxygen
    // this is required by the algorithms
    /* agodemar
    Handle(Adaptor3d_HCurve) curve1 = new BRepAdaptor_HCompCurve(compCurve1);
    Handle(Adaptor3d_HCurve) curve2 = new BRepAdaptor_HCompCurve(compCurve2);
    */
    Handle(Adaptor3d_Curve) curve1 = new BRepAdaptor_CompCurve(compCurve1);
    Handle(Adaptor3d_Curve) curve2 = new BRepAdaptor_CompCurve(compCurve2);
...

File configuration/CCPACSConfiguration.cpp:

...
#include "BRepAlgoAPI_Fuse.hxx"
/* agodemar #include "BRepAlgo_Fuse.hxx" */
#include <BRepAlgoAPI_Fuse.hxx>
#include "ShapeFix_Shape.hxx"
...

File boolean_operations/GEOMAlgo_Splitter.hxx:

...
 protected:
  TIGL_EXPORT
    void BuildResult(const TopAbs_ShapeEnum theType) override;

  TIGL_EXPORT
    void PostTreat() /* override agodemar */;

...

File boolean_operations/GEOMAlgo_Splitter.cxx:

...
#if OCC_VERSION_HEX >= VERSION_HEX_CODE(7,3,0)
#include <TopTools_MapOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopExp.hxx>
#include <BOPTools_AlgoTools.hxx> // agodemar
#else
...
#endif
...
//=======================================================================
//function : PostTreat
//purpose  : 
//=======================================================================
void GEOMAlgo_Splitter::PostTreat()
{
  ...
  // BOPAlgo_Builder::PostTreat();
  BOPAlgo_Builder::PostTreat(Message_ProgressRange()); // agodemar
}
//=======================================================================
//function : TreatCompound
//purpose  : 
//=======================================================================
...

File wing/CCPACSWingSegment.cpp:

...
#include "Geom_BSplineCurve.hxx"
#include "GeomAPI_PointsToBSpline.hxx"
/* agodemar #include "GeomAdaptor_HCurve.hxx" */
#include "GeomFill.hxx"
...

File geometry/CTiglTriangularizer.cpp:

...
int CTiglTriangularizer::triangularizeFace(const TopoDS_Face & face, unsigned long &nVertices, unsigned long &iPolyLower, unsigned long &iPolyUpper)
{
    TopLoc_Location location;
    std::vector<unsigned long> indexBuffer;
    nVertices = 0;

    const Handle(Poly_Triangulation) triangulation = BRep_Tool::Triangulation(face, location);
    if (triangulation.IsNull()) {
        return 0;
    }

    gp_Trsf nodeTransformation = location;

    unsigned long ilower = 0;
    unsigned long iBufferSize = 0;
    
    if (triangulation->HasUVNodes() && m_computeNormals) {
        // we use the uv nodes to compute normal vectors for each point
        
        BRepGProp_Face prop(face);
        
        /* agodemar
        const TColgp_Array1OfPnt2d& uvnodes = triangulation->UVNodes(); // get (face-local) list of nodes
        */
        // https://dev.opencascade.org/doc/overview/html/occt__upgrade.html
        TColgp_Array1OfPnt2d& uvnodes = TColgp_Array1OfPnt2d(1, triangulation->NbNodes());
        for (int i = 1; i <= triangulation->NbNodes(); ++i) 
        {
            uvnodes.SetValue(i, triangulation->UVNode(i));
        }
        // end-agodemar

        ilower = uvnodes.Lower();
        
        iBufferSize = uvnodes.Upper()-uvnodes.Lower()+1;
        indexBuffer.reserve(iBufferSize);
        for (int inode = uvnodes.Lower(); inode <= uvnodes.Upper(); ++inode) {
            const gp_Pnt2d& uv_pnt = uvnodes(inode);
            gp_Pnt p; gp_Vec n;
            prop.Normal(uv_pnt.X(),uv_pnt.Y(),p,n);
            if (n.SquareMagnitude() > 0.) {
                n.Normalize();
            }
            if (face.Orientation() == TopAbs_INTERNAL) {
                n.Reverse();
            }
            indexBuffer.push_back(polys.currentObject().addPointNormal(p.XYZ(), n.XYZ()));
        }
    } 
    else {
        // we cannot compute normals

        /* agodemar
        const TColgp_Array1OfPnt& nodes = triangulation->Nodes(); // get (face-local) list of nodes
        */
        // https://dev.opencascade.org/doc/overview/html/occt__upgrade.html
        TColgp_Array1OfPnt& nodes = TColgp_Array1OfPnt(1, triangulation->NbNodes());
        for (int i = 1; i <= triangulation->NbNodes(); ++i) 
        {
            gp_Pnt pnt = triangulation->Node(i);
            nodes.SetValue(i, pnt);
        }
        // end-agodemar

        ilower = nodes.Lower();

        iBufferSize = nodes.Upper()-nodes.Lower()+1;
        indexBuffer.reserve(iBufferSize);
        for (int inode = nodes.Lower(); inode <= nodes.Upper(); inode++) {
            const gp_Pnt& p = nodes(inode).Transformed(nodeTransformation);
            indexBuffer.push_back(polys.currentObject().addPointNormal(p.XYZ(), CTiglPoint(1,0,0)));
        }
    }

    /* agodemar */
    // https://dev.opencascade.org/doc/overview/html/occt__upgrade.html
    // agodemar: ("Deprecated method, Triangle() should be used instead") 
    const Poly_Array1OfTriangle& triangles = triangulation->Triangles(); 

    iPolyLower = ULONG_MAX;
    iPolyUpper = 0;
    // iterate over triangles in the array 
    for (int j = triangles.Lower(); j <= triangles.Upper(); j++) {
        const Poly_Triangle& triangle = triangles(j);
        int occindex1, occindex2, occindex3;
        triangle.Get(occindex1, occindex2, occindex3); // get indices into index1..3
        unsigned long index1, index2, index3;
        index1 = indexBuffer[occindex1-ilower];
        index2 = indexBuffer[occindex2-ilower];
        index3 = indexBuffer[occindex3-ilower];

        unsigned long iPolyIndex = 0;

        if (face.Orientation() != TopAbs_REVERSED && face.Orientation() != TopAbs_INTERNAL) {
            iPolyIndex = polys.currentObject().addTriangleByVertexIndex(index1, index2, index3);
        }
        else {
            iPolyIndex = polys.currentObject().addTriangleByVertexIndex(index1, index3, index2);
        }

        // In some rare cases, 2 indices are the same
        // which means, that we dont have a true triangle.
        // Ignore this triangle
        if (iPolyIndex == ULONG_MAX) {
            continue;
        }

        if (iPolyIndex > iPolyUpper) {
            iPolyUpper = iPolyIndex;
        }
        if (iPolyIndex < iPolyLower) {
            iPolyLower = iPolyIndex;
        }
        
    } // for triangles

    nVertices = iBufferSize;
    return 0;
}
...

File control_devices/CControlSurfaceBorderBuilder.cpp:

...
#include <Geom2dAPI_Interpolate.hxx>
#include <Geom2d_BSplineCurve.hxx> // agodemar
#include <BRepBuilderAPI_MakeWire.hxx>
...
TopoDS_Wire CControlSurfaceBorderBuilder::boarderWithInnerShapeImpl(double relHeightCenterPoint, double xsiCenterPoint, double xsiEdgeUpper, double xsiEdgeLower, double offset_factor)
{
    // compute position of the leading and trailing edge in local coords
    gp_Pln plane = _coords.getPlane();
    gp_Pnt2d _le2d = ProjectPointOnPlane(plane, _coords.getLe());
    gp_Pnt2d _te2d = ProjectPointOnPlane(plane, _coords.getTe());

    computeSkinPoints(xsiEdgeUpper, xsiEdgeLower);

    // Determine the center point of the slat defined by relHeightCenterPoint
    gp_Pnt2d upTmp, loTmp;
    gp_Vec2d dummyVec;
    computeSkinPointsImpl(xsiCenterPoint, upTmp, dummyVec, loTmp, dummyVec);
    gp_Pnt2d centerPoint2d = loTmp.XY() * (1. - relHeightCenterPoint) + upTmp.XY()*relHeightCenterPoint;

    // Compute normals
    gp_Vec2d upNorm2d(-_upTan2d.Y(), _upTan2d.X());
    gp_Vec2d loNorm2d(-_loTan2d.Y(), _loTan2d.X());

    if (upNorm2d.Y() < 0) {
        upNorm2d.Multiply(-1.);
    }

    if (loNorm2d.Y() > 0) {
        loNorm2d.Multiply(-1.);
    }

    // Compute the inner edge by interpolating upper, lower and center point
    Handle(TColgp_HArray1OfPnt2d) points = new TColgp_HArray1OfPnt2d(1,3);
    points->SetValue(1, _lp2d);
    points->SetValue(2, centerPoint2d);
    points->SetValue(3, _up2d);

    Geom2dAPI_Interpolate interp(points, false, Precision::Confusion());

    // make the upper tangent point away from the inner edge
    if ((centerPoint2d.X() > _up2d.X()) != (_upTan2d.X() < 0)) {
        _upTan2d.Multiply(-1.);
    }

    // make the lower tangent point to the inner edge
    if ((centerPoint2d.X() > _lp2d.X()) != (_loTan2d.X() > 0)) {
        _loTan2d.Multiply(-1.);
    }

    interp.Load(_loTan2d, _upTan2d);
    interp.Perform();

    /* agodemar
    TopoDS_Edge innerEdge = BRepBuilderAPI_MakeEdge(interp.Curve(), new Geom_Plane(plane));
    */
    // target constructor: BRepBuilderAPI_MakeEdge (const Handle< Geom2d_Curve > &L, const Handle< Geom_Surface > &S)

    const Handle(Geom_Plane) gplane = new Geom_Plane(plane);
    TopoDS_Edge innerEdge = BRepBuilderAPI_MakeEdge(interp.Curve(), gplane);

    // end-agodemar

    BRepLib::BuildCurves3d(innerEdge);
    ...
}
...

These modifications should also work with the latest OCCT v7.7.0 recently released.

-agostino

[meerfrau]

Hi agostino,
I was (and still am) very thankful finding this.

With OpenCascade 7.7 there is a failure in the updated Triangularizer:

./geometry/CTiglTriangularizer.cpp: In member function 'int tigl::CTiglTriangularizer::triangularizeFace(const TopoDS_Face&, long unsigned int&, long unsigned int&, long unsigned int&)':
./geometry/CTiglTriangularizer.cpp:297:41: error: cannot bind non-const lvalue reference of type 'TColgp_Array1OfPnt2d&' {aka 'NCollection_Array1<gp_Pnt2d>&'} to an rvalue of type 'TColgp_Array1OfPnt2d' {aka 'NCollection_Array1<gp_Pnt2d>'}
  297 |         TColgp_Array1OfPnt2d& uvnodes = TColgp_Array1OfPnt2d(1, triangulation->NbNodes());
      |                                         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
./geometry/CTiglTriangularizer.cpp:322:37: error: cannot bind non-const lvalue reference of type 'TColgp_Array1OfPnt&' {aka 'NCollection_Array1<gp_Pnt>&'} to an rvalue of type 'TColgp_Array1OfPnt' {aka 'NCollection_Array1<gp_Pnt>'}
  322 |         TColgp_Array1OfPnt& nodes = TColgp_Array1OfPnt(1, triangulation->NbNodes());
      |                                     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[joergbrech]

Thanks again for the heads up! It took quite a while, but TiGL is now compatible to OCCT 7.6.2, thanks to #971. I haven't tested it yet for 7.7.0