lili/OCCT
1
0
Fork 0
mirror of https://github.com/Open-Cascade-SAS/OCCT.git synced 2026-08-28 22:08:25 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
1db80256771e1f34d7f62d2cd1f4b712072117bf
OCCT/src/ModelingData/TKBRep/BRep/BRep_Builder.cxx
T
Pasukhin Dmitry 1db8025677 Coding - Apply Clang-Tidy automatic fixes (#1245) 
Flags:
aChecks="modernize-deprecated-headers,modernize-redundant-void-arg,modernize-use-bool-literals,modernize-use-equals-default,modernize-use-equals-delete,modernize-use-nullptr,modernize-use-override,performance-avoid-endl,performance-move-constructor-init,readability-braces-around-statements,readability-delete-null-pointer,readability-redundant-control-flow,readability-redundant-declaration,readability-redundant-function-ptr-dereference,readability-redundant-member-init,readability-redundant-string-init,readability-static-accessed-through-instance"

clang-tidy version: 22.1.3
2026-04-29 15:04:38 +01:00

1466 lines
47 KiB
C++
Raw Blame History

// Created on: 1991-07-02
// Created by: Remi LEQUETTE
// Copyright (c) 1991-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.
#include <BRep_Builder.hxx>
#include <BRep_Curve3D.hxx>
#include <BRep_CurveOn2Surfaces.hxx>
#include <BRep_CurveOnClosedSurface.hxx>
#include <BRep_GCurve.hxx>
#include <BRep_PointRepresentation.hxx>
#include <NCollection_List.hxx>
#include <BRep_PointOnCurve.hxx>
#include <BRep_PointOnCurveOnSurface.hxx>
#include <BRep_PointOnSurface.hxx>
#include <BRep_Polygon3D.hxx>
#include <BRep_PolygonOnClosedSurface.hxx>
#include <BRep_PolygonOnClosedTriangulation.hxx>
#include <BRep_PolygonOnSurface.hxx>
#include <BRep_PolygonOnTriangulation.hxx>
#include <BRep_TEdge.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <Poly_Polygon2D.hxx>
#include <Poly_Polygon3D.hxx>
#include <Poly_PolygonOnTriangulation.hxx>
#include <Poly_Triangulation.hxx>
#include <Precision.hxx>
#include <Standard_DomainError.hxx>
#include <TopLoc_Location.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_LockedShape.hxx>
#include <TopoDS_Vertex.hxx>
//=================================================================================================
//=================================================================================================
// function : UpdateCurves
// purpose : Insert a 3d curve <C> with location <L>
// in a list of curve representations <lcr>
//=================================================================================================
static void UpdateCurves(NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr,
const occ::handle<Geom_Curve>& C,
const TopLoc_Location& L)
{
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
occ::handle<BRep_GCurve> GC;
double f = 0., l = 0.;
while (itcr.More())
{
GC = occ::down_cast<BRep_GCurve>(itcr.Value());
if (!GC.IsNull())
{
GC->Range(f, l);
if (GC->IsCurve3D())
{
break;
}
}
itcr.Next();
}
if (itcr.More())
{
itcr.Value()->Curve3D(C);
itcr.Value()->Location(L);
}
else
{
occ::handle<BRep_Curve3D> C3d = new BRep_Curve3D(C, L);
// test if there is already a range
if (!GC.IsNull())
{
C3d->SetRange(f, l);
}
lcr.Append(C3d);
}
}
//=================================================================================================
// function : UpdateCurves
// purpose : Insert a pcurve <C> on surface <S> with location <L>
// in a list of curve representations <lcr>
// Remove the pcurve on <S> from <lcr> if <C> is null
//=================================================================================================
static void UpdateCurves(NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr,
const occ::handle<Geom2d_Curve>& C,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L)
{
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
occ::handle<BRep_CurveRepresentation> cr;
occ::handle<BRep_GCurve> GC;
double f = -Precision::Infinite(), l = Precision::Infinite();
// search the range of the 3d curve
// and remove any existing representation
while (itcr.More())
{
GC = occ::down_cast<BRep_GCurve>(itcr.Value());
if (!GC.IsNull())
{
if (GC->IsCurve3D())
{
// if (!C.IsNull()) { //xpu031198, degenerate edge
// xpu151298 : parameters can be set for null curves
// see lbo & flo, to determine whether range is defined
// compare first and last parameters with default values.
GC->Range(f, l);
}
if (GC->IsCurveOnSurface(S, L))
{
// remove existing curve on surface
// cr is used to keep a reference on the curve representation
// this avoid deleting it as its content may be referenced by C or S
cr = itcr.Value();
lcr.Remove(itcr);
}
else
{
itcr.Next();
}
}
else
{
itcr.Next();
}
}
if (!C.IsNull())
{
occ::handle<BRep_CurveOnSurface> COS = new BRep_CurveOnSurface(C, S, L);
double aFCur = 0.0, aLCur = 0.0;
COS->Range(aFCur, aLCur);
if (!Precision::IsInfinite(f))
{
aFCur = f;
}
if (!Precision::IsInfinite(l))
{
aLCur = l;
}
COS->SetRange(aFCur, aLCur);
lcr.Append(COS);
}
}
//=================================================================================================
// function : UpdateCurves
// purpose : Insert a pcurve <C> on surface <S> with location <L>
// in a list of curve representations <lcr>
// Remove the pcurve on <S> from <lcr> if <C> is null
//=================================================================================================
static void UpdateCurves(NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr,
const occ::handle<Geom2d_Curve>& C,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L,
const gp_Pnt2d& Pf,
const gp_Pnt2d& Pl)
{
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
occ::handle<BRep_CurveRepresentation> cr;
occ::handle<BRep_GCurve> GC;
double f = -Precision::Infinite(), l = Precision::Infinite();
// search the range of the 3d curve
// and remove any existing representation
while (itcr.More())
{
GC = occ::down_cast<BRep_GCurve>(itcr.Value());
if (!GC.IsNull())
{
if (GC->IsCurve3D())
{
// if (!C.IsNull()) { //xpu031198, degenerate edge
// xpu151298 : parameters can be set for null curves
// see lbo & flo, to determine whether range is defined
// compare first and last parameters with default values.
GC->Range(f, l);
}
if (GC->IsCurveOnSurface(S, L))
{
// remove existing curve on surface
// cr is used to keep a reference on the curve representation
// this avoid deleting it as its content may be referenced by C or S
cr = itcr.Value();
lcr.Remove(itcr);
}
else
{
itcr.Next();
}
}
else
{
itcr.Next();
}
}
if (!C.IsNull())
{
occ::handle<BRep_CurveOnSurface> COS = new BRep_CurveOnSurface(C, S, L);
double aFCur = 0.0, aLCur = 0.0;
COS->Range(aFCur, aLCur);
if (!Precision::IsInfinite(f))
{
aFCur = f;
}
if (!Precision::IsInfinite(l))
{
aLCur = l;
}
COS->SetRange(aFCur, aLCur);
COS->SetUVPoints(Pf, Pl);
lcr.Append(COS);
}
}
//=================================================================================================
// function : UpdateCurves
// purpose : Insert two pcurves <C1,C2> on surface <S> with location <L>
// in a list of curve representations <lcr>
// Remove the pcurves on <S> from <lcr> if <C1> or <C2> is null
//=================================================================================================
static void UpdateCurves(NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr,
const occ::handle<Geom2d_Curve>& C1,
const occ::handle<Geom2d_Curve>& C2,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L)
{
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
occ::handle<BRep_CurveRepresentation> cr;
occ::handle<BRep_GCurve> GC;
double f = -Precision::Infinite(), l = Precision::Infinite();
while (itcr.More())
{
GC = occ::down_cast<BRep_GCurve>(itcr.Value());
if (!GC.IsNull())
{
if (GC->IsCurve3D())
{
GC->Range(f, l);
}
bool iscos = GC->IsCurveOnSurface(S, L);
if (iscos)
{
break;
}
}
itcr.Next();
}
if (itcr.More())
{
// cr is used to keep a reference on the curve representation
// this avoid deleting it as its content may be referenced by C or S
cr = itcr.Value();
lcr.Remove(itcr);
}
if (!C1.IsNull() && !C2.IsNull())
{
occ::handle<BRep_CurveOnClosedSurface> COS =
new BRep_CurveOnClosedSurface(C1, C2, S, L, GeomAbs_C0);
double aFCur = 0.0, aLCur = 0.0;
COS->Range(aFCur, aLCur);
if (!Precision::IsInfinite(f))
{
aFCur = f;
}
if (!Precision::IsInfinite(l))
{
aLCur = l;
}
COS->SetRange(aFCur, aLCur);
lcr.Append(COS);
}
}
//=================================================================================================
// function : UpdateCurves
// purpose : Insert two pcurves <C1,C2> on surface <S> with location <L>
// in a list of curve representations <lcr>
// Remove the pcurves on <S> from <lcr> if <C1> or <C2> is null
//=================================================================================================
static void UpdateCurves(NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr,
const occ::handle<Geom2d_Curve>& C1,
const occ::handle<Geom2d_Curve>& C2,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L,
const gp_Pnt2d& Pf,
const gp_Pnt2d& Pl)
{
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
occ::handle<BRep_CurveRepresentation> cr;
occ::handle<BRep_GCurve> GC;
double f = -Precision::Infinite(), l = Precision::Infinite();
while (itcr.More())
{
GC = occ::down_cast<BRep_GCurve>(itcr.Value());
if (!GC.IsNull())
{
if (GC->IsCurve3D())
{
GC->Range(f, l);
}
bool iscos = GC->IsCurveOnSurface(S, L);
if (iscos)
{
break;
}
}
itcr.Next();
}
if (itcr.More())
{
// cr is used to keep a reference on the curve representation
// this avoid deleting it as its content may be referenced by C or S
cr = itcr.Value();
lcr.Remove(itcr);
}
if (!C1.IsNull() && !C2.IsNull())
{
occ::handle<BRep_CurveOnClosedSurface> COS =
new BRep_CurveOnClosedSurface(C1, C2, S, L, GeomAbs_C0);
double aFCur = 0.0, aLCur = 0.0;
COS->Range(aFCur, aLCur);
if (!Precision::IsInfinite(f))
{
aFCur = f;
}
if (!Precision::IsInfinite(l))
{
aLCur = l;
}
COS->SetRange(aFCur, aLCur);
COS->SetUVPoints2(Pf, Pl);
lcr.Append(COS);
}
}
static void UpdateCurves(NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr,
const occ::handle<Geom_Surface>& S1,
const occ::handle<Geom_Surface>& S2,
const TopLoc_Location& L1,
const TopLoc_Location& L2,
const GeomAbs_Shape C)
{
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
while (itcr.More())
{
const occ::handle<BRep_CurveRepresentation>& cr = itcr.Value();
bool isregu = cr->IsRegularity(S1, S2, L1, L2);
if (isregu)
{
break;
}
itcr.Next();
}
if (itcr.More())
{
occ::handle<BRep_CurveRepresentation> cr = itcr.Value();
cr->Continuity(C);
}
else
{
occ::handle<BRep_CurveOn2Surfaces> COS = new BRep_CurveOn2Surfaces(S1, S2, L1, L2, C);
lcr.Append(COS);
}
}
static void UpdatePoints(NCollection_List<occ::handle<BRep_PointRepresentation>>& lpr,
double p,
const occ::handle<Geom_Curve>& C,
const TopLoc_Location& L)
{
NCollection_List<occ::handle<BRep_PointRepresentation>>::Iterator itpr(lpr);
while (itpr.More())
{
const occ::handle<BRep_PointRepresentation>& pr = itpr.Value();
bool isponc = pr->IsPointOnCurve(C, L);
if (isponc)
{
break;
}
itpr.Next();
}
if (itpr.More())
{
occ::handle<BRep_PointRepresentation> pr = itpr.Value();
pr->Parameter(p);
}
else
{
occ::handle<BRep_PointOnCurve> POC = new BRep_PointOnCurve(p, C, L);
lpr.Append(POC);
}
}
static void UpdatePoints(NCollection_List<occ::handle<BRep_PointRepresentation>>& lpr,
double p,
const occ::handle<Geom2d_Curve>& PC,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L)
{
NCollection_List<occ::handle<BRep_PointRepresentation>>::Iterator itpr(lpr);
while (itpr.More())
{
const occ::handle<BRep_PointRepresentation>& pr = itpr.Value();
bool isponcons = pr->IsPointOnCurveOnSurface(PC, S, L);
if (isponcons)
{
break;
}
itpr.Next();
}
if (itpr.More())
{
occ::handle<BRep_PointRepresentation> pr = itpr.Value();
pr->Parameter(p);
}
else
{
occ::handle<BRep_PointOnCurveOnSurface> POCS = new BRep_PointOnCurveOnSurface(p, PC, S, L);
lpr.Append(POCS);
}
}
static void UpdatePoints(NCollection_List<occ::handle<BRep_PointRepresentation>>& lpr,
double p1,
double p2,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L)
{
NCollection_List<occ::handle<BRep_PointRepresentation>>::Iterator itpr(lpr);
while (itpr.More())
{
const occ::handle<BRep_PointRepresentation>& pr = itpr.Value();
bool ispons = pr->IsPointOnSurface(S, L);
if (ispons)
{
break;
}
itpr.Next();
}
if (itpr.More())
{
occ::handle<BRep_PointRepresentation> pr = itpr.Value();
pr->Parameter(p1);
// pr->Parameter(p2); // skv
pr->Parameter2(p2); // skv
}
else
{
occ::handle<BRep_PointOnSurface> POS = new BRep_PointOnSurface(p1, p2, S, L);
lpr.Append(POS);
}
}
//=================================================================================================
void BRep_Builder::MakeFace(TopoDS_Face& F,
const occ::handle<Geom_Surface>& S,
const double Tol) const
{
occ::handle<BRep_TFace> TF = new BRep_TFace();
if (!F.IsNull() && F.Locked())
{
throw TopoDS_LockedShape("BRep_Builder::MakeFace");
}
TF->Surface(S);
TF->Tolerance(Tol);
MakeShape(F, TF);
}
//=================================================================================================
void BRep_Builder::MakeFace(TopoDS_Face& theFace,
const occ::handle<Poly_Triangulation>& theTriangulation) const
{
occ::handle<BRep_TFace> aTFace = new BRep_TFace();
if (!theFace.IsNull() && theFace.Locked())
{
throw TopoDS_LockedShape("BRep_Builder::MakeFace");
}
aTFace->Triangulation(theTriangulation);
MakeShape(theFace, aTFace);
}
//=================================================================================================
void BRep_Builder::MakeFace(
TopoDS_Face& theFace,
const NCollection_List<occ::handle<Poly_Triangulation>>& theTriangulations,
const occ::handle<Poly_Triangulation>& theActiveTriangulation) const
{
occ::handle<BRep_TFace> aTFace = new BRep_TFace();
if (!theFace.IsNull() && theFace.Locked())
{
throw TopoDS_LockedShape("BRep_Builder::MakeFace");
}
aTFace->Triangulations(theTriangulations, theActiveTriangulation);
MakeShape(theFace, aTFace);
}
//=================================================================================================
void BRep_Builder::MakeFace(TopoDS_Face& F,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L,
const double Tol) const
{
occ::handle<BRep_TFace> TF = new BRep_TFace();
if (!F.IsNull() && F.Locked())
{
throw TopoDS_LockedShape("BRep_Builder::MakeFace");
}
TF->Surface(S);
TF->Tolerance(Tol);
TF->Location(L);
MakeShape(F, TF);
}
//=================================================================================================
void BRep_Builder::UpdateFace(const TopoDS_Face& F,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L,
const double Tol) const
{
const occ::handle<BRep_TFace>& TF = *((occ::handle<BRep_TFace>*)&F.TShape());
if (TF->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateFace");
}
TF->Surface(S);
TF->Tolerance(Tol);
TF->Location(L.Predivided(F.Location()));
F.TShape()->Modified(true);
}
//=================================================================================================
void BRep_Builder::UpdateFace(const TopoDS_Face& theFace,
const occ::handle<Poly_Triangulation>& theTriangulation,
const bool theToReset) const
{
const occ::handle<BRep_TFace>& aTFace = *((occ::handle<BRep_TFace>*)&theFace.TShape());
if (aTFace->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateFace");
}
aTFace->Triangulation(theTriangulation, theToReset);
theFace.TShape()->Modified(true);
}
//=================================================================================================
void BRep_Builder::UpdateFace(const TopoDS_Face& F, const double Tol) const
{
const occ::handle<BRep_TFace>& TF = *((occ::handle<BRep_TFace>*)&F.TShape());
if (TF->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateFace");
}
TF->Tolerance(Tol);
F.TShape()->Modified(true);
}
//=================================================================================================
void BRep_Builder::NaturalRestriction(const TopoDS_Face& F, const bool N) const
{
const occ::handle<BRep_TFace>& TF = (*((occ::handle<BRep_TFace>*)&F.TShape()));
if (TF->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::NaturalRestriction");
}
TF->NaturalRestriction(N);
F.TShape()->Modified(true);
}
//=================================================================================================
void BRep_Builder::MakeEdge(TopoDS_Edge& E) const
{
occ::handle<BRep_TEdge> TE = new BRep_TEdge();
if (!E.IsNull() && E.Locked())
{
throw TopoDS_LockedShape("BRep_Builder::MakeEdge");
}
MakeShape(E, TE);
}
//=================================================================================================
void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const occ::handle<Geom_Curve>& C,
const TopLoc_Location& L,
const double Tol) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
}
const TopLoc_Location l = L.Predivided(E.Location());
UpdateCurves(TE->ChangeCurves(), C, l);
TE->UpdateTolerance(Tol);
TE->Modified(true);
}
//=================================================================================================
void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const occ::handle<Geom2d_Curve>& C,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L,
const double Tol) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
}
const TopLoc_Location l = L.Predivided(E.Location());
UpdateCurves(TE->ChangeCurves(), C, S, l);
TE->UpdateTolerance(Tol);
TE->Modified(true);
}
//=================================================================================================
// function : UpdateEdge
// purpose : for the second format (for XML Persistence)
//=================================================================================================
void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const occ::handle<Geom2d_Curve>& C,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L,
const double Tol,
const gp_Pnt2d& Pf,
const gp_Pnt2d& Pl) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
}
const TopLoc_Location l = L.Predivided(E.Location());
UpdateCurves(TE->ChangeCurves(), C, S, l, Pf, Pl);
TE->UpdateTolerance(Tol);
TE->Modified(true);
}
//=================================================================================================
void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const occ::handle<Geom2d_Curve>& C1,
const occ::handle<Geom2d_Curve>& C2,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L,
const double Tol) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
}
const TopLoc_Location l = L.Predivided(E.Location());
UpdateCurves(TE->ChangeCurves(), C1, C2, S, l);
TE->UpdateTolerance(Tol);
TE->Modified(true);
}
//=================================================================================================
// function : UpdateEdge
// purpose : for the second format (for XML Persistence)
//=================================================================================================
void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const occ::handle<Geom2d_Curve>& C1,
const occ::handle<Geom2d_Curve>& C2,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L,
const double Tol,
const gp_Pnt2d& Pf,
const gp_Pnt2d& Pl) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
}
const TopLoc_Location l = L.Predivided(E.Location());
UpdateCurves(TE->ChangeCurves(), C1, C2, S, l, Pf, Pl);
TE->UpdateTolerance(Tol);
TE->Modified(true);
}
//=================================================================================================
void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const occ::handle<Poly_Polygon3D>& P,
const TopLoc_Location& L) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
}
NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr = TE->ChangeCurves();
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
while (itcr.More())
{
if (itcr.Value()->IsPolygon3D())
{
if (P.IsNull())
{
lcr.Remove(itcr);
}
else
{
itcr.Value()->Polygon3D(P);
}
TE->Modified(true);
return;
}
itcr.Next();
}
const TopLoc_Location l = L.Predivided(E.Location());
occ::handle<BRep_Polygon3D> P3d = new BRep_Polygon3D(P, l);
lcr.Append(P3d);
TE->Modified(true);
}
//=================================================================================================
void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const occ::handle<Poly_PolygonOnTriangulation>& P,
const occ::handle<Poly_Triangulation>& T,
const TopLoc_Location& L) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
}
const TopLoc_Location l = L.Predivided(E.Location());
bool isModified = false;
NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr = TE->ChangeCurves();
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
occ::handle<BRep_CurveRepresentation> cr;
while (itcr.More())
{
if (itcr.Value()->IsPolygonOnTriangulation(T, l))
{
// cr is used to keep a reference on the curve representation
// this avoid deleting it as its content may be referenced by T
cr = itcr.Value();
lcr.Remove(itcr);
isModified = true;
break;
}
itcr.Next();
}
if (!P.IsNull())
{
occ::handle<BRep_PolygonOnTriangulation> PT = new BRep_PolygonOnTriangulation(P, T, l);
lcr.Append(PT);
isModified = true;
}
if (isModified)
{
TE->Modified(true);
}
}
//=================================================================================================
void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const occ::handle<Poly_PolygonOnTriangulation>& P1,
const occ::handle<Poly_PolygonOnTriangulation>& P2,
const occ::handle<Poly_Triangulation>& T,
const TopLoc_Location& L) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
}
const TopLoc_Location l = L.Predivided(E.Location());
bool isModified = false;
NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr = TE->ChangeCurves();
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
occ::handle<BRep_CurveRepresentation> cr;
while (itcr.More())
{
if (itcr.Value()->IsPolygonOnTriangulation(T, l)) // szv:was L
{
// cr is used to keep a reference on the curve representation
// this avoid deleting it as its content may be referenced by T
cr = itcr.Value();
lcr.Remove(itcr);
isModified = true;
break;
}
itcr.Next();
}
if (!P1.IsNull() && !P2.IsNull())
{
occ::handle<BRep_PolygonOnClosedTriangulation> PT =
new BRep_PolygonOnClosedTriangulation(P1, P2, T, l);
lcr.Append(PT);
isModified = true;
}
if (isModified)
{
TE->Modified(true);
}
}
//=================================================================================================
void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const occ::handle<Poly_Polygon2D>& P,
const TopoDS_Face& F) const
{
TopLoc_Location l;
const occ::handle<Geom_Surface>& S = BRep_Tool::Surface(F, l);
UpdateEdge(E, P, S, l);
}
//=================================================================================================
void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const occ::handle<Poly_Polygon2D>& P,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
}
TopLoc_Location l = L.Predivided(E.Location());
NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr = TE->ChangeCurves();
occ::handle<BRep_CurveRepresentation> cr;
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
while (itcr.More())
{
if (itcr.Value()->IsPolygonOnSurface(S, l))
{
break;
}
itcr.Next();
}
if (itcr.More())
{
// cr is used to keep a reference on the curve representation
// this avoid deleting it as its content may be referenced by T
cr = itcr.Value();
lcr.Remove(itcr);
}
if (!P.IsNull())
{
occ::handle<BRep_PolygonOnSurface> PS = new BRep_PolygonOnSurface(P, S, l);
lcr.Append(PS);
}
TE->Modified(true);
}
//=================================================================================================
void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const occ::handle<Poly_Polygon2D>& P1,
const occ::handle<Poly_Polygon2D>& P2,
const TopoDS_Face& F) const
{
TopLoc_Location l;
const occ::handle<Geom_Surface>& S = BRep_Tool::Surface(F, l);
UpdateEdge(E, P1, P2, S, l);
}
//=================================================================================================
void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const occ::handle<Poly_Polygon2D>& P1,
const occ::handle<Poly_Polygon2D>& P2,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
}
TopLoc_Location l = L.Predivided(E.Location());
NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr = TE->ChangeCurves();
occ::handle<BRep_CurveRepresentation> cr;
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
while (itcr.More())
{
if (itcr.Value()->IsPolygonOnSurface(S, l))
{
break;
}
itcr.Next();
}
if (itcr.More())
{
// cr is used to keep a reference on the curve representation
// this avoid deleting it as its content may be referenced by T
cr = itcr.Value();
lcr.Remove(itcr);
}
if (!P1.IsNull() && !P2.IsNull())
{
occ::handle<BRep_PolygonOnClosedSurface> PS =
new BRep_PolygonOnClosedSurface(P1, P2, S, TopLoc_Location());
lcr.Append(PS);
}
TE->Modified(true);
}
//=================================================================================================
void BRep_Builder::UpdateEdge(const TopoDS_Edge& E, const double Tol) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
}
TE->UpdateTolerance(Tol);
TE->Modified(true);
}
//=================================================================================================
void BRep_Builder::Continuity(const TopoDS_Edge& E,
const TopoDS_Face& F1,
const TopoDS_Face& F2,
const GeomAbs_Shape C) const
{
TopLoc_Location l1, l2;
const occ::handle<Geom_Surface>& S1 = BRep_Tool::Surface(F1, l1);
const occ::handle<Geom_Surface>& S2 = BRep_Tool::Surface(F2, l2);
Continuity(E, S1, S2, l1, l2, C);
}
//=================================================================================================
void BRep_Builder::Continuity(const TopoDS_Edge& E,
const occ::handle<Geom_Surface>& S1,
const occ::handle<Geom_Surface>& S2,
const TopLoc_Location& L1,
const TopLoc_Location& L2,
const GeomAbs_Shape C) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::Continuity");
}
const TopLoc_Location l1 = L1.Predivided(E.Location());
const TopLoc_Location l2 = L2.Predivided(E.Location());
UpdateCurves(TE->ChangeCurves(), S1, S2, l1, l2, C);
TE->Modified(true);
}
//=================================================================================================
void BRep_Builder::SameParameter(const TopoDS_Edge& E, const bool S) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::SameParameter");
}
TE->SameParameter(S);
TE->Modified(true);
}
//=================================================================================================
void BRep_Builder::SameRange(const TopoDS_Edge& E, const bool S) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::SameRange");
}
TE->SameRange(S);
TE->Modified(true);
}
//=================================================================================================
void BRep_Builder::Degenerated(const TopoDS_Edge& E, const bool D) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::Degenerated");
}
TE->Degenerated(D);
if (D)
{
// set a null 3d curve
UpdateCurves(TE->ChangeCurves(), occ::handle<Geom_Curve>(), E.Location());
}
TE->Modified(true);
}
//=================================================================================================
void BRep_Builder::Range(const TopoDS_Edge& E,
const double First,
const double Last,
const bool Only3d) const
{
// set the range to all the representations if Only3d=FALSE
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::Range");
}
NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr = TE->ChangeCurves();
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
occ::handle<BRep_GCurve> GC;
while (itcr.More())
{
GC = occ::down_cast<BRep_GCurve>(itcr.Value());
if (!GC.IsNull() && (!Only3d || GC->IsCurve3D()))
{
GC->SetRange(First, Last);
}
itcr.Next();
}
TE->Modified(true);
}
//=================================================================================================
void BRep_Builder::Range(const TopoDS_Edge& E,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L,
const double First,
const double Last) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::Range");
}
const TopLoc_Location l = L.Predivided(E.Location());
NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr = TE->ChangeCurves();
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
occ::handle<BRep_GCurve> GC;
while (itcr.More())
{
GC = occ::down_cast<BRep_GCurve>(itcr.Value());
if (!GC.IsNull() && GC->IsCurveOnSurface(S, l))
{
GC->SetRange(First, Last);
break;
}
itcr.Next();
}
if (!itcr.More())
{
throw Standard_DomainError("BRep_Builder::Range, no pcurve");
}
TE->Modified(true);
}
//=================================================================================================
void BRep_Builder::Transfert(const TopoDS_Edge& Ein, const TopoDS_Edge& Eout) const
{
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&Ein.TShape());
const double tol = TE->Tolerance();
const NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr = TE->Curves();
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
while (itcr.More())
{
const occ::handle<BRep_CurveRepresentation>& CR = itcr.Value();
if (CR->IsCurveOnSurface())
{
UpdateEdge(Eout, CR->PCurve(), CR->Surface(), Ein.Location() * CR->Location(), tol);
}
else if (CR->IsCurveOnClosedSurface())
{
UpdateEdge(Eout,
CR->PCurve(),
CR->PCurve2(),
CR->Surface(),
Ein.Location() * CR->Location(),
tol);
}
if (CR->IsRegularity())
{
Continuity(Eout,
CR->Surface(),
CR->Surface2(),
Ein.Location() * CR->Location(),
Ein.Location() * CR->Location2(),
CR->Continuity());
}
itcr.Next();
}
}
//=================================================================================================
void BRep_Builder::UpdateVertex(const TopoDS_Vertex& V, const gp_Pnt& P, const double Tol) const
{
const occ::handle<BRep_TVertex>& TV = *((occ::handle<BRep_TVertex>*)&V.TShape());
if (TV->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
}
TV->Pnt(P.Transformed(V.Location().Inverted().Transformation()));
TV->UpdateTolerance(Tol);
TV->Modified(true);
}
//=================================================================================================
// function : UpdateVertex
// purpose : update vertex with parameter on edge
//=================================================================================================
void BRep_Builder::UpdateVertex(const TopoDS_Vertex& V,
const double Par,
const TopoDS_Edge& E,
const double Tol) const
{
if (Precision::IsPositiveInfinite(Par) || Precision::IsNegativeInfinite(Par))
{
throw Standard_DomainError("BRep_Builder::Infinite parameter");
}
const occ::handle<BRep_TVertex>& TV = *((occ::handle<BRep_TVertex>*)&V.TShape());
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TV->Locked() || TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
}
TopLoc_Location L = E.Location().Predivided(V.Location());
// Search the vertex in the edge
TopAbs_Orientation ori = TopAbs_INTERNAL;
TopoDS_Iterator itv(E.Oriented(TopAbs_FORWARD));
// if the edge has no vertices
// and is degenerated use the vertex orientation
// RLE, june 94
if (!itv.More() && TE->Degenerated())
{
ori = V.Orientation();
}
while (itv.More())
{
const TopoDS_Shape& Vcur = itv.Value();
if (V.IsSame(Vcur))
{
ori = Vcur.Orientation();
if (ori == V.Orientation())
{
break;
}
}
itv.Next();
}
NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr = TE->ChangeCurves();
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
occ::handle<BRep_GCurve> GC;
while (itcr.More())
{
GC = occ::down_cast<BRep_GCurve>(itcr.Value());
if (!GC.IsNull())
{
if (ori == TopAbs_FORWARD)
{
GC->First(Par);
}
else if (ori == TopAbs_REVERSED)
{
GC->Last(Par);
}
else
{
NCollection_List<occ::handle<BRep_PointRepresentation>>& lpr = TV->ChangePoints();
const TopLoc_Location& GCloc = GC->Location();
TopLoc_Location LGCloc = L * GCloc;
if (GC->IsCurve3D())
{
const occ::handle<Geom_Curve>& GC3d = GC->Curve3D();
UpdatePoints(lpr, Par, GC3d, LGCloc);
}
else if (GC->IsCurveOnSurface())
{
const occ::handle<Geom2d_Curve>& GCpc = GC->PCurve();
const occ::handle<Geom_Surface>& GCsu = GC->Surface();
UpdatePoints(lpr, Par, GCpc, GCsu, LGCloc);
}
}
}
itcr.Next();
}
if ((ori != TopAbs_FORWARD) && (ori != TopAbs_REVERSED))
{
TV->Modified(true);
}
TV->UpdateTolerance(Tol);
TE->Modified(true);
}
//=================================================================================================
// function : UpdateVertex
// purpose : update vertex with parameter on edge on face
//=================================================================================================
void BRep_Builder::UpdateVertex(const TopoDS_Vertex& V,
const double Par,
const TopoDS_Edge& E,
const occ::handle<Geom_Surface>& S,
const TopLoc_Location& L,
const double Tol) const
{
if (Precision::IsPositiveInfinite(Par) || Precision::IsNegativeInfinite(Par))
{
throw Standard_DomainError("BRep_Builder::Infinite parameter");
}
// Find the curve representation
TopLoc_Location l = L.Predivided(V.Location());
const occ::handle<BRep_TVertex>& TV = *((occ::handle<BRep_TVertex>*)&V.TShape());
const occ::handle<BRep_TEdge>& TE = *((occ::handle<BRep_TEdge>*)&E.TShape());
if (TV->Locked() || TE->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
}
// Search the vertex in the edge
TopAbs_Orientation ori = TopAbs_INTERNAL;
TopoDS_Iterator itv(E.Oriented(TopAbs_FORWARD));
// if the edge has no vertices
// and is degenerated use the vertex orientation
// RLE, june 94
if (!itv.More() && TE->Degenerated())
{
ori = V.Orientation();
}
while (itv.More())
{
const TopoDS_Shape& Vcur = itv.Value();
if (V.IsSame(Vcur))
{
ori = Vcur.Orientation();
if (ori == V.Orientation())
{
break;
}
}
itv.Next();
}
NCollection_List<occ::handle<BRep_CurveRepresentation>>& lcr = TE->ChangeCurves();
NCollection_List<occ::handle<BRep_CurveRepresentation>>::Iterator itcr(lcr);
occ::handle<BRep_GCurve> GC;
while (itcr.More())
{
GC = occ::down_cast<BRep_GCurve>(itcr.Value());
if (!GC.IsNull())
{
// if (GC->IsCurveOnSurface(S,l)) {
if (GC->IsCurveOnSurface(S, L))
{ // xpu020198 : BUC60407
if (ori == TopAbs_FORWARD)
{
GC->First(Par);
}
else if (ori == TopAbs_REVERSED)
{
GC->Last(Par);
}
else
{
NCollection_List<occ::handle<BRep_PointRepresentation>>& lpr = TV->ChangePoints();
const occ::handle<Geom2d_Curve>& GCpc = GC->PCurve();
UpdatePoints(lpr, Par, GCpc, S, l);
TV->Modified(true);
}
break;
}
}
itcr.Next();
}
if (!itcr.More())
{
throw Standard_DomainError("BRep_Builder:: no pcurve");
}
TV->UpdateTolerance(Tol);
TE->Modified(true);
}
//=================================================================================================
// function : UpdateVertex
// purpose : update vertex with parameters on face
//=================================================================================================
void BRep_Builder::UpdateVertex(const TopoDS_Vertex& Ve,
const double U,
const double V,
const TopoDS_Face& F,
const double Tol) const
{
const occ::handle<BRep_TVertex>& TV = *((occ::handle<BRep_TVertex>*)&Ve.TShape());
if (TV->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
}
TopLoc_Location L;
const occ::handle<Geom_Surface>& S = BRep_Tool::Surface(F, L);
L = L.Predivided(Ve.Location());
NCollection_List<occ::handle<BRep_PointRepresentation>>& lpr = TV->ChangePoints();
UpdatePoints(lpr, U, V, S, L);
TV->UpdateTolerance(Tol);
TV->Modified(true);
}
//=================================================================================================
void BRep_Builder::UpdateVertex(const TopoDS_Vertex& V, const double Tol) const
{
const occ::handle<BRep_TVertex>& TV = *((occ::handle<BRep_TVertex>*)&V.TShape());
if (TV->Locked())
{
throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
}
TV->UpdateTolerance(Tol);
TV->Modified(true);
}
//=================================================================================================
void BRep_Builder::Transfert(const TopoDS_Edge& Ein,
const TopoDS_Edge& Eout,
const TopoDS_Vertex& Vin,
const TopoDS_Vertex& Vout) const
{
const double tol = BRep_Tool::Tolerance(Vin);
const double parin = BRep_Tool::Parameter(Vin, Ein);
UpdateVertex(Vout, parin, Eout, tol);
}
Reference in New Issue View Git Blame Copy Permalink