Loading files
f2929057eThis file is pinned to the selected release. Download the original to open it in your design tool.
// Created on: 1995-03-29
// Created by: Frederic MAUPAS
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
// gka 21.08.98 PRO7656
// gka 15.12.98 UKI60591 #1274560
// pdn 18.12.98 to keep pcurves
//: o0 abv 16.02.99: POLYLINE allowed as 3d curve of edge
//: abv 07.04.99: S4136: improve tolerance management and dealing with pcurves
// rln 02.06.99 removing #include <StepToTopoDS_DegeneratedTool.hxx>
// smh 31.01.01 BUC60810 : IsNull protection
#include <BRep_Builder.hxx>
#include <BRep_TEdge.hxx>
#include <BRep_Tool.hxx>
#include <ElCLib.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Plane.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_Surface.hxx>
#include <gp_Pnt.hxx>
#include <Precision.hxx>
#include <ShapeAlgo.hxx>
#include <ShapeAlgo_AlgoContainer.hxx>
#include <ShapeAlgo_ToolContainer.hxx>
#include <ShapeAnalysis_Curve.hxx>
#include <ShapeAnalysis_Edge.hxx>
#include <Standard_ErrorHandler.hxx>
#include <ShapeBuild_Edge.hxx>
#include <ShapeExtend_WireData.hxx>
#include <ShapeFix_EdgeProjAux.hxx>
#include <StdFail_NotDone.hxx>
#include <StepData_Factors.hxx>
#include <StepData_StepModel.hxx>
#include <StepGeom_Pcurve.hxx>
#include <StepGeom_Surface.hxx>
#include <StepGeom_SurfaceCurve.hxx>
#include <StepRepr_DefinitionalRepresentation.hxx>
#include <StepShape_EdgeCurve.hxx>
#include <StepShape_EdgeLoop.hxx>
#include <StepShape_FaceBound.hxx>
#include <StepShape_OrientedEdge.hxx>
#include <StepShape_Vertex.hxx>
#include <StepToGeom.hxx>
#include <StepToTopoDS.hxx>
#include <StepToTopoDS_GeometricTool.hxx>
#include <StepToTopoDS_NMTool.hxx>
#include <StepToTopoDS_Tool.hxx>
#include <StepToTopoDS_TranslateEdge.hxx>
#include <StepToTopoDS_TranslateEdgeLoop.hxx>
#include <StepToTopoDS_TranslateVertex.hxx>
#include <TopAbs.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Wire.hxx>
#include <Transfer_TransientProcess.hxx>
#include <XSAlgo.hxx>
#include <XSAlgo_ShapeProcessor.hxx>
//=================================================================================================
static void RemoveSinglePCurve(const TopoDS_Edge& aEdge, const TopoDS_Face& aFace)
{
ShapeBuild_Edge().RemovePCurve(aEdge, aFace);
}
//=================================================================================================
static void RemovePCurves(const TopoDS_Wire& aWire, const TopoDS_Face& aFace)
{
TopExp_Explorer EdgeExp(aWire, TopAbs_EDGE);
while (EdgeExp.More())
{
const TopoDS_Edge& myEdge = TopoDS::Edge(EdgeExp.Current());
RemoveSinglePCurve(myEdge, aFace);
EdgeExp.Next();
}
}
// ============================================================================
// Method : CheckPCurves
// Purpose : Checks the pcurves topological trimming parameter consistency
// and deviation between 2D ans 3D
// ============================================================================
static void CheckPCurves(TopoDS_Wire& aWire,
const TopoDS_Face& aFace,
const bool isPlane,
const double preci)
{
if (isPlane)
{
RemovePCurves(aWire, aFace);
return;
}
BRep_Builder B;
double w1, w2, cf, cl;
occ::handle<Geom_Surface> mySurf = BRep_Tool::Surface(aFace);
occ::handle<ShapeExtend_WireData> sbwd = new ShapeExtend_WireData(aWire);
for (int i = 1; i <= sbwd->NbEdges(); i++)
{
const TopoDS_Edge& myEdge = sbwd->Edge(i);
// First Check : 2D Parameters on Edge :
// Case 1 : w1 == w2 illegal => Drop the PCurve
// Case 2 : on bounded curve w1 < FirstParameter => w1 = FirstParameter
// w2 > LastParameter => w2 = LastParameter
occ::handle<Geom2d_Curve> thePC;
ShapeAnalysis_Edge sae;
if (!sae.PCurve(myEdge, aFace, thePC, w1, w2, false))
{
continue;
}
cf = thePC->FirstParameter();
cl = thePC->LastParameter();
if (w1 == w2)
{
RemoveSinglePCurve(myEdge, aFace);
#ifdef OCCT_DEBUG
std::cout << "Removing pcuve w1=w2" << std::endl;
#endif
continue;
}
// check parameters of range only for not periodic curves
if (!thePC->IsPeriodic())
{
if (w1 < cf)
{
B.Range(myEdge, aFace, cf, w2);
w1 = cf;
}
if (w2 > cl)
{
B.Range(myEdge, aFace, w1, cl);
w2 = cl;
}
}
if (w1 > w2 && mySurf->IsUPeriodic())
{
double u1, u2, v1, v2;
mySurf->Bounds(u1, u2, v1, v2);
ElCLib::AdjustPeriodic(u1,
u2,
std::min(std::abs(w2 - w1) / 2, Precision::PConfusion()),
w1,
w2);
B.Range(myEdge, aFace, w1, w2);
}
// advanced check
XSAlgo_ShapeProcessor::CheckPCurve(myEdge, aFace, preci, sbwd->IsSeam(i));
}
}
//=================================================================================================
StepToTopoDS_TranslateEdgeLoop::StepToTopoDS_TranslateEdgeLoop()
: myError(StepToTopoDS_TranslateEdgeLoopOther)
{
done = false;
}
// ============================================================================
// Method : StepToTopoDS_TranslateEdgeLoop::StepToTopoDS_TranslateEdgeLoop
// Purpose : Constructor with a FaceSurface and a Tool
// ============================================================================
StepToTopoDS_TranslateEdgeLoop::StepToTopoDS_TranslateEdgeLoop(
const occ::handle<StepShape_FaceBound>& FB,
const TopoDS_Face& Face,
const occ::handle<Geom_Surface>& GeomSurf,
const occ::handle<StepGeom_Surface>& StepSurf,
const bool sameSense,
StepToTopoDS_Tool& T,
StepToTopoDS_NMTool& NMTool,
const StepData_Factors& theLocalFactors)
{
Init(FB, Face, GeomSurf, StepSurf, sameSense, T, NMTool, theLocalFactors);
}
// ============================================================================
// Method : Init
// Purpose : Init with a EdgeLoop and a Tool
// ============================================================================
void StepToTopoDS_TranslateEdgeLoop::Init(const occ::handle<StepShape_FaceBound>& FaceBound,
const TopoDS_Face& Face,
const occ::handle<Geom_Surface>& GeomSurf,
const occ::handle<StepGeom_Surface>& StepSurf,
const bool sameSense,
StepToTopoDS_Tool& aTool,
StepToTopoDS_NMTool& NMTool,
const StepData_Factors& theLocalFactors)
{
done = true;
occ::handle<StepShape_EdgeLoop> EL = occ::down_cast<StepShape_EdgeLoop>(FaceBound->Bound());
if (aTool.IsBound(EL))
{
myResult = TopoDS::Wire(aTool.Find(EL));
myError = StepToTopoDS_TranslateEdgeLoopDone;
done = true;
return;
}
BRep_Builder B;
occ::handle<Transfer_TransientProcess> TP = aTool.TransientProcess();
occ::handle<StepData_StepModel> aStepModel = occ::down_cast<StepData_StepModel>(TP->Model());
int modepcurve = aStepModel->InternalParameters.ReadSurfaceCurveMode;
// 0,1 : suivre le code, 2 : ne prendre que pcurve, 3 : ne prendre que C3D
double preci = Precision();
TopoDS_Wire W;
TopoDS_Edge E;
TopoDS_Vertex V;
bool isSeam, isLikeSeam;
occ::handle<StepShape_OrientedEdge> OrEdge1, OrEdge2;
occ::handle<StepGeom_Curve> StepCurve, StepCurve1, StepCurve2;
occ::handle<StepRepr_DefinitionalRepresentation> DRI, Dri1, Dri2;
occ::handle<Geom2d_Curve> C2d, C2d1, C2d2, WhichC2d1, WhichC2d2;
TopoDS_Edge suspectE; //: f1, degEdge;
int j, NbEdge = EL->NbEdgeList();
if (NbEdge == 0)
{
TP->AddWarning(EL, "Wire not done. EdgeLoop does not contain edges.");
done = false;
return;
}
// PTV 16.09.2000
// default value set as true (if not correct see logic of algorithm).
bool hasPcurve = true;
bool isPlane = GeomSurf->IsKind(STANDARD_TYPE(Geom_Plane));
occ::handle<Geom_Surface> ConvSurf = GeomSurf;
if (GeomSurf->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface)))
{
occ::handle<Geom_RectangularTrimmedSurface> theRTS =
occ::down_cast<Geom_RectangularTrimmedSurface>(GeomSurf);
ConvSurf = theRTS->BasisSurface();
}
aTool.ComputePCurve(false);
// What is the Wire Orientation
bool ForwardWire = FaceBound->Orientation();
// --- Initialize target Wire ---
B.MakeWire(W);
// -----------------------------------------------
// Preparation : Make Vertices + Curves3d
// Hence, a closed curve limited by distinct vertices
// will give a unique vertex (if same coords)
//
// In addition : detect shared PCurve (cf SYRKO)
// This case may not be processed, PCurves has to be recomputed from scratch
// -----------------------------------------------
// int theSame = 1; //gka 15.12.98
for (j = 1; j <= NbEdge; j++)
{
OrEdge1 = EL->EdgeListValue(j);
if (OrEdge1.IsNull() || OrEdge1->EdgeElement().IsNull())
{
TP->AddWarning(
OrEdge1,
"Incorrect Oriented_Edge is not translated. Oriented_Edge definition is not correct");
continue;
}
// see bug #29979: oriented edge contains another oriented edge
if (OrEdge1->EdgeElement()->IsKind(STANDARD_TYPE(StepShape_OrientedEdge)))
{
OrEdge1 = occ::down_cast<StepShape_OrientedEdge>(OrEdge1->EdgeElement());
}
occ::handle<StepShape_EdgeCurve> EC =
occ::down_cast<StepShape_EdgeCurve>(OrEdge1->EdgeElement());
if (EC.IsNull())
{
TP->AddWarning(OrEdge1, "Edge does not contain EDGE_CURVE, skipped");
continue;
}
occ::handle<StepGeom_Curve> C = EC->EdgeGeometry();
if (!C.IsNull())
{
if (C->IsKind(STANDARD_TYPE(StepGeom_SurfaceCurve)))
{
occ::handle<StepGeom_SurfaceCurve> Sc = occ::down_cast<StepGeom_SurfaceCurve>(C);
C = Sc->Curve3d();
}
}
occ::handle<Geom_Curve> C1;
if (!C.IsNull())
{
try
{
OCC_CATCH_SIGNALS
C1 = occ::down_cast<Geom_Curve>(TP->FindTransient(C));
if (C1.IsNull())
{
C1 = StepToGeom::MakeCurve(C, theLocalFactors);
if (!C1.IsNull())
{
TP->BindTransient(C, C1);
}
else
{
TP->AddWarning(C, "Could not convert a curve. Curve definition is incorrect");
}
}
}
catch (Standard_Failure const& anException)
{
#ifdef OCCT_DEBUG
std::cout << "Warning: StepToTopoDS_TranslateEdgeLoop: Exception: ";
anException.Print(std::cout);
std::cout << std::endl;
#endif
(void)anException;
TP->AddFail(C, "Exception was raised. Curve geometry definition is incorrect");
}
}
occ::handle<StepShape_Vertex> Vstart, Vend;
if (EC->SameSense())
{
Vstart = EC->EdgeStart();
Vend = EC->EdgeEnd();
}
else
{
Vend = EC->EdgeStart();
Vstart = EC->EdgeEnd();
}
bool istV = aTool.IsBound(Vstart);
bool iseV = aTool.IsBound(Vend);
TopoDS_Vertex V1, V2;
StepToTopoDS_TranslateVertex myTranVertex1(Vstart, aTool, NMTool, theLocalFactors);
StepToTopoDS_TranslateVertex myTranVertex2(Vend, aTool, NMTool, theLocalFactors);
if (myTranVertex1.IsDone())
{
V1 = TopoDS::Vertex(myTranVertex1.Value());
}
if (myTranVertex2.IsDone())
{
V2 = TopoDS::Vertex(myTranVertex2.Value());
gp_Pnt p1 = BRep_Tool::Pnt(V1);
gp_Pnt p2 = BRep_Tool::Pnt(V2);
if (p1.Distance(p2) <= Precision::Confusion())
{ //: S4136: preci) {
bool Fixed = true;
if (!iseV)
{
aTool.Bind(Vend, V1); // gka 21.08.1998 bug PRO7656
}
else if (!istV)
{
aTool.Bind(Vstart, V2);
}
else
{
aTool.Bind(Vend, V1);
}
if (!C1.IsNull() && !C1->IsClosed() && Fixed)
{
TP->AddWarning(EL->EdgeListValue(j), "Vertex of same coordinates, set confused");
}
}
}
}
//: f6 abv 29 Apr 98: BUC50070 #3815: make sure that each two edges are
// connected by the same vertex; else check that vertices confuse
// and make it be one vertex
// NOTE: this is done only for the case if at least one of edges
// was not yet translated; else nothing will help
for (j = 1; j <= NbEdge; j++)
{
OrEdge1 = EL->EdgeListValue(j);
OrEdge2 = EL->EdgeListValue(j < NbEdge ? j + 1 : 1);
if (OrEdge1.IsNull() || OrEdge2.IsNull())
{
continue;
}
occ::handle<StepShape_EdgeCurve> EC1 =
occ::down_cast<StepShape_EdgeCurve>(OrEdge1->EdgeElement());
occ::handle<StepShape_EdgeCurve> EC2 =
occ::down_cast<StepShape_EdgeCurve>(OrEdge2->EdgeElement());
if (EC1.IsNull() || EC2.IsNull()) // see #29979
{
continue;
}
occ::handle<StepShape_Vertex> Vs1, Vs2, Vs11, Vs22;
Vs1 = (OrEdge1->Orientation() ? EC1->EdgeEnd() : EC1->EdgeStart());
Vs2 = (OrEdge2->Orientation() ? EC2->EdgeStart() : EC2->EdgeEnd());
Vs11 = (OrEdge1->Orientation() ? EC1->EdgeStart() : EC1->EdgeEnd());
Vs22 = (OrEdge2->Orientation() ? EC2->EdgeEnd() : EC2->EdgeStart());
if ((Vs1 == Vs2) || (Vs1 == Vs22) || (Vs2 == Vs11) || (Vs22 == Vs11))
{
continue;
}
StepToTopoDS_TranslateVertex myTranVertex1(Vs1, aTool, NMTool, theLocalFactors);
StepToTopoDS_TranslateVertex myTranVertex2(Vs2, aTool, NMTool, theLocalFactors);
TopoDS_Vertex V1, V2;
if (myTranVertex1.IsDone())
{
V1 = TopoDS::Vertex(myTranVertex1.Value());
}
if (myTranVertex2.IsDone())
{
V2 = TopoDS::Vertex(myTranVertex2.Value());
}
if (V1.IsNull() || V2.IsNull())
{
continue; // not treated
}
if (V1.IsSame(V2))
{
continue; // OK
}
gp_Pnt p1 = BRep_Tool::Pnt(V1);
gp_Pnt p2 = BRep_Tool::Pnt(V2);
bool locFixed = true;
if (p1.Distance(p2) <= preci)
{
if (!aTool.IsBound(EC1))
{
aTool.Bind(Vs1, V2);
}
else if (!aTool.IsBound(EC2))
{
aTool.Bind(Vs2, V1);
}
else
{
locFixed = false;
}
}
else
{
locFixed = false;
}
if (locFixed)
{
TP->AddWarning(EL, "Adjacent edges do not have common vertex; set confused");
}
else
{
TP->AddWarning(EL, "Adjacent edges are not connected");
}
}
// -----------------------------------------------
// Iteration on each Oriented Edge of the EdgeLoop
// -----------------------------------------------
for (j = 1; j <= NbEdge; j++)
{
bool ThereIsLikeSeam = false;
#ifdef OCCT_DEBUG
std::cout << " Processing Edge :" << j << std::endl;
#endif
OrEdge1 = EL->EdgeListValue(j);
if (OrEdge1.IsNull() || OrEdge1->EdgeElement().IsNull())
{
continue;
}
// see bug #29979: oriented edge contains another oriented edge
if (OrEdge1->EdgeElement()->IsKind(STANDARD_TYPE(StepShape_OrientedEdge)))
{
OrEdge1 = occ::down_cast<StepShape_OrientedEdge>(OrEdge1->EdgeElement());
}
occ::handle<StepShape_EdgeCurve> EC =
occ::down_cast<StepShape_EdgeCurve>(OrEdge1->EdgeElement());
if (EC.IsNull())
{
continue;
}
// ----------------
// Map the StepEdge
// ----------------
StepToTopoDS_TranslateEdge myTranEdge;
myTranEdge.SetPrecision(preci);
myTranEdge.SetMaxTol(MaxTol());
myTranEdge.Init(OrEdge1, aTool, NMTool, theLocalFactors);
if (myTranEdge.IsDone())
{
E = TopoDS::Edge(myTranEdge.Value());
if (E.IsNull())
{
continue; // NULL, on saute
}
occ::handle<StepGeom_Curve> C = EC->EdgeGeometry();
if (OrEdge1->Orientation() && EC->SameSense())
{
E.Orientation(TopAbs_FORWARD);
}
else if (!OrEdge1->Orientation() && !EC->SameSense())
{
E.Orientation(TopAbs_FORWARD);
}
else
{
E.Orientation(TopAbs_REVERSED);
}
isSeam = isLikeSeam = false;
// ------------------------------------------
// Map the StepEdge parametric representation
// ------------------------------------------
// --------------------------------------------
// CASE 1 : The Edge Geometry is of Pcurve Type
// --------------------------------------------
if (C.IsNull())
{
aTool.ComputePCurve(true);
hasPcurve = false;
}
else if (C->IsKind(STANDARD_TYPE(StepGeom_Pcurve)))
{
occ::handle<StepGeom_Pcurve> StepPCurve = occ::down_cast<StepGeom_Pcurve>(C);
C2d = myTranEdge.MakePCurve(StepPCurve, ConvSurf, theLocalFactors);
// -- Statistics --
aTool.AddContinuity(C2d);
}
// -----------------------------------------
// CASE 2 : The curve is a SurfaceCurve i.e.
// - a 3D Curve (mandatory)
// - 2 PCurveOrSurface
// If modepcurve = 3, PCurve are ignored here
// -----------------------------------------
else if (modepcurve == 3)
{
aTool.ComputePCurve(true);
hasPcurve = false;
}
else if (C->IsKind(STANDARD_TYPE(StepGeom_SurfaceCurve)))
{
// recouvre les cas SeamCurve et IntersectionCurve
occ::handle<StepGeom_SurfaceCurve> SurfCurve = occ::down_cast<StepGeom_SurfaceCurve>(C);
occ::handle<StepGeom_Pcurve> StepPCurve, StepPCurve1, StepPCurve2;
int lastpcurve = StepToTopoDS_GeometricTool::PCurve(SurfCurve, StepSurf, StepPCurve, 0);
hasPcurve = !StepPCurve.IsNull();
// De toute facon, on recalcule
if (isPlane)
{
hasPcurve = false;
}
// -------------------------------------------
// --- Special Mapping Cases : ---
// --- the SurfaceCurve is a SeamCurve ---
// --- or is like a seam curve ---
// --- (see CATIA cylinder) ---
// -------------------------------------------
isLikeSeam = StepToTopoDS_GeometricTool::IsLikeSeam(SurfCurve, StepSurf, EC, EL);
isSeam = StepToTopoDS_GeometricTool::IsSeamCurve(SurfCurve, StepSurf, EC, EL);
if (isSeam || isLikeSeam)
{
// isLikeSeam = Two faces on the same Surface
StepPCurve1 = SurfCurve->AssociatedGeometryValue(1).Pcurve();
StepPCurve2 = SurfCurve->AssociatedGeometryValue(2).Pcurve();
// clang-format off
if (StepPCurve1.IsNull() || StepPCurve2.IsNull()) { hasPcurve = false; //smh : BUC60810
// clang-format on
}
else
{
C2d1 = myTranEdge.MakePCurve(StepPCurve1, ConvSurf, theLocalFactors);
C2d2 = myTranEdge.MakePCurve(StepPCurve2, ConvSurf, theLocalFactors);
hasPcurve = (!C2d1.IsNull() && !C2d2.IsNull());
}
if (isLikeSeam)
{
suspectE = E;
ThereIsLikeSeam = true;
hasPcurve = true;
}
}
else if (hasPcurve)
{
// GeometricTool : Pcurve a retourne StepPCurve
while (lastpcurve > 0)
{
C2d1 = myTranEdge.MakePCurve(StepPCurve, ConvSurf, theLocalFactors);
if (C2d1.IsNull())
{
TP->AddWarning(
EC,
"Incorrect pcurve is not translated. Pcurve definition is not correct");
hasPcurve = false;
break;
}
else
{
C2d = C2d1;
}
lastpcurve =
StepToTopoDS_GeometricTool::PCurve(SurfCurve, StepSurf, StepPCurve, lastpcurve);
// -- Statistics --
aTool.AddContinuity(C2d);
}
}
if (!hasPcurve)
{
// The edge geometry has no 2D representation
aTool.ComputePCurve(true);
}
}
// ----------------------------------------------------------
// CASE 3 : The EdgeCurve Geometry is not a Pcurve
// nor a SurfaceCurve (i.e. it is a single 3D curve)
// ----------------------------------------------------------
else
{
aTool.ComputePCurve(true);
hasPcurve = false;
}
// ----------------------------------
// update the edge with the pcurve(s)
// ----------------------------------
if (hasPcurve && (isSeam || ThereIsLikeSeam))
{
// -----------------------------------------------------------
// The Edge is a Seam Edge : The pcurve which is FORWARD has
// to be identified
// -----------------------------------------------------------
if ((!C2d1.IsNull()) && (!C2d2.IsNull()))
{
TopAbs_Orientation CumulO, EdgeO, WireO, FaceO;
EdgeO = E.Orientation();
if (ForwardWire)
{
WireO = TopAbs_FORWARD;
}
else
{
WireO = TopAbs_REVERSED;
}
if (sameSense)
{
FaceO = TopAbs_FORWARD;
}
else
{
FaceO = TopAbs_REVERSED;
}
CumulO = TopAbs::Compose(EdgeO, WireO);
CumulO = TopAbs::Compose(CumulO, FaceO);
bool ForwardEdge = (CumulO == TopAbs_FORWARD);
int forwardPC = ShapeAnalysis_Curve().SelectForwardSeam(C2d1, C2d2);
if (forwardPC == 0)
{
TP->AddFail(EC, " Seam curve not mapped");
done = false;
myError = StepToTopoDS_TranslateEdgeLoopOther;
continue;
}
else if (!ForwardEdge)
{
forwardPC = 3 - forwardPC; // inverser 1-2
}
if (forwardPC == 1)
{
if (isSeam)
{
// When the edge is a Seam, it is better to find the topological
// trimming right now.
// Remarque : pour bien faire, il faudrait, si necessaire, recalculer
// les trois courbes de maniere a ce qu`elles soient
// immediatement Same Range et Same Parameter.
B.UpdateEdge(E, C2d1, C2d2, Face, 0.);
//: S4136 FindParameter(C2d1, C2d2, E, Face, preci);
}
else
{
B.UpdateEdge(E, C2d1, Face, 0.); // preci
}
}
else
{
if (isSeam)
{
// When the edge is a Seam, it is better to find the topological
// trimming right now.
B.UpdateEdge(E, C2d2, C2d1, Face, 0.);
//: S4136 FindParameter(C2d1, C2d2, E, Face, preci);
}
else
{
B.UpdateEdge(E, C2d2, Face, 0.);
}
}
}
else
{
TP->AddFail(EC, " Seam curve not mapped");
done = false;
myError = StepToTopoDS_TranslateEdgeLoopOther;
continue;
}
}
else
{
// ---------------------------
// The Edge is a "normal" edge
// ---------------------------
if (hasPcurve)
{
if (!C2d.IsNull() && !isLikeSeam)
{
B.UpdateEdge(E, C2d, Face, 0.);
}
else
{
TP->AddFail(EC, " Edge: Trimming of 2D curve failed");
done = false;
myError = StepToTopoDS_TranslateEdgeLoopOther;
continue;
}
}
}
if (E.IsNull())
{
TP->AddFail(EC, " an Edge not mapped");
done = false;
myError = StepToTopoDS_TranslateEdgeLoopOther;
}
}
else
{ // The Edge is Not mapped => switch to next wire ?
TP->AddFail(EC, " an Edge not mapped");
done = false;
myError = StepToTopoDS_TranslateEdgeLoopOther;
}
if (done)
{
B.Add(W, E); // on le fait ici. Sauf si erreur rencontree ... !
}
else
{
occ::handle<StepShape_Vertex> Vs1, Vs2;
Vs1 = EC->EdgeStart();
Vs2 = EC->EdgeEnd();
if (!Vs1.IsNull() && !Vs2.IsNull() && Vs1 == Vs2)
{
done = true;
TP->AddFail(EL, " Edge with equal vertices failed, scipped");
}
}
}
// The EdgeLoop is binded in the Wire
if (!done)
{
TP->AddFail(EL, "At least one edge failed : wire not done");
return;
}
W.Closed(BRep_Tool::IsClosed(W));
aTool.Bind(EL, W);
// ----------------------------------------------
// Computes the 2D parameter of Vertices on Edges
// ----------------------------------------------
// pdn compute parameter of Vertices using projecting
if (!aTool.ComputePCurve())
{
for (TopoDS_Iterator EdgeIt(W); EdgeIt.More(); EdgeIt.Next())
{
TopoDS_Edge edge = TopoDS::Edge(EdgeIt.Value());
occ::handle<ShapeFix_EdgeProjAux> myEdgePro =
ShapeAlgo::AlgoContainer()->ToolContainer()->EdgeProjAux();
myEdgePro->Init(Face, edge);
myEdgePro->Compute(preci);
if (myEdgePro->IsFirstDone() && myEdgePro->IsLastDone())
{
if (std::abs(myEdgePro->FirstParam() - myEdgePro->LastParam()) < Precision::PConfusion())
{
continue;
}
B.Range(edge, Face, myEdgePro->FirstParam(), myEdgePro->LastParam());
}
else
{
RemoveSinglePCurve(edge, Face);
#ifdef OCCT_DEBUG
std::cout << "Removing after prj" << std::endl;
#endif
}
}
}
myResult = W;
myError = StepToTopoDS_TranslateEdgeLoopDone;
done = true;
// Check des PCurves SYSTEMATIQUE, s il n y en a que quelques unes
CheckPCurves(W, Face, isPlane, preci);
}
//=================================================================================================
const TopoDS_Shape& StepToTopoDS_TranslateEdgeLoop::Value() const
{
StdFail_NotDone_Raise_if(!done, "StepToTopoDS_TranslateEdgeLoop::Value() - no result");
return myResult;
}
// ============================================================================
// Method : Error
// Purpose : Return the TranslateEdgeLoop error
// ============================================================================
StepToTopoDS_TranslateEdgeLoopError StepToTopoDS_TranslateEdgeLoop::Error() const
{
return myError;
}