kindred/create
1
1
Fork 0
Code Issues 30 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

OCCT: port FreeCAD sources to version 7.6

Browse Source 
SMESH is not yet ported
Although FreeCAD code compiles with OCCT 7.6 it doesn't work at the moment
This commit is contained in:
wmayer
2021-10-09 13:49:02 +02:00
parent f628050732
commit 74639da997
13 changed files with 138 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/Mod/Drawing/App/DrawingExport.cpp
View File

@@ -64,10 +64,7 @@
#include <BRep_Tool.hxx>
#include <BRepAdaptor_CompCurve.hxx>
#include <BRepAdaptor_HCompCurve.hxx>
#include <Approx_Curve3d.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_BezierCurve.hxx>
#include <GeomConvert_BSplineCurveToBezierCurve.hxx>
@@ -75,11 +72,19 @@
#include <Geom2d_BSplineCurve.hxx>
#include <BRepLProp_CLProps.hxx>
#include <Standard_Failure.hxx>
#include <Standard_Version.hxx>
#if OCC_VERSION_HEX < 0x070600
#include <BRepAdaptor_HCurve.hxx>
#endif
#include "DrawingExport.h"
#include <Base/Tools.h>
#include <Base/Vector3D.h>
#if OCC_VERSION_HEX >= 0x070600
using BRepAdaptor_HCurve = BRepAdaptor_Curve;
#endif
using namespace Drawing;
using namespace std;

3
src/Mod/Drawing/App/ProjectionAlgos.cpp
View File

@@ -61,10 +61,7 @@
#include <BRepMesh_IncrementalMesh.hxx>
#include <BRepLib.hxx>
#include <BRepAdaptor_CompCurve.hxx>
#include <BRepAdaptor_HCompCurve.hxx>
#include <Approx_Curve3d.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_BezierCurve.hxx>
#include <GeomConvert_BSplineCurveToBezierCurve.hxx>

9
src/Mod/Import/App/ImpExpDxf.cpp
View File

@@ -29,7 +29,6 @@
#include <Approx_Curve3d.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <BRep_Builder.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRepBuilderAPI_MakeVertex.hxx>
@@ -47,6 +46,7 @@
#include <gp_Pnt.hxx>
#include <gp_Dir.hxx>
#include <gp_Vec.hxx>
#include <Standard_Version.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Vertex.hxx>
@@ -55,6 +55,9 @@
#include <TopExp_Explorer.hxx>
#include <TopoDS_Edge.hxx>
#include <TColgp_Array1OfPnt.hxx>
#if OCC_VERSION_HEX < 0x070600
#include <BRepAdaptor_HCurve.hxx>
#endif
#include <Base/Console.h>
#include <Base/Parameter.h>
@@ -68,6 +71,10 @@
using namespace Import;
#if OCC_VERSION_HEX >= 0x070600
using BRepAdaptor_HCurve = BRepAdaptor_Curve;
#endif
//******************************************************************************
// reading

41
src/Mod/Part/App/GeomPlate/CurveConstraintPyImp.cpp
View File

@@ -24,10 +24,13 @@
#include "PreCompiled.h"
#ifndef _PreComp_
# include <GeomAdaptor_Curve.hxx>
# include <GeomAdaptor_HCurve.hxx>
# include <Geom2dAdaptor_Curve.hxx>
# include <Geom2dAdaptor_HCurve.hxx>
# include <Standard_Failure.hxx>
# include <Standard_Version.hxx>
# if OCC_VERSION_HEX < 0x070600
# include <GeomAdaptor_HCurve.hxx>
# include <Geom2dAdaptor_HCurve.hxx>
# endif
#endif
#include "GeomPlate/CurveConstraintPy.h"
@@ -76,6 +79,16 @@ int CurveConstraintPy::PyInit(PyObject* args, PyObject* kwds)
return -1;
}
#if OCC_VERSION_HEX >= 0x070600
Handle(Adaptor3d_Curve) hCurve;
if (curve->getTypeId().isDerivedFrom(GeomTrimmedCurve::getClassTypeId())) {
GeomTrimmedCurve* trim = static_cast<GeomTrimmedCurve*>(curve);
hCurve = new GeomAdaptor_Curve(handle, trim->getFirstParameter(), trim->getLastParameter());
}
else {
hCurve = new GeomAdaptor_Curve(handle);
}
#else
Handle(Adaptor3d_HCurve) hCurve;
if (curve->getTypeId().isDerivedFrom(GeomTrimmedCurve::getClassTypeId())) {
GeomTrimmedCurve* trim = static_cast<GeomTrimmedCurve*>(curve);
@@ -86,6 +99,7 @@ int CurveConstraintPy::PyInit(PyObject* args, PyObject* kwds)
GeomAdaptor_Curve adapt(handle);
hCurve = new GeomAdaptor_HCurve(adapt);
}
#endif
ptr.reset(new GeomPlate_CurveConstraint(hCurve, order, nbPts, tolDist, tolAng, tolCurv));
}
@@ -212,11 +226,15 @@ PyObject* CurveConstraintPy::curve3d(PyObject *args)
return nullptr;
try {
Handle(Adaptor3d_HCurve) hAdapt = getGeomPlate_CurveConstraintPtr()->Curve3d();
auto hAdapt = getGeomPlate_CurveConstraintPtr()->Curve3d();
if (hAdapt.IsNull())
Py_Return;
#if OCC_VERSION_HEX >= 0x070600
const Adaptor3d_Curve& a3d = *hAdapt;
#else
const Adaptor3d_Curve& a3d = hAdapt->Curve();
#endif
std::unique_ptr<GeomCurve> ptr(Part::makeFromCurveAdaptor(a3d));
return ptr->getPyObject();
}
@@ -282,6 +300,16 @@ PyObject* CurveConstraintPy::setProjectedCurve(PyObject *args)
return nullptr;
}
#if OCC_VERSION_HEX >= 0x070600
Handle(Adaptor2d_Curve2d) hCurve;
if (handle->IsKind(STANDARD_TYPE(Geom2d_TrimmedCurve))) {
Handle(Geom2d_TrimmedCurve) aTC (Handle(Geom2d_TrimmedCurve)::DownCast (handle));
hCurve = new Geom2dAdaptor_Curve(handle, aTC->FirstParameter(), aTC->LastParameter());
}
else {
hCurve = new Geom2dAdaptor_Curve(handle);
}
#else
Handle(Adaptor2d_HCurve2d) hCurve;
if (handle->IsKind(STANDARD_TYPE(Geom2d_TrimmedCurve))) {
Handle(Geom2d_TrimmedCurve) aTC (Handle(Geom2d_TrimmedCurve)::DownCast (handle));
@@ -292,6 +320,7 @@ PyObject* CurveConstraintPy::setProjectedCurve(PyObject *args)
Geom2dAdaptor_Curve adapt(handle);
hCurve = new Geom2dAdaptor_HCurve(adapt);
}
#endif
getGeomPlate_CurveConstraintPtr()->SetProjectedCurve(hCurve, tolU, tolV);
Py_Return;
@@ -308,11 +337,15 @@ PyObject* CurveConstraintPy::projectedCurve(PyObject *args)
return nullptr;
try {
Handle(Adaptor2d_HCurve2d) hAdapt = getGeomPlate_CurveConstraintPtr()->ProjectedCurve();
auto hAdapt = getGeomPlate_CurveConstraintPtr()->ProjectedCurve();
if (hAdapt.IsNull())
Py_Return;
#if OCC_VERSION_HEX >= 0x070600
const Adaptor2d_Curve2d& a2d = *hAdapt;
#else
const Adaptor2d_Curve2d& a2d = hAdapt->Curve2d();
#endif
std::unique_ptr<Geom2dCurve> ptr(Part::makeFromCurveAdaptor2d(a2d));
return ptr->getPyObject();
}

7
src/Mod/Part/App/Geometry.cpp
View File

@@ -51,7 +51,6 @@
# include <Geom_RectangularTrimmedSurface.hxx>
# include <Geom_SurfaceOfRevolution.hxx>
# include <Geom_SurfaceOfLinearExtrusion.hxx>
# include <GeomAdaptor_HCurve.hxx>
# include <GeomAPI_Interpolate.hxx>
# include <GeomConvert.hxx>
# include <GeomConvert_CompCurveToBSplineCurve.hxx>
@@ -101,6 +100,9 @@
# include <GeomAPI_ExtremaCurveCurve.hxx>
# include <ShapeConstruct_Curve.hxx>
# include <LProp_NotDefined.hxx>
# if OCC_VERSION_HEX < 0x070600
# include <GeomAdaptor_HCurve.hxx>
# endif
# include <ctime>
# include <cmath>
@@ -144,6 +146,9 @@
#include "Geometry.h"
#if OCC_VERSION_HEX >= 0x070600
using GeomAdaptor_HCurve = GeomAdaptor_Curve;
#endif
using namespace Part;

22
src/Mod/Part/App/PartFeatures.cpp
View File

@@ -25,9 +25,7 @@
#ifndef _PreComp_
# include <BRepFill.hxx>
# include <BRepAdaptor_Curve.hxx>
# include <BRepAdaptor_HCurve.hxx>
# include <BRepAdaptor_CompCurve.hxx>
# include <BRepAdaptor_HCompCurve.hxx>
# include <BRepLib_MakeWire.hxx>
# include <Geom_BSplineSurface.hxx>
# include <TopoDS.hxx>
@@ -43,7 +41,7 @@
# include <TopExp_Explorer.hxx>
# include <TopoDS.hxx>
# include <Precision.hxx>
# include <Adaptor3d_HCurve.hxx>
# include <memory>
#endif
@@ -170,22 +168,18 @@ App::DocumentObjectExecReturn *RuledSurface::execute(void)
if (Orientation.getValue() == 0) {
// Automatic
Handle(Adaptor3d_HCurve) a1;
Handle(Adaptor3d_HCurve) a2;
std::unique_ptr<Adaptor3d_Curve> a1;
std::unique_ptr<Adaptor3d_Curve> a2;
if (!isWire) {
BRepAdaptor_Curve adapt1(TopoDS::Edge(S1));
BRepAdaptor_Curve adapt2(TopoDS::Edge(S2));
a1 = new BRepAdaptor_HCurve(adapt1);
a2 = new BRepAdaptor_HCurve(adapt2);
a1 = std::make_unique<BRepAdaptor_Curve>(TopoDS::Edge(S1));
a2 = std::make_unique<BRepAdaptor_Curve>(TopoDS::Edge(S2));
}
else {
BRepAdaptor_CompCurve adapt1(TopoDS::Wire(S1));
BRepAdaptor_CompCurve adapt2(TopoDS::Wire(S2));
a1 = new BRepAdaptor_HCompCurve(adapt1);
a2 = new BRepAdaptor_HCompCurve(adapt2);
a1 = std::make_unique<BRepAdaptor_CompCurve>(TopoDS::Wire(S1));
a2 = std::make_unique<BRepAdaptor_CompCurve>(TopoDS::Wire(S2));
}
if (!a1.IsNull() && !a2.IsNull()) {
if (a1 && a2) {
// get end points of 1st curve
Standard_Real first, last;
first = a1->FirstParameter();

82
src/Mod/Part/App/TopoShape.cpp
View File

@@ -38,8 +38,6 @@
# include <BRep_Tool.hxx>
# include <BRepAdaptor_Curve.hxx>
# include <BRepAdaptor_CompCurve.hxx>
# include <BRepAdaptor_HCurve.hxx>
# include <BRepAdaptor_HCompCurve.hxx>
# include <BRepAdaptor_Surface.hxx>
# include <BRepAlgoAPI_Common.hxx>
# include <BRepAlgoAPI_Cut.hxx>
@@ -186,6 +184,12 @@
#if OCC_VERSION_HEX >= 0x070300
# include <BRepAlgoAPI_Defeaturing.hxx>
#endif
#if OCC_VERSION_HEX < 0x070600
# include <BRepAdaptor_HCurve.hxx>
# include <BRepAdaptor_HCompCurve.hxx>
#endif
#endif // _PreComp_
#include <boost/algorithm/string/predicate.hpp>
@@ -2133,12 +2137,20 @@ TopoDS_Shape TopoShape::makeTube(double radius, double tol, int cont, int maxdeg
if (this->_Shape.IsNull())
Standard_Failure::Raise("Cannot sweep along empty spine");
#if OCC_VERSION_HEX >= 0x070600
Handle(Adaptor3d_Curve) myPath;
if (this->_Shape.ShapeType() == TopAbs_EDGE) {
const TopoDS_Edge& path_edge = TopoDS::Edge(this->_Shape);
myPath = new BRepAdaptor_Curve(path_edge);
}
#else
Handle(Adaptor3d_HCurve) myPath;
if (this->_Shape.ShapeType() == TopAbs_EDGE) {
const TopoDS_Edge& path_edge = TopoDS::Edge(this->_Shape);
BRepAdaptor_Curve path_adapt(path_edge);
myPath = new BRepAdaptor_HCurve(path_adapt);
}
#endif
//else if (this->_Shape.ShapeType() == TopAbs_WIRE) {
// const TopoDS_Wire& path_wire = TopoDS::Wire(this->_Shape);
// BRepAdaptor_CompCurve path_adapt(path_wire);
@@ -3777,72 +3789,32 @@ void TopoShape::getLinesFromSubElement(const Data::Segment* element,
for(TopExp_Explorer exp(shape,TopAbs_EDGE);exp.More();exp.Next()) {
TopoDS_Edge aEdge = TopoDS::Edge(exp.Current());
TopLoc_Location aLoc;
Handle(Poly_Polygon3D) aPoly = BRep_Tool::Polygon3D(aEdge, aLoc);
std::vector<gp_Pnt> points;
gp_Trsf myTransf;
Standard_Integer nbNodesInFace;
auto line_start = vertices.size();
// triangulation succeeded?
if (!aPoly.IsNull()) {
if (!aLoc.IsIdentity()) {
myTransf = aLoc.Transformation();
}
nbNodesInFace = aPoly->NbNodes();
const TColgp_Array1OfPnt& Nodes = aPoly->Nodes();
gp_Pnt V;
for (Standard_Integer i=0;i < nbNodesInFace;i++) {
V = Nodes(i+1);
V.Transform(myTransf);
vertices.emplace_back(V.X(),V.Y(),V.Z());
}
}
else {
if (!Tools::getPolygon3D(aEdge, points)) {
// the edge has not its own triangulation, but then a face the edge is attached to
// must provide this triangulation
// Look for one face in our map (it doesn't care which one we take)
int index = edge2Face.FindIndex(aEdge);
if(!index)
if (index < 1)
continue;
const auto &faces = edge2Face.FindFromIndex(index);
if(!faces.Extent())
if (faces.Extent() == 0)
continue;
const TopoDS_Face& aFace = TopoDS::Face(faces.First());
// take the face's triangulation instead
Handle(Poly_Triangulation) aPolyTria = BRep_Tool::Triangulation(aFace,aLoc);
if (!aLoc.IsIdentity()) {
myTransf = aLoc.Transformation();
}
if (aPolyTria.IsNull()) break;
// this holds the indices of the edge's triangulation to the actual points
Handle(Poly_PolygonOnTriangulation) aPoly = BRep_Tool::PolygonOnTriangulation(aEdge, aPolyTria, aLoc);
if (aPoly.IsNull())
continue; // polygon does not exist
// getting size and create the array
nbNodesInFace = aPoly->NbNodes();
const TColStd_Array1OfInteger& indices = aPoly->Nodes();
const TColgp_Array1OfPnt& Nodes = aPolyTria->Nodes();
gp_Pnt V;
// go through the index array
for (Standard_Integer i=indices.Lower();i <= indices.Upper();i++) {
V = Nodes(indices(i));
V.Transform(myTransf);
vertices.emplace_back(V.X(),V.Y(),V.Z());
}
if (!Part::Tools::getPolygonOnTriangulation(aEdge, aFace, points))
continue;
}
if(line_start+1 < vertices.size()) {
auto line_start = vertices.size();
vertices.reserve(vertices.size() + points.size());
std::for_each(points.begin(), points.end(), [&vertices](const gp_Pnt& p) {
vertices.push_back(Base::convertTo<Base::Vector3d>(p));
});
if (line_start+1 < vertices.size()) {
lines.emplace_back();
lines.back().I1 = line_start;
lines.back().I2 = vertices.size()-1;

10
src/Mod/Part/App/TopoShapeFacePyImp.cpp
View File

@@ -493,6 +493,15 @@ PyObject* TopoShapeFacePy::getUVNodes(PyObject *args)
return Py::new_reference_to(list);
}
#if OCC_VERSION_HEX >= 0x070600
for (int i=1; i<=mesh->NbNodes(); i++) {
gp_Pnt2d pt2d = mesh->UVNode(i);
Py::Tuple uv(2);
uv.setItem(0, Py::Float(pt2d.X()));
uv.setItem(1, Py::Float(pt2d.Y()));
list.append(uv);
}
#else
const TColgp_Array1OfPnt2d& aNodesUV = mesh->UVNodes();
for (int i=aNodesUV.Lower(); i<=aNodesUV.Upper(); i++) {
gp_Pnt2d pt2d = aNodesUV(i);
@@ -501,6 +510,7 @@ PyObject* TopoShapeFacePy::getUVNodes(PyObject *args)
uv.setItem(1, Py::Float(pt2d.Y()));
list.append(uv);
}
#endif
return Py::new_reference_to(list);
}

6
src/Mod/Part/App/TopoShapeWirePyImp.cpp
View File

@@ -344,9 +344,9 @@ PyObject* TopoShapeWirePy::approximate(PyObject *args, PyObject *kwds)
return 0;
try {
BRepAdaptor_CompCurve adapt(TopoDS::Wire(getTopoShapePtr()->getShape()));
Handle(Adaptor3d_HCurve) hcurve = adapt.Trim(adapt.FirstParameter(),
adapt.LastParameter(),
tol2d);
auto hcurve = adapt.Trim(adapt.FirstParameter(),
adapt.LastParameter(),
tol2d);
Approx_Curve3d approx(hcurve, tol3d, GeomAbs_C0, maxseg, maxdeg);
if (approx.IsDone()) {
return new BSplineCurvePy(new GeomBSplineCurve(approx.Curve()));

6
src/Mod/Part/Gui/TaskCheckGeometry.cpp
View File

@@ -711,8 +711,10 @@ int TaskCheckGeometryResults::goBOPSingleCheck(const TopoDS_Shape& shapeIn, Resu
#if OCC_VERSION_HEX >= 0x060900
#if OCC_VERSION_HEX < 0x070500
BOPCheck.SetProgressIndicator(theProgress);
#else
#elif OCC_VERSION_HEX < 0x070600
BOPCheck.SetProgressIndicator(theScope);
#else
Q_UNUSED(theScope)
#endif // 0x070500
#else
Q_UNUSED(theProgress);
@@ -740,7 +742,7 @@ int TaskCheckGeometryResults::goBOPSingleCheck(const TopoDS_Shape& shapeIn, Resu
Base::TimeInfo start_time;
#endif
BOPCheck.Perform();
BOPCheck.Perform();
#ifdef FC_DEBUG
float bopAlgoTime = Base::TimeInfo::diffTimeF(start_time,Base::TimeInfo());

17
src/Mod/Part/Gui/ViewProviderExt.cpp
View File

@@ -1083,16 +1083,25 @@ void ViewProviderPartExt::updateVisual()
// cycling through the poly mesh
#if OCC_VERSION_HEX < 0x070600
const Poly_Array1OfTriangle& Triangles = mesh->Triangles();
const TColgp_Array1OfPnt& Nodes = mesh->Nodes();
TColgp_Array1OfDir Normals (Nodes.Lower(), Nodes.Upper());
#else
int numNodes = mesh->NbNodes();
TColgp_Array1OfDir Normals (1, numNodes);
#endif
if (NormalsFromUV)
Part::Tools::getPointNormals(actFace, mesh, Normals);
for (int g=1;g<=nbTriInFace;g++) {
// Get the triangle
Standard_Integer N1,N2,N3;
#if OCC_VERSION_HEX < 0x070600
Triangles(g).Get(N1,N2,N3);
#else
mesh->Triangle(g).Get(N1,N2,N3);
#endif
// change orientation of the triangle if the face is reversed
if ( orient != TopAbs_FORWARD ) {
@@ -1102,7 +1111,11 @@ void ViewProviderPartExt::updateVisual()
}
// get the 3 points of this triangle
#if OCC_VERSION_HEX < 0x070600
gp_Pnt V1(Nodes(N1)), V2(Nodes(N2)), V3(Nodes(N3));
#else
gp_Pnt V1(mesh->Node(N1)), V2(mesh->Node(N2)), V3(mesh->Node(N3));
#endif
// get the 3 normals of this triangle
gp_Vec NV1, NV2, NV3;
@@ -1179,7 +1192,11 @@ void ViewProviderPartExt::updateVisual()
// rare cases where some points are only referenced by the polygon
// but not by any triangle. Thus, we must apply the coordinates to
// make sure that everything is properly set.
#if OCC_VERSION_HEX < 0x070600
gp_Pnt p(Nodes(nodeIndex));
#else
gp_Pnt p(mesh->Node(nodeIndex));
#endif
if (!identity)
p.Transform(myTransf);
verts[index].setValue((float)(p.X()),(float)(p.Y()),(float)(p.Z()));

5
src/Mod/Path/App/AppPathPy.cpp
View File

@@ -49,10 +49,7 @@
#include <TopExp_Explorer.hxx>
#include <gp_Lin.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_CompCurve.hxx>
#include <BRepAdaptor_HCompCurve.hxx>
#include <Approx_Curve3d.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <BRepAdaptor_Curve.hxx>
#include "CommandPy.h"
#include "PathPy.h"

12
src/Mod/TechDraw/App/Geometry.cpp
View File

@@ -28,13 +28,13 @@
#include <BRepAdaptor_Curve.hxx>
#include <BRep_Tool.hxx>
#include <BRepTools.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <BRepLib.hxx>
#include <BRepBuilderAPI_MakeVertex.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRepBuilderAPI_MakeWire.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <BRepExtrema_DistShapeShape.hxx>
#include <BRepLProp_CLProps.hxx>
#include <Precision.hxx>
#include <GCPnts_AbscissaPoint.hxx>
#include <gce_MakeCirc.hxx>
@@ -58,14 +58,16 @@
#include <GeomLProp_CLProps.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <Poly_Polygon3D.hxx>
#include <Standard_Version.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <BRepLProp_CLProps.hxx>
#if OCC_VERSION_HEX < 0x070600
#include <BRepAdaptor_HCurve.hxx>
#endif
#include <cmath>
#endif // #ifndef _PreComp_
@@ -86,6 +88,10 @@
using namespace TechDraw;
using namespace std;
#if OCC_VERSION_HEX >= 0x070600
using BRepAdaptor_HCurve = BRepAdaptor_Curve;
#endif
#define GEOMETRYEDGE 0
#define COSMETICEDGE 1
#define CENTERLINE 2