OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-09 13:22:24 +03:00
Code Activity

0024940: WOK: Cyclic dependency detected between: BOPInt IntTools

Browse Source 
Classes  BOPInt_Context, BOPInt_ShrunkRange, BOPInt_Tools have been removed.
Package BOPInt has been removed
Classes IntTools_Context, IntTools_ShrunkRange have been added to replace corresponding BOPInt_ classes.
The classes provide same functionality as corresponding BOPInt_ classes.
Classes :
BOPAlgo_ArgumentAnalyzer
BOPAlgo_Builder
BOPAlgo_BuilderArea
BOPAlgo_BuilderFace
BOPAlgo_BuilderSolid
BOPAlgo_CheckerSI
BOPAlgo_PaveFiller
BOPAlgo_ShellSplitter
BOPTools_AlgoTools3D
BRepFill_TrimShellCorner
IntTools_BeanFaceIntersector
IntTools_EdgeFace
IntTools_FaceFace
IntTools_Tools
have been modified to use new classes IntTools_Context IntTools_ShrunkRange

Class IntTools_Tools has been modofied to provide the functionality that was in BOPInt_Tools.
This commit is contained in:
pkv
2014-05-26 10:48:29 +04:00
committed by apn
parent 68bd84a5f0
commit 1e143abba6
45 changed files with 1798 additions and 1972 deletions
Download Patch File Download Diff File Expand all files Collapse all files

167
src/IntTools/IntTools.cdl
View File

@@ -15,8 +15,8 @@
package IntTools
---Purpose: Contains classes for intersection and classification
--- purposes and accompanying classes
---Purpose: Contains classes for intersection and classification
--- purposes and accompanying classes
uses
TCollection,
@@ -43,186 +43,191 @@ uses
BRepClass3d,
TColgp,
MMgt,
BOPInt
Geom2dHatch,
BOPCol
is
class Range;
class CommonPrt;
class Root;
class Compare;
class CompareRange;
class Context;
class ShrunkRange;
--
class Range;
class CommonPrt;
class Root;
class Compare;
class CompareRange;
class EdgeEdge;
---Purpose: class provides the Edge/Edge algorithm
---Purpose: class provides the Edge/Edge algorithm
class EdgeFace;
---Purpose: class provides the Edge/Face algorithm
---Purpose: class provides the Edge/Face algorithm
class FClass2d;
---Purpose: class provides classification of a point in a face
---Purpose: class provides classification of a point in a face
class LineConstructor;
---Purpose: class provides post-processing of results of
--- surfaces intersection
---Purpose: class provides post-processing of results of
--- surfaces intersection
-----
class MarkedRangeSet;
---Purpose: auxiliary class for range management
---Purpose: auxiliary class for range management
class BaseRangeSample;
---Purpose: base class for range index management
---Purpose: base class for range index management
class CurveRangeSample;
---Purpose: class for range index management of curve
---Purpose: class for range index management of curve
class SurfaceRangeSample;
---Purpose: class for range index management of surface
---Purpose: class for range index management of surface
class CurveRangeLocalizeData;
class SurfaceRangeLocalizeData;
class BeanFaceIntersector;
---Purpose: class provides computing ranges of parameters
--- of edge/face intersection.
---Purpose: class provides computing ranges of parameters
--- of edge/face intersection.
-----
class Curve;
---Purpose: class is a container of
--- one 3d curve
--- two 2d curves
---Purpose: class is a container of
--- one 3d curve
--- two 2d curves
-----
class PntOnFace;
class PntOn2Faces;
class TopolTool;
---Purpose: class redefines TopolTool from Adaptor3d
---Purpose: class redefines TopolTool from Adaptor3d
class FaceFace;
---Purpose: class provides the Face/Face algorithm
---Purpose: class provides the Face/Face algorithm
---
class Tools;
---Purpose: class is a container of usefull geometrical and
--- topological algorithms
---Purpose: class is a container of usefull geometrical and
--- topological algorithms
generic class CArray1;
---
--- I n s t a n t i a t i o n s
---
class SequenceOfPntOn2Faces instantiates
Sequence from TCollection(PntOn2Faces from IntTools);
Sequence from TCollection(PntOn2Faces from IntTools);
--
class SequenceOfCurves instantiates
Sequence from TCollection(Curve from IntTools);
Sequence from TCollection(Curve from IntTools);
class SequenceOfRanges instantiates
Sequence from TCollection(Range from IntTools);
Sequence from TCollection(Range from IntTools);
class CArray1OfInteger instantiates
CArray1(Integer from Standard);
CArray1(Integer from Standard);
class CArray1OfReal instantiates
CArray1(Real from Standard);
CArray1(Real from Standard);
class SequenceOfRoots instantiates
Sequence from TCollection(Root from IntTools);
Sequence from TCollection(Root from IntTools);
class Array1OfRoots instantiates
Array1 from TCollection (Root from IntTools);
Array1 from TCollection (Root from IntTools);
class Array1OfRange instantiates
Array1 from TCollection (Range from IntTools);
Array1 from TCollection (Range from IntTools);
class QuickSort instantiates
QuickSort from SortTools (Root from IntTools,
Array1OfRoots from IntTools,
Compare from IntTools);
QuickSort from SortTools (Root from IntTools,
Array1OfRoots from IntTools,
Compare from IntTools);
class QuickSortRange instantiates
QuickSort from SortTools (Range from IntTools,
Array1OfRange from IntTools,
CompareRange from IntTools);
QuickSort from SortTools (Range from IntTools,
Array1OfRange from IntTools,
CompareRange from IntTools);
class SequenceOfCommonPrts instantiates
Sequence from TCollection(CommonPrt from IntTools);
Sequence from TCollection(CommonPrt from IntTools);
class IndexedDataMapOfTransientAddress instantiates
IndexedDataMap from TCollection(Transient from Standard,
Address from Standard,
MapTransientHasher from TColStd);
IndexedDataMap from TCollection(Transient from Standard,
Address from Standard,
MapTransientHasher from TColStd);
--modified by NIZHNY-MKK Wed Oct 5 18:06:39 2005
class ListOfCurveRangeSample instantiates
List from TCollection(CurveRangeSample from IntTools);
List from TCollection(CurveRangeSample from IntTools);
class ListOfSurfaceRangeSample instantiates
List from TCollection(SurfaceRangeSample from IntTools);
List from TCollection(SurfaceRangeSample from IntTools);
class ListOfBox instantiates
List from TCollection(Box from Bnd);
List from TCollection(Box from Bnd);
class CurveRangeSampleMapHasher;
---Purpose: class for range index management of curve
---Purpose: class for range index management of curve
class SurfaceRangeSampleMapHasher;
class MapOfCurveSample instantiates
Map from TCollection(CurveRangeSample from IntTools,
Map from TCollection(CurveRangeSample from IntTools,
CurveRangeSampleMapHasher from IntTools);
class MapOfSurfaceSample instantiates
Map from TCollection(SurfaceRangeSample from IntTools,
SurfaceRangeSampleMapHasher from IntTools);
Map from TCollection(SurfaceRangeSample from IntTools,
SurfaceRangeSampleMapHasher from IntTools);
class DataMapOfCurveSampleBox instantiates
DataMap from TCollection(CurveRangeSample from IntTools,
Box from Bnd,
CurveRangeSampleMapHasher from IntTools);
DataMap from TCollection(CurveRangeSample from IntTools,
Box from Bnd,
CurveRangeSampleMapHasher from IntTools);
class DataMapOfSurfaceSampleBox instantiates
DataMap from TCollection(SurfaceRangeSample from IntTools,
Box from Bnd,
SurfaceRangeSampleMapHasher from IntTools);
DataMap from TCollection(SurfaceRangeSample from IntTools,
Box from Bnd,
SurfaceRangeSampleMapHasher from IntTools);
-----------------------------------------------------
-- Block of static functions
-----------------------------------------------------
Length (E : Edge from TopoDS)
returns Real from Standard;
---Purpose: returns the length of the edge;
returns Real from Standard;
---Purpose: returns the length of the edge;
RemoveIdenticalRoots (aSeq :out SequenceOfRoots from IntTools;
anEpsT: Real from Standard);
anEpsT: Real from Standard);
---Purpose: Remove from the sequence aSeq the Roots that have
-- values ti and tj such as |ti-tj] < anEpsT.
SortRoots (aSeq :out SequenceOfRoots from IntTools;
anEpsT: Real from Standard);
anEpsT: Real from Standard);
---Purpose: Sort the sequence aSeq of the Roots to arrange the
-- Roons in increasing order
-- Roons in increasing order
FindRootStates (aSeq :out SequenceOfRoots from IntTools;
anEpsNull: Real from Standard);
---Purpose: Find the states (before and after) for each Root
-- from the sequence aSeq
Parameter (P : Pnt from gp;
Curve : Curve from Geom;
aParm : out Real from Standard)
returns Integer from Standard;
Curve : Curve from Geom;
aParm : out Real from Standard)
returns Integer from Standard;
GetRadius(C: Curve from BRepAdaptor;
t1,t3:Real from Standard;
R:out Real from Standard)
t1,t3:Real from Standard;
R:out Real from Standard)
returns Integer from Standard;
PrepareArgs(C: in out Curve from BRepAdaptor;
tMax,tMin: Real from Standard;
Discret : Integer from Standard;
Deflect : Real from Standard;
anArgs : out CArray1OfReal from IntTools)
Discret : Integer from Standard;
Deflect : Real from Standard;
anArgs : out CArray1OfReal from IntTools)
returns Integer from Standard;
end IntTools;

246
src/IntTools/IntTools_BeanFaceIntersector.cdl
View File

@@ -28,14 +28,14 @@ uses
SequenceOfRoots from IntTools,
MarkedRangeSet from IntTools,
SequenceOfRanges from IntTools,
Context from BOPInt,
Context from IntTools,
ExtCS from Extrema,
ProjectPointOnSurf from GeomAPI,
Edge from TopoDS,
Face from TopoDS,
Curve from BRepAdaptor,
Surface from BRepAdaptor,
Box from Bnd,
Box from Bnd,
CurveRangeSample from IntTools,
SurfaceRangeSample from IntTools,
ListOfCurveRangeSample from IntTools,
@@ -48,176 +48,176 @@ is
Create returns BeanFaceIntersector from IntTools;
Create(theEdge: Edge from TopoDS;
theFace: Face from TopoDS)
returns BeanFaceIntersector from IntTools;
---Purpose:
--- Initializes the algorithm
---
-- Warning:
--- The parts of the edge which are on
--- the surface of the face and belong to
--- the whole in the face (if there is)
--- is considered as result
---
theFace: Face from TopoDS)
returns BeanFaceIntersector from IntTools;
---Purpose:
--- Initializes the algorithm
---
-- Warning:
--- The parts of the edge which are on
--- the surface of the face and belong to
--- the whole in the face (if there is)
--- is considered as result
---
Create(theCurve : Curve from BRepAdaptor;
theSurface : Surface from BRepAdaptor;
theBeanTolerance: Real from Standard;
theFaceTolerance: Real from Standard)
returns BeanFaceIntersector from IntTools;
---Purpose:
--- Initializes the algorithm
---
theSurface : Surface from BRepAdaptor;
theBeanTolerance: Real from Standard;
theFaceTolerance: Real from Standard)
returns BeanFaceIntersector from IntTools;
---Purpose:
--- Initializes the algorithm
---
Create(theCurve : Curve from BRepAdaptor;
theSurface : Surface from BRepAdaptor;
theFirstParOnCurve: Real from Standard;
theLastParOnCurve : Real from Standard;
theUMinParameter : Real from Standard;
theUMaxParameter : Real from Standard;
theVMinParameter : Real from Standard;
theVMaxParameter : Real from Standard;
theBeanTolerance : Real from Standard;
theFaceTolerance : Real from Standard)
returns BeanFaceIntersector from IntTools;
---Purpose:
--- Initializes the algorithm
--- theUMinParameter, ... are used for
--- optimization purposes
---
theSurface : Surface from BRepAdaptor;
theFirstParOnCurve: Real from Standard;
theLastParOnCurve : Real from Standard;
theUMinParameter : Real from Standard;
theUMaxParameter : Real from Standard;
theVMinParameter : Real from Standard;
theVMaxParameter : Real from Standard;
theBeanTolerance : Real from Standard;
theFaceTolerance : Real from Standard)
returns BeanFaceIntersector from IntTools;
---Purpose:
--- Initializes the algorithm
--- theUMinParameter, ... are used for
--- optimization purposes
---
Init(me: in out;theEdge: Edge from TopoDS;
theFace: Face from TopoDS);
---Purpose:
--- Initializes the algorithm
---
-- Warning:
--- The parts of the edge which are on
--- the surface of the face and belong to
--- the whole in the face (if there is)
--- is considered as result
---
theFace: Face from TopoDS);
---Purpose:
--- Initializes the algorithm
---
-- Warning:
--- The parts of the edge which are on
--- the surface of the face and belong to
--- the whole in the face (if there is)
--- is considered as result
---
Init(me: in out;theCurve : Curve from BRepAdaptor;
theSurface : Surface from BRepAdaptor;
theBeanTolerance: Real from Standard;
theFaceTolerance: Real from Standard);
---Purpose:
--- Initializes the algorithm
---
theSurface : Surface from BRepAdaptor;
theBeanTolerance: Real from Standard;
theFaceTolerance: Real from Standard);
---Purpose:
--- Initializes the algorithm
---
Init(me: in out;theCurve : Curve from BRepAdaptor;
theSurface : Surface from BRepAdaptor;
theFirstParOnCurve: Real from Standard;
theLastParOnCurve : Real from Standard;
theUMinParameter : Real from Standard;
theUMaxParameter : Real from Standard;
theVMinParameter : Real from Standard;
theVMaxParameter : Real from Standard;
theBeanTolerance : Real from Standard;
theFaceTolerance : Real from Standard);
---Purpose:
--- Initializes the algorithm
--- theUMinParameter, ... are used for
--- optimization purposes
---
theSurface : Surface from BRepAdaptor;
theFirstParOnCurve: Real from Standard;
theLastParOnCurve : Real from Standard;
theUMinParameter : Real from Standard;
theUMaxParameter : Real from Standard;
theVMinParameter : Real from Standard;
theVMaxParameter : Real from Standard;
theBeanTolerance : Real from Standard;
theFaceTolerance : Real from Standard);
---Purpose:
--- Initializes the algorithm
--- theUMinParameter, ... are used for
--- optimization purposes
---
SetContext(me: in out;
theContext: Context from BOPInt);
---Purpose:
--- Sets the intersecton context
---
Context(me)
returns Context from BOPInt;
---C++: return const &
theContext: Context from IntTools);
---Purpose:
--- Gets the intersecton context
---
--- Sets the intersecton context
---
Context(me)
returns Context from IntTools;
---C++: return const &
---Purpose:
--- Gets the intersecton context
---
SetBeanParameters(me: in out;theFirstParOnCurve : Real from Standard;
theLastParOnCurve : Real from Standard);
---Purpose:
--- Set restrictions for curve
---
theLastParOnCurve : Real from Standard);
---Purpose:
--- Set restrictions for curve
---
SetSurfaceParameters(me: in out;theUMinParameter : Real from Standard;
theUMaxParameter : Real from Standard;
theVMinParameter : Real from Standard;
theVMaxParameter : Real from Standard);
---Purpose:
--- Set restrictions for surface
---
theUMaxParameter : Real from Standard;
theVMinParameter : Real from Standard;
theVMaxParameter : Real from Standard);
---Purpose:
--- Set restrictions for surface
---
Perform(me: in out);
---Purpose:
--- Launches the algorithm
---
---Purpose:
--- Launches the algorithm
---
IsDone(me) returns Boolean from Standard;
---C++: inline
---C++: inline
Result(me)
returns SequenceOfRanges from IntTools;
---C++: return const &
returns SequenceOfRanges from IntTools;
---C++: return const &
Result(me; theResults: out SequenceOfRanges from IntTools);
-- private
ComputeAroundExactIntersection(me: in out)
is private;
is private;
ComputeLinePlane(me: in out)
is private;
is private;
FastComputeExactIntersection(me: in out)
returns Integer from Standard is private;
ComputeUsingExtremum(me: in out)
is private;
is private;
ComputeNearRangeBoundaries(me: in out)
is private;
is private;
ComputeLocalized(me: in out)
returns Boolean from Standard is private;
returns Boolean from Standard is private;
ComputeRangeFromStartPoint(me: in out; ToIncreaseParameter : Boolean from Standard;
theParameter : Real from Standard;
theUParameter : Real from Standard;
theVParameter : Real from Standard)
is private;
theParameter : Real from Standard;
theUParameter : Real from Standard;
theVParameter : Real from Standard)
is private;
ComputeRangeFromStartPoint(me: in out; ToIncreaseParameter : Boolean from Standard;
theParameter : Real from Standard;
theUParameter : Real from Standard;
theVParameter : Real from Standard;
theIndex : Integer from Standard)
is private;
theParameter : Real from Standard;
theUParameter : Real from Standard;
theVParameter : Real from Standard;
theIndex : Integer from Standard)
is private;
Distance(me: in out; theArg : Real from Standard;
theUParameter: out Real from Standard;
theVParameter: out Real from Standard)
returns Real from Standard
is private;
theUParameter: out Real from Standard;
theVParameter: out Real from Standard)
returns Real from Standard
is private;
Distance(me: in out; theArg: Real from Standard)
returns Real from Standard
is private;
returns Real from Standard
is private;
LocalizeSolutions(me: in out; theCurveRange : CurveRangeSample from IntTools;
theBoxCurve : Box from Bnd;
theSurfaceRange: SurfaceRangeSample from IntTools;
theBoxSurface : Box from Bnd;
theCurveData : in out CurveRangeLocalizeData from IntTools;
theSurfaceData : in out SurfaceRangeLocalizeData from IntTools;
theListCurveRange: in out ListOfCurveRangeSample from IntTools;
theListSurfaceRange: in out ListOfSurfaceRangeSample from IntTools)
returns Boolean from Standard
is private;
theBoxCurve : Box from Bnd;
theSurfaceRange: SurfaceRangeSample from IntTools;
theBoxSurface : Box from Bnd;
theCurveData : in out CurveRangeLocalizeData from IntTools;
theSurfaceData : in out SurfaceRangeLocalizeData from IntTools;
theListCurveRange: in out ListOfCurveRangeSample from IntTools;
theListSurfaceRange: in out ListOfSurfaceRangeSample from IntTools)
returns Boolean from Standard
is private;
TestComputeCoinside(me: in out)
returns Boolean from Standard
is private;
returns Boolean from Standard
is private;
fields
@@ -242,7 +242,7 @@ fields
myProjector : ProjectPointOnSurf from GeomAPI;
myRangeManager : MarkedRangeSet from IntTools;
myDeflection : Real from Standard;
myContext : Context from BOPInt;
myContext : Context from IntTools;
-- results
myResults : SequenceOfRanges from IntTools;

1496
src/IntTools/IntTools_BeanFaceIntersector.cxx
View File

File diff suppressed because it is too large Load Diff

306
src/IntTools/IntTools_Context.cdl Normal file
View File

@@ -0,0 +1,306 @@
-- Created by: Peter KURNEV
-- 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.
class Context from IntTools
inherits TShared from MMgt
---Purpose:
-- The intersection Context contains geometrical
-- and topological toolkit (classifiers, projectors, etc).
-- The intersection Context is for caching the tools
-- to increase the performance.
uses
Pnt2d from gp,
Pnt from gp,
State from TopAbs,
Curve from Geom,
ProjectPointOnCurve from GeomAPI,
ProjectPointOnSurf from GeomAPI,
Vertex from TopoDS,
Face from TopoDS,
Edge from TopoDS,
Solid from TopoDS,
SolidClassifier from BRepClass3d,
FClass2d from IntTools,
Curve from IntTools,
BaseAllocator from BOPCol,
DataMapOfShapeAddress from BOPCol,
DataMapOfTransientAddress from BOPCol,
Hatcher from Geom2dHatch,
SurfaceRangeLocalizeData from IntTools
--raises
is
Create
returns Context from IntTools;
---C++: alias "Standard_EXPORT virtual ~IntTools_Context();"
Create (theAllocator: BaseAllocator from BOPCol)
returns Context from IntTools;
FClass2d(me:mutable;
aF: Face from TopoDS)
returns FClass2d from IntTools;
---C++: return &
---Purpose:
--- Returns a reference to point classifier
--- for given face
---
ProjPS (me:mutable;
aF: Face from TopoDS)
returns ProjectPointOnSurf from GeomAPI;
---C++: return &
---Purpose:
--- Returns a reference to point projector
--- for given face
---
ProjPC (me:mutable;
aE: Edge from TopoDS)
returns ProjectPointOnCurve from GeomAPI;
---C++: return &
---Purpose:
--- Returns a reference to point projector
--- for given edge
---
ProjPT (me:mutable;
aC: Curve from Geom)
returns ProjectPointOnCurve from GeomAPI;
---C++: return &
---Purpose:
--- Returns a reference to point projector
--- for given curve
---
SurfaceData(me: mutable;
aF: Face from TopoDS)
returns SurfaceRangeLocalizeData from IntTools;
---C++: return &
---Purpose:
--- Returns a reference to surface localization data
--- for given face
SolidClassifier(me:mutable;
aSolid: Solid from TopoDS)
returns SolidClassifier from BRepClass3d;
---C++: return &
---Purpose:
--- Returns a reference to solid classifier
--- for given solid
---
Hatcher(me: mutable;
aF: Face from TopoDS)
returns Hatcher from Geom2dHatch;
---C++: return &
---Purpose:
--- Returns a reference to 2D hatcher
--- for given face
---
ComputePE (me:mutable;
theP : Pnt from gp;
theTolP: Real from Standard;
theE : Edge from TopoDS;
theT :out Real from Standard)
returns Integer from Standard;
---Purpose:
--- Computes parameter of the Point theP on
--- the edge aE.
--- Returns zero if the distance between point
--- and edge is less than sum of tolerance value of edge and theTopP,
--- otherwise and for following conditions returns
--- negative value
--- 1. the edge is degenerated (-1)
--- 2. the edge does not contain 3d curve and pcurves (-2)
--- 3. projection algorithm failed (-3)
---
ComputeVE (me:mutable;
aV : Vertex from TopoDS;
aE : Edge from TopoDS;
aT :out Real from Standard)
returns Integer from Standard;
---Purpose:
--- Computes parameter of the vertex aV on
--- the edge aE.
--- Returns zero if the distance between vertex
--- and edge is less than sum of tolerances,
--- otherwise and for following conditions returns
--- negative value
--- 1. the edge is degenerated (-1)
--- 2. the edge does not contain 3d curve and pcurves (-2)
--- 3. projection algorithm failed (-3)
---
ComputeVF (me:mutable;
aV : Vertex from TopoDS;
aF : Face from TopoDS;
U : out Real from Standard;
V : out Real from Standard)
returns Integer from Standard;
---Purpose:
--- Computes UV parameters of the vertex aV on face aF
--- Returns zero if the distance between vertex and face is
--- less than or equal the sum of tolerances and the projection
--- point lays inside boundaries of the face.
--- For following conditions returns negative value
--- 1. projection algorithm failed (-1)
--- 2. distance is more than sum of tolerances (-2)
--- 3. projection point out or on the boundaries of face (-3)
---
StatePointFace(me:mutable;
aF : Face from TopoDS;
aP2D : Pnt2d from gp)
returns State from TopAbs;
---Purpose:
--- Returns the state of the point aP2D
--- relative to face aF
---
IsPointInFace(me:mutable;
aF : Face from TopoDS;
aP2D : Pnt2d from gp)
returns Boolean from Standard;
---Purpose:
--- Returns true if the point aP2D is
--- inside the boundaries of the face aF,
--- otherwise returns false
---
IsPointInOnFace(me:mutable;
aF : Face from TopoDS;
aP2D : Pnt2d from gp)
returns Boolean from Standard;
---Purpose:
--- Returns true if the point aP2D is
--- inside or on the boundaries of aF
---
IsValidPointForFace(me:mutable;
aP3D : Pnt from gp;
aF : Face from TopoDS;
aTol : Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Returns true if the distance between point aP3D
--- and face aF is less or equal to tolerance aTol
--- and projection point is inside or on the boundaries
--- of the face aF
---
IsValidPointForFaces(me:mutable;
aP3D : Pnt from gp;
aF1 : Face from TopoDS;
aF2 : Face from TopoDS;
aTol : Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Returns true if IsValidPointForFace returns true
--- for both face aF1 and aF2
---
IsValidBlockForFace (me:mutable;
aT1 : Real from Standard;
aT2 : Real from Standard;
aIC : Curve from IntTools;
aF : Face from TopoDS;
aTol : Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Returns true if IsValidPointForFace returns true
--- for some 3d point that lay on the curve aIC bounded by
--- parameters aT1 and aT2
---
IsValidBlockForFaces (me:mutable;
aT1 : Real from Standard;
aT2 : Real from Standard;
aIC : Curve from IntTools;
aF1 : Face from TopoDS;
aF2 : Face from TopoDS;
aTol : Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Returns true if IsValidBlockForFace returns true
--- for both faces aF1 and aF2
---
IsVertexOnLine(me:mutable;
aV : Vertex from TopoDS;
aIC : Curve from IntTools;
aTolC: Real from Standard;
aT :out Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Computes parameter of the vertex aV on
--- the curve aIC.
--- Returns true if the distance between vertex and
--- curve is less than sum of tolerance of aV and aTolC,
--- otherwise or if projection algorithm failed
--- returns false (in this case aT isn't significant)
---
IsVertexOnLine(me:mutable;
aV : Vertex from TopoDS;
aTolV: Real from Standard;
aIC : Curve from IntTools;
aTolC: Real from Standard;
aT :out Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Computes parameter of the vertex aV on
--- the curve aIC.
--- Returns true if the distance between vertex and
--- curve is less than sum of tolerance of aV and aTolC,
--- otherwise or if projection algorithm failed
--- returns false (in this case aT isn't significant)
---
ProjectPointOnEdge (me:mutable;
aP : Pnt from gp;
aE : Edge from TopoDS;
aT :out Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Computes parameter of the point aP on
--- the edge aE.
--- Returns false if projection algorithm failed
--- other wiese returns true.
---
fields
myAllocator : BaseAllocator from BOPCol is protected;
myFClass2dMap:DataMapOfShapeAddress from BOPCol is protected;
myProjPSMap :DataMapOfShapeAddress from BOPCol is protected;
myProjPCMap :DataMapOfShapeAddress from BOPCol is protected;
mySClassMap :DataMapOfShapeAddress from BOPCol is protected;
myProjPTMap :DataMapOfTransientAddress from BOPCol is protected;
myHatcherMap :DataMapOfShapeAddress from BOPCol is protected;
myProjSDataMap:DataMapOfShapeAddress from BOPCol is protected;
myCreateFlag :Integer from Standard is protected;
end Context;

847
src/IntTools/IntTools_Context.cxx Normal file
View File

@@ -0,0 +1,847 @@
// Created by: Peter KURNEV
// 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 <IntTools_Context.ixx>
#include <Precision.hxx>
#include <Geom_Curve.hxx>
#include <Geom_BoundedCurve.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <Geom2dHatch_Intersector.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <TopAbs_State.hxx>
#include <TopoDS.hxx>
#include <TopExp_Explorer.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <IntTools_Tools.hxx>
#include <IntTools_FClass2d.hxx>
//
#include <Extrema_LocateExtPC.hxx>
#include <Geom2d_Curve.hxx>
#include <NCollection_IncAllocator.hxx>
#include <IntTools_SurfaceRangeLocalizeData.hxx>
//=======================================================================
//function :
//purpose :
//=======================================================================
IntTools_Context::IntTools_Context()
:
myAllocator(new NCollection_IncAllocator()),
myFClass2dMap(100, myAllocator),
myProjPSMap(100, myAllocator),
myProjPCMap(100, myAllocator),
mySClassMap(100, myAllocator),
myProjPTMap(100, myAllocator),
myHatcherMap(100, myAllocator),
myProjSDataMap(100, myAllocator),
myCreateFlag(0)
{
}
//=======================================================================
//function :
//purpose :
//=======================================================================
IntTools_Context::IntTools_Context
(const Handle(NCollection_BaseAllocator)& theAllocator)
:
myAllocator(theAllocator),
myFClass2dMap(100, myAllocator),
myProjPSMap(100, myAllocator),
myProjPCMap(100, myAllocator),
mySClassMap(100, myAllocator),
myProjPTMap(100, myAllocator),
myHatcherMap(100, myAllocator),
myProjSDataMap(100, myAllocator),
myCreateFlag(1)
{
}
//=======================================================================
//function : ~
//purpose :
//=======================================================================
IntTools_Context::~IntTools_Context()
{
Standard_Address anAdr;
BOPCol_DataMapIteratorOfDataMapOfShapeAddress aIt;
BOPCol_DataMapIteratorOfDataMapOfTransientAddress aIt1;
//
IntTools_FClass2d* pFClass2d;
//
aIt.Initialize(myFClass2dMap);
for (; aIt.More(); aIt.Next()) {
anAdr=aIt.Value();
pFClass2d=(IntTools_FClass2d*)anAdr;
(*pFClass2d).~IntTools_FClass2d();
myAllocator->Free(anAdr);
}
myFClass2dMap.Clear();
//
GeomAPI_ProjectPointOnSurf* pProjPS;
aIt.Initialize(myProjPSMap);
for (; aIt.More(); aIt.Next()) {
anAdr=aIt.Value();
pProjPS=(GeomAPI_ProjectPointOnSurf*)anAdr;
(*pProjPS).~GeomAPI_ProjectPointOnSurf();
myAllocator->Free(anAdr);
}
myProjPSMap.Clear();
//
GeomAPI_ProjectPointOnCurve* pProjPC;
aIt.Initialize(myProjPCMap);
for (; aIt.More(); aIt.Next()) {
anAdr=aIt.Value();
pProjPC=(GeomAPI_ProjectPointOnCurve*)anAdr;
(*pProjPC).~GeomAPI_ProjectPointOnCurve();
myAllocator->Free(anAdr);
}
myProjPCMap.Clear();
//
//
BRepClass3d_SolidClassifier* pSC;
aIt.Initialize(mySClassMap);
for (; aIt.More(); aIt.Next()) {
anAdr=aIt.Value();
pSC=(BRepClass3d_SolidClassifier*)anAdr;
(*pSC).~BRepClass3d_SolidClassifier();
myAllocator->Free(anAdr);
}
mySClassMap.Clear();
//
GeomAPI_ProjectPointOnCurve* pProjPT;
aIt1.Initialize(myProjPTMap);
for (; aIt1.More(); aIt1.Next()) {
anAdr=aIt1.Value();
pProjPT=(GeomAPI_ProjectPointOnCurve*)anAdr;
(*pProjPT).~GeomAPI_ProjectPointOnCurve();
myAllocator->Free(anAdr);
}
myProjPTMap.Clear();
//
Geom2dHatch_Hatcher* pHatcher;
aIt.Initialize(myHatcherMap);
for (; aIt.More(); aIt.Next()) {
anAdr=aIt.Value();
pHatcher=(Geom2dHatch_Hatcher*)anAdr;
(*pHatcher).~Geom2dHatch_Hatcher();
myAllocator->Free(anAdr);
}
myHatcherMap.Clear();
//
IntTools_SurfaceRangeLocalizeData* pSData = NULL;
aIt.Initialize(myProjSDataMap);
for (; aIt.More(); aIt.Next()) {
anAdr=aIt.Value();
pSData = (IntTools_SurfaceRangeLocalizeData*)anAdr;
(*pSData).~IntTools_SurfaceRangeLocalizeData();
myAllocator->Free(anAdr);
}
myProjSDataMap.Clear();
}
//=======================================================================
//function : FClass2d
//purpose :
//=======================================================================
IntTools_FClass2d& IntTools_Context::FClass2d(const TopoDS_Face& aF)
{
Standard_Address anAdr;
IntTools_FClass2d* pFClass2d;
//
if (!myFClass2dMap.IsBound(aF)) {
Standard_Real aTolF;
TopoDS_Face aFF;
//
aFF=aF;
aFF.Orientation(TopAbs_FORWARD);
aTolF=BRep_Tool::Tolerance(aFF);
//
pFClass2d=(IntTools_FClass2d*)myAllocator->Allocate(sizeof(IntTools_FClass2d));
new (pFClass2d) IntTools_FClass2d(aFF, aTolF);
//
anAdr=(Standard_Address)pFClass2d;
myFClass2dMap.Bind(aFF, anAdr);
}
else {
anAdr=myFClass2dMap.Find(aF);
pFClass2d=(IntTools_FClass2d*)anAdr;
}
return *pFClass2d;
}
//=======================================================================
//function : ProjPS
//purpose :
//=======================================================================
GeomAPI_ProjectPointOnSurf& IntTools_Context::ProjPS(const TopoDS_Face& aF)
{
Standard_Address anAdr;
GeomAPI_ProjectPointOnSurf* pProjPS;
if (!myProjPSMap.IsBound(aF)) {
Standard_Real Umin, Usup, Vmin, Vsup, anEpsT=1.e-12 ;
BRepAdaptor_Surface aBAS;
//
const Handle(Geom_Surface)& aS=BRep_Tool::Surface(aF);
aBAS.Initialize (aF, Standard_True);
//
Umin=aBAS.FirstUParameter();
Usup=aBAS.LastUParameter ();
Vmin=aBAS.FirstVParameter();
Vsup=aBAS.LastVParameter ();
//
pProjPS=(GeomAPI_ProjectPointOnSurf*)myAllocator->Allocate(sizeof(GeomAPI_ProjectPointOnSurf));
new (pProjPS) GeomAPI_ProjectPointOnSurf();
pProjPS->Init(aS ,Umin, Usup, Vmin, Vsup, anEpsT/*, Extrema_ExtAlgo_Tree*/);
Extrema_ExtPS& anExtAlgo = const_cast<Extrema_ExtPS&>(pProjPS->Extrema());
anExtAlgo.SetFlag(Extrema_ExtFlag_MIN);
//
anAdr=(Standard_Address)pProjPS;
myProjPSMap.Bind(aF, anAdr);
}
else {
anAdr=myProjPSMap.Find(aF);
pProjPS=(GeomAPI_ProjectPointOnSurf*)anAdr;
}
return *pProjPS;
}
//=======================================================================
//function : ProjPC
//purpose :
//=======================================================================
GeomAPI_ProjectPointOnCurve& IntTools_Context::ProjPC(const TopoDS_Edge& aE)
{
Standard_Address anAdr;
GeomAPI_ProjectPointOnCurve* pProjPC;
if (!myProjPCMap.IsBound(aE)) {
Standard_Real f, l;
//
Handle(Geom_Curve)aC3D=BRep_Tool::Curve (aE, f, l);
//
pProjPC=(GeomAPI_ProjectPointOnCurve*)myAllocator->Allocate(sizeof(GeomAPI_ProjectPointOnCurve));
new (pProjPC) GeomAPI_ProjectPointOnCurve();
pProjPC->Init(aC3D, f, l);
//
anAdr=(Standard_Address)pProjPC;
myProjPCMap.Bind(aE, anAdr);
}
else {
anAdr=myProjPCMap.Find(aE);
pProjPC=(GeomAPI_ProjectPointOnCurve*)anAdr;
}
return *pProjPC;
}
//=======================================================================
//function : ProjPT
//purpose :
//=======================================================================
GeomAPI_ProjectPointOnCurve& IntTools_Context::ProjPT
(const Handle(Geom_Curve)& aC3D)
{
Standard_Address anAdr;
GeomAPI_ProjectPointOnCurve* pProjPT;
if (!myProjPTMap.IsBound(aC3D)) {
Standard_Real f, l;
f=aC3D->FirstParameter();
l=aC3D->LastParameter();
//
pProjPT=(GeomAPI_ProjectPointOnCurve*)myAllocator->Allocate(sizeof(GeomAPI_ProjectPointOnCurve));
new (pProjPT) GeomAPI_ProjectPointOnCurve();
pProjPT->Init(aC3D, f, l);
//
anAdr=(Standard_Address)pProjPT;
myProjPTMap.Bind(aC3D, anAdr);
}
else {
anAdr=myProjPTMap.Find(aC3D);
pProjPT=(GeomAPI_ProjectPointOnCurve*)anAdr;
}
return *pProjPT;
}
//=======================================================================
//function : SolidClassifier
//purpose :
//=======================================================================
BRepClass3d_SolidClassifier& IntTools_Context::SolidClassifier
(const TopoDS_Solid& aSolid)
{
Standard_Address anAdr;
BRepClass3d_SolidClassifier* pSC;
if (!mySClassMap.IsBound(aSolid)) {
//
pSC=(BRepClass3d_SolidClassifier*)myAllocator->Allocate(sizeof(BRepClass3d_SolidClassifier));
new (pSC) BRepClass3d_SolidClassifier(aSolid);
//
anAdr=(Standard_Address)pSC;
mySClassMap.Bind(aSolid, anAdr);
}
else {
anAdr=mySClassMap.Find(aSolid);
pSC =(BRepClass3d_SolidClassifier*)anAdr;
}
return *pSC;
}
//=======================================================================
//function : Hatcher
//purpose :
//=======================================================================
Geom2dHatch_Hatcher& IntTools_Context::Hatcher(const TopoDS_Face& aF)
{
Standard_Address anAdr;
Geom2dHatch_Hatcher* pHatcher;
//
if (!myHatcherMap.IsBound(aF)) {
Standard_Real aTolArcIntr, aTolTangfIntr, aTolHatch2D, aTolHatch3D;
Standard_Real aU1, aU2, aEpsT;
TopAbs_Orientation aOrE;
Handle(Geom_Surface) aS;
Handle(Geom2d_Curve) aC2D;
Handle(Geom2d_TrimmedCurve) aCT2D;
TopoDS_Face aFF;
TopExp_Explorer aExp;
//
aTolHatch2D=1.e-8;
aTolHatch3D=1.e-8;
aTolArcIntr=1.e-10;
aTolTangfIntr=1.e-10;
aEpsT=Precision::PConfusion();
//
Geom2dHatch_Intersector aIntr(aTolArcIntr, aTolTangfIntr);
pHatcher=new Geom2dHatch_Hatcher(aIntr,
aTolHatch2D, aTolHatch3D,
Standard_True, Standard_False);
//
aFF=aF;
aFF.Orientation(TopAbs_FORWARD);
aS=BRep_Tool::Surface(aFF);
aExp.Init (aFF, TopAbs_EDGE);
for (; aExp.More() ; aExp.Next()) {
const TopoDS_Edge& aE=*((TopoDS_Edge*)&aExp.Current());
aOrE=aE.Orientation();
//
aC2D=BRep_Tool::CurveOnSurface (aE, aFF, aU1, aU2);
if (aC2D.IsNull() ) {
continue;
}
if (fabs(aU1-aU2) < aEpsT) {
continue;
}
//
aCT2D=new Geom2d_TrimmedCurve(aC2D, aU1, aU2);
pHatcher->AddElement(aCT2D, aOrE);
}// for (; aExp.More() ; aExp.Next()) {
//
anAdr=(Standard_Address)pHatcher;
myHatcherMap.Bind(aFF, anAdr);
}//if (!myHatcherMap.IsBound(aF)) {
//
else {
anAdr=myHatcherMap.Find(aF);
pHatcher=(Geom2dHatch_Hatcher*)anAdr;
}
return *pHatcher;
}
//=======================================================================
//function : SurfaceData
//purpose :
//=======================================================================
IntTools_SurfaceRangeLocalizeData& IntTools_Context::SurfaceData
(const TopoDS_Face& aF)
{
Standard_Address anAdr;
IntTools_SurfaceRangeLocalizeData* pSData;
//
if (!myProjSDataMap.IsBound(aF)) {
pSData=new IntTools_SurfaceRangeLocalizeData
(3,
3,
10. * Precision::PConfusion(),
10. * Precision::PConfusion());
//
anAdr=(Standard_Address)pSData;
myProjSDataMap.Bind(aF, anAdr);
}
else {
anAdr=myProjSDataMap.Find(aF);
pSData=(IntTools_SurfaceRangeLocalizeData*)anAdr;
}
return *pSData;
}
//=======================================================================
//function : ComputePE
//purpose :
//=======================================================================
Standard_Integer IntTools_Context::ComputePE
(const gp_Pnt& aP1,
const Standard_Real aTolP1,
const TopoDS_Edge& aE2,
Standard_Real& aT)
{
if (!BRep_Tool::IsGeometric(aE2)) {
return -2;
}
Standard_Real aDist, aTolE2, aTolSum;
Standard_Integer aNbProj;
//
GeomAPI_ProjectPointOnCurve& aProjector=ProjPC(aE2);
aProjector.Perform(aP1);
aNbProj=aProjector.NbPoints();
if (!aNbProj) {
return -3;
}
//
aDist=aProjector.LowerDistance();
//
aTolE2=BRep_Tool::Tolerance(aE2);
aTolSum=aTolP1+aTolE2;
//
aT=aProjector.LowerDistanceParameter();
if (aDist > aTolSum) {
return -4;
}
return 0;
}
//=======================================================================
//function : ComputeVE
//purpose :
//=======================================================================
Standard_Integer IntTools_Context::ComputeVE
(const TopoDS_Vertex& aV1,
const TopoDS_Edge& aE2,
Standard_Real& aT)
{
if (BRep_Tool::Degenerated(aE2)) {
return -1;
}
if (!BRep_Tool::IsGeometric(aE2)) {
return -2;
}
Standard_Real aDist, aTolV1, aTolE2, aTolSum;
Standard_Integer aNbProj;
gp_Pnt aP;
//
aP=BRep_Tool::Pnt(aV1);
//
GeomAPI_ProjectPointOnCurve& aProjector=ProjPC(aE2);
aProjector.Perform(aP);
aNbProj=aProjector.NbPoints();
if (!aNbProj) {
return -3;
}
//
aDist=aProjector.LowerDistance();
// tolerance of check for coincidence is sum of tolerances of edge and vertex
// extended by additional Precision::Confusion() to allow for interference where
// it is very close but not fit to tolerance (see #24108)
aTolV1=BRep_Tool::Tolerance(aV1);
aTolE2=BRep_Tool::Tolerance(aE2);
aTolSum = aTolV1 + aTolE2 + Precision::Confusion();
//
aT=aProjector.LowerDistanceParameter();
if (aDist > aTolSum) {
return -4;
}
return 0;
}
//=======================================================================
//function : ComputeVS
//purpose :
//=======================================================================
Standard_Integer IntTools_Context::ComputeVF
(const TopoDS_Vertex& aV1,
const TopoDS_Face& aF2,
Standard_Real& U,
Standard_Real& V)
{
Standard_Real aTolV1, aTolF2, aTolSum, aDist;
gp_Pnt aP;
aP=BRep_Tool::Pnt(aV1);
//
// 1. Check if the point is projectable on the surface
GeomAPI_ProjectPointOnSurf& aProjector=ProjPS(aF2);
aProjector.Perform(aP);
//
if (!aProjector.IsDone()) { // the point is not projectable on the surface
return -1;
}
//
// 2. Check the distance between the projection point and
// the original point
aDist=aProjector.LowerDistance();
aTolV1=BRep_Tool::Tolerance(aV1);
aTolF2=BRep_Tool::Tolerance(aF2);
aTolSum=aTolV1+aTolF2;
if (aDist > aTolSum) {
// the distance is too large
return -2;
}
aProjector.LowerDistanceParameters(U, V);
//
gp_Pnt2d aP2d(U, V);
Standard_Boolean pri=IsPointInFace (aF2, aP2d);
if (!pri) {// the point lays on the surface but out of the face
return -3;
}
return 0;
}
//=======================================================================
//function : StatePointFace
//purpose :
//=======================================================================
TopAbs_State IntTools_Context::StatePointFace
(const TopoDS_Face& aF,
const gp_Pnt2d& aP2d)
{
TopAbs_State aState;
IntTools_FClass2d& aClass2d=FClass2d(aF);
aState=aClass2d.Perform(aP2d);
return aState;
}
//=======================================================================
//function : IsPointInFace
//purpose :
//=======================================================================
Standard_Boolean IntTools_Context::IsPointInFace
(const TopoDS_Face& aF,
const gp_Pnt2d& aP2d)
{
TopAbs_State aState=StatePointFace(aF, aP2d);
if (aState==TopAbs_OUT || aState==TopAbs_ON) {
return Standard_False;
}
return Standard_True;
}
//=======================================================================
//function : IsPointInOnFace
//purpose :
//=======================================================================
Standard_Boolean IntTools_Context::IsPointInOnFace(const TopoDS_Face& aF,
const gp_Pnt2d& aP2d)
{
TopAbs_State aState=StatePointFace(aF, aP2d);
if (aState==TopAbs_OUT) {
return Standard_False;
}
return Standard_True;
}
//=======================================================================
//function : IsValidPointForFace
//purpose :
//=======================================================================
Standard_Boolean IntTools_Context::IsValidPointForFace
(const gp_Pnt& aP,
const TopoDS_Face& aF,
const Standard_Real aTol)
{
Standard_Boolean bFlag;
Standard_Real Umin, U, V;
GeomAPI_ProjectPointOnSurf& aProjector=ProjPS(aF);
aProjector.Perform(aP);
bFlag=aProjector.IsDone();
if (bFlag) {
Umin=aProjector.LowerDistance();
//if (Umin > 1.e-3) { // it was
if (Umin > aTol) {
return !bFlag;
}
//
aProjector.LowerDistanceParameters(U, V);
gp_Pnt2d aP2D(U, V);
bFlag=IsPointInOnFace (aF, aP2D);
}
return bFlag;
}
//=======================================================================
//function : IsValidPointForFaces
//purpose :
//=======================================================================
Standard_Boolean IntTools_Context::IsValidPointForFaces
(const gp_Pnt& aP,
const TopoDS_Face& aF1,
const TopoDS_Face& aF2,
const Standard_Real aTol)
{
Standard_Boolean bFlag1, bFlag2;
bFlag1=IsValidPointForFace(aP, aF1, aTol);
if (!bFlag1) {
return bFlag1;
}
bFlag2=IsValidPointForFace(aP, aF2, aTol);
return bFlag2;
}
//=======================================================================
//function : IsValidBlockForFace
//purpose :
//=======================================================================
Standard_Boolean IntTools_Context::IsValidBlockForFace
(const Standard_Real aT1,
const Standard_Real aT2,
const IntTools_Curve& aC,
const TopoDS_Face& aF,
const Standard_Real aTol)
{
Standard_Boolean bFlag;
Standard_Real aTInterm;
gp_Pnt aPInterm;
aTInterm=IntTools_Tools::IntermediatePoint(aT1, aT2);
Handle(Geom_Curve) aC3D=aC.Curve();
// point 3D
aC3D->D0(aTInterm, aPInterm);
//
bFlag=IsValidPointForFace (aPInterm, aF, aTol);
return bFlag;
}
//=======================================================================
//function : IsValidBlockForFaces
//purpose :
//=======================================================================
Standard_Boolean IntTools_Context::IsValidBlockForFaces
(const Standard_Real aT1,
const Standard_Real aT2,
const IntTools_Curve& aC,
const TopoDS_Face& aF1,
const TopoDS_Face& aF2,
const Standard_Real aTol)
{
Standard_Boolean bFlag1, bFlag2;
//
Handle(Geom2d_Curve) aPC1 = aC.FirstCurve2d();
Handle(Geom2d_Curve) aPC2 = aC.SecondCurve2d();
if( !aPC1.IsNull() && !aPC2.IsNull() ) {
Standard_Real aMidPar = IntTools_Tools::IntermediatePoint(aT1, aT2);
gp_Pnt2d aPnt2D;
aPC1->D0(aMidPar, aPnt2D);
bFlag1 = IsPointInOnFace(aF1, aPnt2D);
if( !bFlag1 )
return bFlag1;
aPC2->D0(aMidPar, aPnt2D);
bFlag2 = IsPointInOnFace(aF2, aPnt2D);
return bFlag2;
}
//
bFlag1=IsValidBlockForFace (aT1, aT2, aC, aF1, aTol);
if (!bFlag1) {
return bFlag1;
}
bFlag2=IsValidBlockForFace (aT1, aT2, aC, aF2, aTol);
return bFlag2;
}
//=======================================================================
//function : IsVertexOnLine
//purpose :
//=======================================================================
Standard_Boolean IntTools_Context::IsVertexOnLine
(const TopoDS_Vertex& aV,
const IntTools_Curve& aC,
const Standard_Real aTolC,
Standard_Real& aT)
{
Standard_Boolean bRet;
Standard_Real aTolV;
//
aTolV=BRep_Tool::Tolerance(aV);
bRet=IntTools_Context::IsVertexOnLine(aV, aTolV, aC, aTolC , aT);
//
return bRet;
}
//=======================================================================
//function : IsVertexOnLine
//purpose :
//=======================================================================
Standard_Boolean IntTools_Context::IsVertexOnLine
(const TopoDS_Vertex& aV,
const Standard_Real aTolV,
const IntTools_Curve& aC,
const Standard_Real aTolC,
Standard_Real& aT)
{
Standard_Real aFirst, aLast, aDist, aTolSum;
Standard_Integer aNbProj;
gp_Pnt aPv;
aPv=BRep_Tool::Pnt(aV);
Handle(Geom_Curve) aC3D=aC.Curve();
aTolSum=aTolV+aTolC;
//
GeomAdaptor_Curve aGAC(aC3D);
GeomAbs_CurveType aType=aGAC.GetType();
if (aType==GeomAbs_BSplineCurve ||
aType==GeomAbs_BezierCurve) {
aTolSum=2.*aTolSum;
if (aTolSum<1.e-5) {
aTolSum=1.e-5;
}
}
else {
aTolSum=2.*aTolSum;//xft
if(aTolSum < 1.e-6)
aTolSum = 1.e-6;
}
//
aFirst=aC3D->FirstParameter();
aLast =aC3D->LastParameter();
//
//Checking extermities first
if (!Precision::IsInfinite(aFirst)) {
gp_Pnt aPCFirst=aC3D->Value(aFirst);
aDist=aPv.Distance(aPCFirst);
if (aDist < aTolSum) {
aT=aFirst;
//
if(aDist > aTolV) {
Extrema_LocateExtPC anExt(aPv, aGAC, aFirst, 1.e-10);
if(anExt.IsDone()) {
Extrema_POnCurv aPOncurve = anExt.Point();
aT = aPOncurve.Parameter();
if((aT > (aLast + aFirst) * 0.5) ||
(aPv.Distance(aPOncurve.Value()) > aTolSum) ||
(aPCFirst.Distance(aPOncurve.Value()) < Precision::Confusion()))
aT = aFirst;
}
}
//
return Standard_True;
}
}
//
//if (!Precision::IsInfinite(aFirst)) {
if (!Precision::IsInfinite(aLast)) {
gp_Pnt aPCLast=aC3D->Value(aLast);
aDist=aPv.Distance(aPCLast);
if (aDist < aTolSum) {
aT=aLast;
//
if(aDist > aTolV) {
Extrema_LocateExtPC anExt(aPv, aGAC, aLast, 1.e-10);
if(anExt.IsDone()) {
Extrema_POnCurv aPOncurve = anExt.Point();
aT = aPOncurve.Parameter();
if((aT < (aLast + aFirst) * 0.5) ||
(aPv.Distance(aPOncurve.Value()) > aTolSum) ||
(aPCLast.Distance(aPOncurve.Value()) < Precision::Confusion()))
aT = aLast;
}
}
//
return Standard_True;
}
}
//
GeomAPI_ProjectPointOnCurve& aProjector=ProjPT(aC3D);
aProjector.Perform(aPv);
aNbProj=aProjector.NbPoints();
if (!aNbProj) {
Handle(Geom_BoundedCurve) aBC=
Handle(Geom_BoundedCurve)::DownCast(aC3D);
if (!aBC.IsNull()) {
gp_Pnt aPStart=aBC->StartPoint();
gp_Pnt aPEnd =aBC->EndPoint();
aDist=aPv.Distance(aPStart);
if (aDist < aTolSum) {
aT=aFirst;
return Standard_True;
}
aDist=aPv.Distance(aPEnd);
if (aDist < aTolSum) {
aT=aLast;
return Standard_True;
}
}
return Standard_False;
}
aDist=aProjector.LowerDistance();
if (aDist > aTolSum) {
return Standard_False;
}
aT=aProjector.LowerDistanceParameter();
return Standard_True;
}
//=======================================================================
//function : ProjectPointOnEdge
//purpose :
//=======================================================================
Standard_Boolean IntTools_Context::ProjectPointOnEdge
(const gp_Pnt& aP,
const TopoDS_Edge& anEdge,
Standard_Real& aT)
{
Standard_Integer aNbPoints;
GeomAPI_ProjectPointOnCurve& aProjector=ProjPC(anEdge);
aProjector.Perform(aP);
aNbPoints=aProjector.NbPoints();
if (aNbPoints) {
aT=aProjector.LowerDistanceParameter();
return Standard_True;
}
return Standard_False;
}

10
src/IntTools/IntTools_EdgeFace.cdl
View File

@@ -31,7 +31,7 @@ uses
FClass2d from IntTools,
SequenceOfRoots from IntTools,
SequenceOfCommonPrts from IntTools,
Context from BOPInt,
Context from IntTools,
Range from IntTools
--raises
@@ -118,12 +118,12 @@ is
--- The algorithm processes edge inside these boundaries.
SetContext (me: in out;
theContext: Context from BOPInt);
theContext: Context from IntTools);
---Purpose:
--- Sets the intersecton context
Context (me)
returns Context from BOPInt;
returns Context from IntTools;
---C++:return const &
---Purpose:
--- Gets the intersecton context
@@ -234,7 +234,7 @@ is
t,f:CArray1OfReal from IntTools)
is protected;
RemoveIdenticalRoots(me:out)
RemoveIdenticalRoots(me:out)
is protected;
CheckTouch (me: out;
@@ -276,7 +276,7 @@ fields
myErrorStatus : Integer from Standard;
--- internal members
myContext : Context from BOPInt;
myContext : Context from IntTools;
myProjectableRanges: SequenceOfRanges from IntTools;
myFClass2d : FClass2d from IntTools;
myFuncArray : CArray1OfReal from IntTools;

8
src/IntTools/IntTools_EdgeFace.cxx
View File

@@ -28,7 +28,7 @@
#include <IntTools_CommonPrt.hxx>
#include <IntTools_Root.hxx>
#include <IntTools_BeanFaceIntersector.hxx>
#include <BOPInt_Context.hxx>
#include <IntTools_Context.hxx>
#include <BRep_Tool.hxx>
@@ -100,7 +100,7 @@ static
//function : SetContext
//purpose :
//=======================================================================
void IntTools_EdgeFace::SetContext(const Handle(BOPInt_Context)& theContext)
void IntTools_EdgeFace::SetContext(const Handle(IntTools_Context)& theContext)
{
myContext = theContext;
}
@@ -109,7 +109,7 @@ void IntTools_EdgeFace::SetContext(const Handle(BOPInt_Context)& theContext)
//function : Context
//purpose :
//=======================================================================
const Handle(BOPInt_Context)& IntTools_EdgeFace::Context()const
const Handle(IntTools_Context)& IntTools_EdgeFace::Context()const
{
return myContext;
}
@@ -1221,7 +1221,7 @@ void IntTools_EdgeFace::Perform()
}
//
if (myContext.IsNull()) {
myContext=new BOPInt_Context;
myContext=new IntTools_Context;
}
//
myIsDone = Standard_False;

171
src/IntTools/IntTools_FaceFace.cdl
View File

@@ -15,8 +15,8 @@
class FaceFace from IntTools
---Purpose: This class provides the intersection of
--- face's underlying surfaces.
---Purpose: This class provides the intersection of
--- face's underlying surfaces.
uses
@@ -28,7 +28,7 @@ uses
SequenceOfCurves from IntTools,
LineConstructor from IntTools,
SequenceOfPntOn2Faces from IntTools,
Context from BOPInt
Context from IntTools
@@ -36,117 +36,114 @@ raises NotDone from StdFail
is
Create
returns FaceFace from IntTools;
---Purpose:
--- Empty constructor.
---
returns FaceFace from IntTools;
---Purpose:
--- Empty constructor.
SetParameters(me: in out;
ApproxCurves : Boolean from Standard;
ComputeCurveOnS1: Boolean from Standard;
ComputeCurveOnS2: Boolean from Standard;
ApproximationTolerance: Real from Standard);
---Purpose:
--- Modifier
---
ApproxCurves : Boolean from Standard;
ComputeCurveOnS1: Boolean from Standard;
ComputeCurveOnS2: Boolean from Standard;
ApproximationTolerance: Real from Standard);
---Purpose:
--- Modifier
---
Perform(me: in out;
F1: Face from TopoDS;
F2: Face from TopoDS);
---Purpose:
--- Intersects underliing surfaces of F1 and F2
--- Use sum of tolerance of F1 and F2 as intersection
--- criteria
---
F1: Face from TopoDS;
F2: Face from TopoDS);
---Purpose:
--- Intersects underliing surfaces of F1 and F2
--- Use sum of tolerance of F1 and F2 as intersection
--- criteria
IsDone(me)
returns Boolean from Standard;
---Purpose:
--- Returns True if the intersection was successful
---
returns Boolean from Standard;
---Purpose:
--- Returns True if the intersection was successful
---
Lines(me)
returns SequenceOfCurves from IntTools;
---C++: return const&
---Purpose:
--- Returns sequence of 3d curves as result of intersection
---
returns SequenceOfCurves from IntTools;
---C++: return const&
---Purpose:
--- Returns sequence of 3d curves as result of intersection
---
Points(me)
returns SequenceOfPntOn2Faces from IntTools;
---C++: return const&
---Purpose:
--- Returns sequence of 3d curves as result of intersection
---
returns SequenceOfPntOn2Faces from IntTools;
---C++: return const&
---Purpose:
--- Returns sequence of 3d curves as result of intersection
---
TolReached3d(me)
returns Real from Standard;
---Purpose:
--- Returns tolerance reached during approximation.
--- If approximation was not done, returns zero.
---
returns Real from Standard;
---Purpose:
--- Returns tolerance reached during approximation.
--- If approximation was not done, returns zero.
TolReached2d(me)
returns Real from Standard;
---Purpose:
--- Returns tolerance reached during approximation.
--- If approximation was not done, returns zero.
---
returns Real from Standard;
---Purpose:
--- Returns tolerance reached during approximation.
--- If approximation was not done, returns zero.
---
Face1 (me)
returns Face from TopoDS;
---C++: return const&
---Purpose:
--- Returns first of processed faces
---
returns Face from TopoDS;
---C++: return const&
---Purpose:
--- Returns first of processed faces
---
Face2 (me)
returns Face from TopoDS;
---C++: return const&
---Purpose:
--- Returns second of processed faces
---
returns Face from TopoDS;
---C++: return const&
---Purpose:
--- Returns second of processed faces
---
TangentFaces (me)
returns Boolean from Standard;
---Purpose:
--- Returns True if faces are tangent
---
returns Boolean from Standard;
---Purpose:
--- Returns True if faces are tangent
---
PrepareLines3D (me:out;
bToSplit: Boolean from Standard=Standard_True);
---Purpose:
--- Provides post-processing the result lines.
--- <bToSplit> - the flag.
-- In case of <bToSplit> is true the closed 3D-curves will be splitted
-- on parts.
-- In case of <bToSplit> is false the closed 3D-curves remain untouched.
bToSplit: Boolean from Standard=Standard_True);
---Purpose:
--- Provides post-processing the result lines.
--- <bToSplit> - the flag.
-- In case of <bToSplit> is true the closed 3D-curves will be splitted
-- on parts.
-- In case of <bToSplit> is false the closed 3D-curves remain untouched.
SetList (me: in out;
ListOfPnts: in out ListOfPntOn2S from IntSurf);
ListOfPnts: in out ListOfPntOn2S from IntSurf);
----------------------------------------------------------
-- private block
----------------------------------------------------------
MakeCurve(me: in out; Index : Integer from Standard;
D1 : TopolTool from Adaptor3d;
D2 : TopolTool from Adaptor3d)
is protected;
D1 : TopolTool from Adaptor3d;
D2 : TopolTool from Adaptor3d)
is protected;
ComputeTolReached3d(me:out)
is protected;
is protected;
SetContext(me:out;
aContext : Context from BOPInt);
---Purpose:
--- Sets the intersecton context
aContext : Context from IntTools);
---Purpose:
--- Sets the intersecton context
Context(me)
returns Context from BOPInt;
---C++: return const &
---Purpose:
--- Gets the intersecton context
---
returns Context from IntTools;
---C++: return const &
---Purpose:
--- Gets the intersecton context
fields
myIsDone : Boolean from Standard;
@@ -173,7 +170,7 @@ fields
myListOfPnts : ListOfPntOn2S from IntSurf;
myContext : Context from BOPInt;
myContext : Context from IntTools;
end FaceFace from IntTools;

28
src/IntTools/IntTools_FaceFace.cxx
View File

@@ -111,7 +111,7 @@
#include <IntTools_TopolTool.hxx>
#include <IntTools_PntOnFace.hxx>
#include <IntTools_PntOn2Faces.hxx>
#include <BOPInt_Context.hxx>
#include <IntTools_Context.hxx>
#include <IntSurf_ListIteratorOfListOfPntOn2S.hxx>
static
@@ -186,7 +186,7 @@ static
const Standard_Boolean theAvoidLConstructor,
IntPatch_SequenceOfLine& theNewLines,
Standard_Real& theReachedTol3d,
const Handle(BOPInt_Context)& );
const Handle(IntTools_Context)& );
static
Standard_Boolean ParameterOutOfBoundary(const Standard_Real theParameter,
@@ -196,7 +196,7 @@ static
const Standard_Real theOtherParameter,
const Standard_Boolean bIncreasePar,
Standard_Real& theNewParameter,
const Handle(BOPInt_Context)& );
const Handle(IntTools_Context)& );
static
Standard_Boolean IsCurveValid(Handle(Geom2d_Curve)& thePCurve);
@@ -225,7 +225,7 @@ static
Handle(TColgp_HArray1OfPnt2d)& theResultOnS1,
Handle(TColgp_HArray1OfPnt2d)& theResultOnS2,
Handle(TColStd_HArray1OfReal)& theResultRadius,
const Handle(BOPInt_Context)& );
const Handle(IntTools_Context)& );
static
Standard_Boolean FindPoint(const gp_Pnt2d& theFirstPoint,
@@ -296,7 +296,7 @@ static
const Handle(GeomAdaptor_HSurface) myHS2,
const TopoDS_Face& aF1,
const TopoDS_Face& aF2,
const Handle(BOPInt_Context)& aCtx);
const Handle(IntTools_Context)& aCtx);
static
Standard_Boolean CheckPCurve(const Handle(Geom2d_Curve)& aPC,
@@ -314,7 +314,7 @@ static
const Handle(GeomAdaptor_HSurface)& myHS2,
const TopoDS_Face& aF1,
const TopoDS_Face& aF2,
const Handle(BOPInt_Context)& aCtx);
const Handle(IntTools_Context)& aCtx);
//=======================================================================
//function :
@@ -336,7 +336,7 @@ IntTools_FaceFace::IntTools_FaceFace()
//function : SetContext
//purpose :
//=======================================================================
void IntTools_FaceFace::SetContext(const Handle(BOPInt_Context)& aContext)
void IntTools_FaceFace::SetContext(const Handle(IntTools_Context)& aContext)
{
myContext=aContext;
}
@@ -344,7 +344,7 @@ void IntTools_FaceFace::SetContext(const Handle(BOPInt_Context)& aContext)
//function : Context
//purpose :
//=======================================================================
const Handle(BOPInt_Context)& IntTools_FaceFace::Context()const
const Handle(IntTools_Context)& IntTools_FaceFace::Context()const
{
return myContext;
}
@@ -522,7 +522,7 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
Standard_Boolean RestrictLine = Standard_False, hasCone = Standard_False;
if (myContext.IsNull()) {
myContext=new BOPInt_Context;
myContext=new IntTools_Context;
}
mySeqOfCurve.Clear();
@@ -3396,7 +3396,7 @@ Standard_Integer ComputeTangentZones( const Handle(GeomAdaptor_HSurface)& theSur
Handle(TColgp_HArray1OfPnt2d)& theResultOnS1,
Handle(TColgp_HArray1OfPnt2d)& theResultOnS2,
Handle(TColStd_HArray1OfReal)& theResultRadius,
const Handle(BOPInt_Context)& aContext)
const Handle(IntTools_Context)& aContext)
{
Standard_Integer aResult = 0;
if ( !CheckTangentZonesExist( theSurface1, theSurface2 ) )
@@ -3608,7 +3608,7 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
const Standard_Boolean theAvoidLConstructor,
IntPatch_SequenceOfLine& theNewLines,
Standard_Real& theReachedTol3d,
const Handle(BOPInt_Context)& aContext)
const Handle(IntTools_Context)& aContext)
{
Standard_Boolean bRet, bAvoidLineConstructor;
@@ -4333,7 +4333,7 @@ Standard_Boolean ParameterOutOfBoundary(const Standard_Real theParameter,
const Standard_Real theOtherParameter,
const Standard_Boolean bIncreasePar,
Standard_Real& theNewParameter,
const Handle(BOPInt_Context)& aContext)
const Handle(IntTools_Context)& aContext)
{
Standard_Boolean bIsComputed = Standard_False;
theNewParameter = theParameter;
@@ -4965,7 +4965,7 @@ Standard_Real FindMaxSquareDistance (const Standard_Real aT1,
const Handle(GeomAdaptor_HSurface)& myHS2,
const TopoDS_Face& myFace1,
const TopoDS_Face& myFace2,
const Handle(BOPInt_Context)& myContext)
const Handle(IntTools_Context)& myContext)
{
Standard_Real aA, aB, aCf, aX1, aX2, aF1, aF2, aX, aF;
//
@@ -5019,7 +5019,7 @@ Standard_Real MaxSquareDistance (const Standard_Real aT,
const Handle(GeomAdaptor_HSurface) myHS2,
const TopoDS_Face& aF1,
const TopoDS_Face& aF2,
const Handle(BOPInt_Context)& aCtx)
const Handle(IntTools_Context)& aCtx)
{
Standard_Boolean bIsDone;
Standard_Integer i;

95
src/IntTools/IntTools_ShrunkRange.cdl Normal file
View File

@@ -0,0 +1,95 @@
-- Created by: Peter KURNEV
-- 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.
class ShrunkRange from IntTools
---Purpose:
--- The class provides the computation of
--- a working (shrunk) range [t1, t2] for
--- the 3D-curve of the edge.
uses
Box from Bnd,
Edge from TopoDS,
Vertex from TopoDS,
Context from IntTools
--raises
is
Create
returns ShrunkRange from IntTools;
---C++: alias "Standard_EXPORT virtual ~IntTools_ShrunkRange();"
SetData (me:out;
aE : Edge from TopoDS;
aT1 : Real from Standard;
aT2 : Real from Standard;
aV1 : Vertex from TopoDS;
aV2 : Vertex from TopoDS);
SetContext(me:out;
aCtx: Context from IntTools);
Context(me)
returns Context from IntTools;
---C++: return const &
SetShrunkRange(me:out;
aT1 : Real from Standard;
aT2 : Real from Standard);
ShrunkRange(me;
aT1 :out Real from Standard;
aT2 :out Real from Standard);
BndBox (me)
returns Box from Bnd;
---C++: return const &
Edge (me)
returns Edge from TopoDS;
---C++: return const &
Perform(me:out);
ErrorStatus(me)
returns Integer from Standard;
---Purpose:
--- Returns code of computing shrunk range
--- completion
--- 0 - means successful completion
--- 1 - nothing has been done
--- 2 - initial range is out of edge's range
--- 3 - first boundary of initial range is more than
--- last boundary
--- 4 - projection of first vertex failed
--- 5 - projection of second vertex failed
--- 6 - shrunk range can not be computed
--- shrunk range is setted to initial range
---
fields
myEdge : Edge from TopoDS is protected;
myV1 : Vertex from TopoDS is protected;
myV2 : Vertex from TopoDS is protected;
myT1 : Real from Standard is protected;
myT2 : Real from Standard is protected;
myTS1 : Real from Standard is protected;
myTS2 : Real from Standard is protected;
myBndBox : Box from Bnd is protected;
myCtx : Context from IntTools is protected;
myErrorStatus : Integer from Standard is protected;
end ShrunkRange;

482
src/IntTools/IntTools_ShrunkRange.cxx Normal file
View File

@@ -0,0 +1,482 @@
// Created by: Peter KURNEV
// 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 <IntTools_ShrunkRange.ixx>
#include <Precision.hxx>
#include <gp.hxx>
#include <gp_Circ.hxx>
#include <Geom_Curve.hxx>
#include <BRep_Tool.hxx>
#include <BRepBuilderAPI_MakeVertex.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BndLib_Add3dCurve.hxx>
#include <IntTools_Context.hxx>
#include <gp_Lin.hxx>
#include <ElCLib.hxx>
//=======================================================================
//function :
//purpose :
//=======================================================================
IntTools_ShrunkRange::IntTools_ShrunkRange ()
{
myT1=-99;
myT2=myT1;
myTS1=myT1;
myTS2=myT1;
myErrorStatus=1;
}
//=======================================================================
//function : ~
//purpose :
//=======================================================================
IntTools_ShrunkRange::~IntTools_ShrunkRange ()
{
}
//=======================================================================
//function : SetData
//purpose :
//=======================================================================
void IntTools_ShrunkRange::SetData(const TopoDS_Edge& aE,
const Standard_Real aT1,
const Standard_Real aT2,
const TopoDS_Vertex& aV1,
const TopoDS_Vertex& aV2)
{
myEdge=aE;
myV1=aV1;
myV2=aV2;
myT1=aT1;
myT2=aT2;
myErrorStatus=1;
}
//=======================================================================
//function : SetContext
//purpose :
//=======================================================================
void IntTools_ShrunkRange::SetContext(const Handle(IntTools_Context)& aCtx)
{
myCtx=aCtx;
}
//=======================================================================
//function : Context
//purpose :
//=======================================================================
const Handle(IntTools_Context)& IntTools_ShrunkRange::Context()const
{
return myCtx;
}
//=======================================================================
//function : Edge
//purpose :
//=======================================================================
const TopoDS_Edge& IntTools_ShrunkRange::Edge() const
{
return myEdge;
}
//=======================================================================
//function : ShrunkRange
//purpose :
//=======================================================================
void IntTools_ShrunkRange::ShrunkRange(Standard_Real& aT1,
Standard_Real& aT2) const
{
aT1=myTS1;
aT2=myTS2;
}
//=======================================================================
//function : BndBox
//purpose :
//=======================================================================
const Bnd_Box& IntTools_ShrunkRange::BndBox() const
{
return myBndBox;
}
//=======================================================================
//function : ErrorStatus
//purpose :
//=======================================================================
Standard_Integer IntTools_ShrunkRange::ErrorStatus() const
{
return myErrorStatus;
}
//=======================================================================
//function : SetShrunkRange
//purpose :
//=======================================================================
void IntTools_ShrunkRange::SetShrunkRange(const Standard_Real aT1,
const Standard_Real aT2)
{
myTS1=aT1;
myTS2=aT2;
//
BRepAdaptor_Curve aBAC(myEdge);
BndLib_Add3dCurve::Add (aBAC, aT1, aT2, 0., myBndBox);
}
//=======================================================================
//function : Perform
//purpose :
//=======================================================================
void IntTools_ShrunkRange::Perform()
{
Standard_Real aCF, aCL, aTolE, aTolV1;
Standard_Real aTolV2, t1, t11, t1C, t2, t12, t2C;
Standard_Real aCoeff1, aCoeff2, aTol1, aTol2, dt1, dt2, aR, anEps;
Standard_Integer pri;
Standard_Boolean bInf1, bInf2, bAppr;
GeomAbs_CurveType aCurveType;
Handle(Geom_Curve) aC;
//
myErrorStatus=0;
myTS1=-99;
myTS2=myTS1;
anEps = 1.e-8;
//
aTolE =BRep_Tool::Tolerance(myEdge);
aTolV1=BRep_Tool::Tolerance(myV1);
aTolV2=BRep_Tool::Tolerance(myV2);
//for edges with the tolerance value
//more than the tolerance value of vertices
if (aTolV1 < aTolE) {
aTolV1 = aTolE;
}
//
if (aTolV2 < aTolE) {
aTolV2 = aTolE;
}
//
t1=myT1;
t2=myT2;
//
BRepAdaptor_Curve aBAC(myEdge);
aCurveType=aBAC.GetType();
//
aC=BRep_Tool::Curve(myEdge, aCF, aCL);
BRep_Tool::Range(myEdge, aCF, aCL);
//
if (t1 < aCF || t2 > aCL) {
myErrorStatus=2;
return;
}
//
bAppr = !(fabs(t2 - t1) > 100);
if (fabs(t2 - t1) < anEps) {
myErrorStatus=7;
return;
}
//
if (t1 > t2) {
myErrorStatus=3;
return;
}
//
aTol1 = aTolV1+aTolE;
aTol2 = aTolV2+aTolE;
//
aCoeff1 = (aTolE>0.05) ? 1. : 2.;
aCoeff2 = aCoeff1;
if (aCoeff1 == 2.) {
aCoeff1=(aTol1>0.05) ? 1.5 : 2.;
aCoeff2=(aTol2>0.05) ? 1.5 : 2.;
}
// xf
if (aCurveType==GeomAbs_Line && (aCoeff1 != 1 || aCoeff2 != 1)) {
Standard_Real aTV1, aTV2, aEps;
gp_Pnt aPV1, aPV2, aPC1, aPC2;
gp_Lin aL;
//
aEps=Precision::Confusion();
aEps=aEps*aEps;//1.e-14;
aL=aBAC.Line();
//
aPV1=BRep_Tool::Pnt(myV1);
aTV1=ElCLib::Parameter(aL, aPV1);
//
aPV2=BRep_Tool::Pnt(myV2);
aTV2=ElCLib::Parameter(aL, aPV2);
//
if (fabs(aTV1-aCF)<aEps) {
aCoeff1=1.;
}
if (fabs(aTV2-aCL)<aEps) {
aCoeff2=1.;
}
}
//
dt1=aCoeff1*aTol1;
dt2=aCoeff2*aTol2;
// xt
//
if (aCurveType==GeomAbs_Line) {
Standard_Real dt1x, dt2x;
dt1x = aBAC.Resolution(dt1);
t11=t1+dt1x;
dt2x = aBAC.Resolution(dt2);
t12=t2-dt2x;
if (t11>t2 || t12<t1) {
t1C=t1;
t2C=t2;
myTS1=t1C;
myTS2=t2C;
//
// BndBox
Standard_Real ddx=aTolE;//1.e-12;
BndLib_Add3dCurve::Add (aBAC, t1C, t2C, ddx, myBndBox);
myErrorStatus=6;//0
return;
}
}
//
if (aCurveType==GeomAbs_Circle) {
gp_Circ aCrc=aBAC.Circle();
aR=aCrc.Radius();
t1C=t1+dt1/aR;
t2C=t2-dt2/aR;
}
else {
//
// Vertex1 => t1C
gp_Pnt aP1,aP11;
aC->D0 (t1, aP1);
//
bInf1=Precision::IsNegativeInfinite(t1);
if (bInf1) {
t1C=t1;
}
//
else {
Standard_Real d1 = aCoeff1*aTol1;
// dt1 = aBAC.Resolution(d1);
//
gp_Vec aD1vec1;
gp_Pnt aPoint;
aBAC.D1(t1, aPoint, aD1vec1);
Standard_Real ad1length1 = aD1vec1.Magnitude();
Standard_Boolean bTryOtherPoints = Standard_False;
dt1 = (t2 - t1) * 0.5;
if(ad1length1 > 1.e-12) {
dt1 = d1 / ad1length1;
if(dt1 > (t2 - t1)) {
// bad parametrization, big tolerance or too small range
bTryOtherPoints = Standard_True;
}
}
else {
bTryOtherPoints = Standard_True;
}
if(bTryOtherPoints) {
Standard_Integer nbsamples = 5;
Standard_Integer ii = 0;
Standard_Real adelta = (t2 - t1) / (nbsamples + 1);
Standard_Boolean bFound = Standard_False;
for(ii = 1; ii <= nbsamples; ii++) {
Standard_Real aparameter = t1 + (adelta * ii);
gp_Pnt aPoint2;
aBAC.D1(aparameter, aPoint2, aD1vec1);
if(aPoint.Distance(aPoint2) < d1)
dt1 = adelta * ii;
ad1length1 = aD1vec1.Magnitude();
if(ad1length1 > 1.e-12) {
dt1 = d1 / ad1length1;
if(dt1 < (t2 - t1)) {
bFound = Standard_True;
break;
}
}
}
if(!bFound) {
if(dt1 > (t2 - t1)) {
dt1 = aBAC.Resolution(d1);
}
}
}
//
if (!bAppr) {
dt1 *= 10;
}
t11=t1+dt1;
aC->D0 (t11, aP11);
gp_Vec aV11(aP1, aP11);
// avoid exception if aP1 == aP11
if (aV11.SquareMagnitude() < gp::Resolution())
t1C = t1;
else {
gp_Dir aD11(aV11);
gp_Pnt aP1L;
//
aP1L.SetCoord (aP1.X()+d1*aD11.X(),
aP1.Y()+d1*aD11.Y(),
aP1.Z()+d1*aD11.Z());
BRepBuilderAPI_MakeVertex aMV1(aP1L);
const TopoDS_Vertex& aV1L=aMV1.Vertex();
//
pri=myCtx->ComputeVE (aV1L, myEdge, t1C);
//
if (pri==-3) {
myErrorStatus=4;
return;
}
}
}
//
// Vertex2 => t2C
gp_Pnt aP2, aP12;
aC->D0 (t2, aP2);
//
bInf2=Precision::IsPositiveInfinite(t2);
if (bInf2) {
t2C=t2;
}
//
else {
Standard_Real d2 = aCoeff2*aTol2;
// dt2 = aBAC.Resolution(d2);
//
gp_Vec aD1vec2;
gp_Pnt aPoint;
aBAC.D1(t2, aPoint, aD1vec2);
Standard_Real ad1length2 = aD1vec2.Magnitude();
Standard_Boolean bTryOtherPoints = Standard_False;
dt2 = (t2 - t1) * 0.5;
if(ad1length2 > 1.e-12) {
dt2 = d2 / ad1length2;
if(dt2 > (t2 - t1)) {
bTryOtherPoints = Standard_True;
}
}
else {
bTryOtherPoints = Standard_True;
}
if(bTryOtherPoints) {
Standard_Integer nbsamples = 5;
Standard_Integer ii = 0;
Standard_Real adelta = (t2 - t1) / (nbsamples + 1);
Standard_Boolean bFound = Standard_False;
for(ii = 1; ii <= nbsamples; ii++) {
Standard_Real aparameter = t2 - (adelta * ii);
gp_Pnt aPoint2;
aBAC.D1(aparameter, aPoint2, aD1vec2);
if(aPoint.Distance(aPoint2) < d2)
dt2 = adelta * ii;
ad1length2 = aD1vec2.Magnitude();
if(ad1length2 > 1.e-12) {
dt2 = d2 / ad1length2;
if(dt2 < (t2 - t1)) {
bFound = Standard_True;
break;
}
}
}
if(!bFound) {
if(dt2 > (t2 - t1)) {
dt2 = aBAC.Resolution(d2);
}
}
}
//
if (!bAppr) {
dt2 *= 10;
}
t12=t2-dt2;
aC->D0 (t12, aP12);
gp_Vec aV12(aP2, aP12);
// avoid exception if aP1 == aP11
if (aV12.SquareMagnitude() < gp::Resolution())
t2C = t2;
else {
gp_Dir aD12(aV12);
gp_Pnt aP2L;
//
aP2L.SetCoord (aP2.X()+d2*aD12.X(),
aP2.Y()+d2*aD12.Y(),
aP2.Z()+d2*aD12.Z());
BRepBuilderAPI_MakeVertex aMV2(aP2L);
const TopoDS_Vertex& aV2L=aMV2.Vertex();
//
pri=myCtx->ComputeVE (aV2L, myEdge, t2C);
//
if (pri==-3) {
myErrorStatus=5;
return;
}
}
}
} // else {
//
if (t1C>t2){
t1C=0.5*(t2+t1);
t2C=t1C+0.1*(t2-t1C);
}
if (t1C>t2C) {
t2C=t1C+0.1*(t2-t1C);
}
//
if (t2C-t1C < anEps) {
myErrorStatus = 7;
return;
}
//
myTS1=t1C;
myTS2=t2C;
//
// BndBox
Standard_Real ddx=aTolE;//1.e-12;
BndLib_Add3dCurve::Add (aBAC, t1C, t2C, ddx, myBndBox);
}
/////////////////////////////////////////////////////////////////////////
//
// myErrorStatus :
//
// 1- Nothing has been done
// 2- The source range is out of the edge's range
// 3- t1 < t2 for source range
// 4- Can not project V1L to the Edge;
// 5- Can not project V2L to the Edge;
// 6- for obtained shrunk range [t11, t12] -> t11>t2 || t12<t1;
// 7- too small range.

320
src/IntTools/IntTools_Tools.cdl
View File

@@ -15,9 +15,9 @@
class Tools from IntTools
---Purpose:
--- The class contains handy static functions
--- dealing with the geometry and topology.
---Purpose:
--- The class contains handy static functions
--- dealing with the geometry and topology.
uses
Shape from TopoDS,
@@ -28,160 +28,214 @@ uses
Pnt2d from gp,
Pnt from gp,
Dir from gp,
Lin from gp,
Pln from gp,
CommonPrt from IntTools,
Curve from IntTools,
Range from IntTools,
SequenceOfCurves from IntTools,
Curve from Geom,
State from TopAbs
State from TopAbs,
Box from Bnd
is
ComputeVV (myclass;V1,V2:Vertex from TopoDS)
returns Integer from Standard;
---Purpose:
--- Computes distance between vertex V1 and vertex V2,
--- if the distance is less than sum of vertex tolerances
--- returns zero,
--- otherwise returns negative value
---
returns Integer from Standard;
---Purpose:
--- Computes distance between vertex V1 and vertex V2,
--- if the distance is less than sum of vertex tolerances
--- returns zero,
--- otherwise returns negative value
---
HasInternalEdge (myclass;
aW: Wire from TopoDS)
returns Boolean from Standard;
---Purpose:
--- Returns True if wire aW contains edges
--- with INTERNAL orientation
---
aW: Wire from TopoDS)
returns Boolean from Standard;
---Purpose:
--- Returns True if wire aW contains edges
--- with INTERNAL orientation
---
MakeFaceFromWireAndFace (myclass;
aW: Wire from TopoDS;
aF: Face from TopoDS;
aFNew:out Face from TopoDS);
---Purpose:
--- Build a face based on surface of given face aF
--- and bounded by wire aW
---
ClassifyPointByFace (myclass;
aF: Face from TopoDS;
P: Pnt2d from gp)
returns State from TopAbs;
---Purpose:
---
---
aW: Wire from TopoDS;
aF: Face from TopoDS;
aFNew:out Face from TopoDS);
---Purpose:
--- Build a face based on surface of given face aF
--- and bounded by wire aW
---
ClassifyPointByFace (myclass;
aF: Face from TopoDS;
P: Pnt2d from gp)
returns State from TopAbs;
---Purpose:
---
---
IsVertex (myclass; E: Edge from TopoDS;
t: Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Computes square distance between a point on the edge E
--- corresponded to parameter t and vertices of edge E.
--- Returns True if this distance is less than square
--- tolerance of vertex, otherwise returns false.
---
IsVertex (myclass; E: Edge from TopoDS;
V: Vertex from TopoDS;
t: Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Returns True if square distance between vertex V
--- and a point on the edge E corresponded to parameter t
--- is less than square tolerance of V
---
IsVertex (myclass; aCmnPrt: CommonPrt from IntTools)
returns Boolean from Standard;
---Purpose:
--- Returns True if IsVertx for middle parameter of fist range
--- and first edge returns True
--- and if IsVertex for middle parameter of second range and
--- second range returns True,
--- otherwise returns False
---
IsMiddlePointsEqual(myclass;
E1: Edge from TopoDS;
E2: Edge from TopoDS)
t: Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Gets boundary of parameters of E1 and E2.
--- Computes 3d points on each corresponded to average parameters.
--- Returns True if distance between computed points is less than
--- sum of edge tolerance, otherwise returns False.
---
---Purpose:
--- Computes square distance between a point on the edge E
--- corresponded to parameter t and vertices of edge E.
--- Returns True if this distance is less than square
--- tolerance of vertex, otherwise returns false.
---
IsVertex (myclass; E: Edge from TopoDS;
V: Vertex from TopoDS;
t: Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Returns True if square distance between vertex V
--- and a point on the edge E corresponded to parameter t
--- is less than square tolerance of V
---
IsVertex (myclass; aCmnPrt: CommonPrt from IntTools)
returns Boolean from Standard;
---Purpose:
--- Returns True if IsVertx for middle parameter of fist range
--- and first edge returns True
--- and if IsVertex for middle parameter of second range and
--- second range returns True,
--- otherwise returns False
---
IsMiddlePointsEqual(myclass;
E1: Edge from TopoDS;
E2: Edge from TopoDS)
returns Boolean from Standard;
---Purpose:
--- Gets boundary of parameters of E1 and E2.
--- Computes 3d points on each corresponded to average parameters.
--- Returns True if distance between computed points is less than
--- sum of edge tolerance, otherwise returns False.
---
IsVertex (myclass;
aP : Pnt from gp;
aTolPV: Real from Standard;
aV: Vertex from TopoDS)
returns Boolean from Standard;
---Purpose:
--- Returns True if the distance between point aP and
--- vertex aV is less or equal to sum of aTolPV and
--- vertex tolerance, otherwise returns False
---
aP : Pnt from gp;
aTolPV: Real from Standard;
aV: Vertex from TopoDS)
returns Boolean from Standard;
---Purpose:
--- Returns True if the distance between point aP and
--- vertex aV is less or equal to sum of aTolPV and
--- vertex tolerance, otherwise returns False
---
IntermediatePoint (myclass;
aFirst: Real from Standard;
aLast : Real from Standard)
returns Real from Standard;
---Purpose:
--- Returns some value between aFirst and aLast
---
aFirst: Real from Standard;
aLast : Real from Standard)
returns Real from Standard;
---Purpose:
--- Returns some value between aFirst and aLast
---
SplitCurve (myclass;
aC : Curve from IntTools;
aS :out SequenceOfCurves from IntTools)
returns Integer from Standard;
---Purpose:
--- Split aC by average parameter if aC is closed in 3D.
--- Returns positive value if splitting has been done,
--- otherwise returns zero.
---
aC : Curve from IntTools;
aS :out SequenceOfCurves from IntTools)
returns Integer from Standard;
---Purpose:
--- Split aC by average parameter if aC is closed in 3D.
--- Returns positive value if splitting has been done,
--- otherwise returns zero.
---
RejectLines(myclass;
aSIn: SequenceOfCurves from IntTools;
aSOut:out SequenceOfCurves from IntTools);
---Purpose:
--- Puts curves from aSIn to aSOut except those curves that
--- are coincide with first curve from aSIn.
---
aSIn: SequenceOfCurves from IntTools;
aSOut:out SequenceOfCurves from IntTools);
---Purpose:
--- Puts curves from aSIn to aSOut except those curves that
--- are coincide with first curve from aSIn.
---
IsDirsCoinside (myclass;
D1:Dir from gp;
D2:Dir from gp)
returns Boolean from Standard;
---Purpose:
--- Returns True if D1 and D2 coinside
---
D1:Dir from gp;
D2:Dir from gp)
returns Boolean from Standard;
---Purpose:
--- Returns True if D1 and D2 coinside
---
IsDirsCoinside (myclass;
D1 :Dir from gp;
D2 :Dir from gp;
aTol:Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Returns True if D1 and D2 coinside with given tolerance
---
D1 :Dir from gp;
D2 :Dir from gp;
aTol:Real from Standard)
returns Boolean from Standard;
---Purpose:
--- Returns True if D1 and D2 coinside with given tolerance
---
IsClosed (myclass;
aC : Curve from Geom)
returns Boolean from Standard;
---Purpose:
--- Returns True if aC is BoundedCurve from Geom and
--- the distance between first point
--- of the curve aC and last point
--- is less than 1.e-12
---
aC : Curve from Geom)
returns Boolean from Standard;
---Purpose:
--- Returns True if aC is BoundedCurve from Geom and
--- the distance between first point
--- of the curve aC and last point
--- is less than 1.e-12
---
CurveTolerance(myclass;
aC : Curve from Geom;
aTolBase : Real from Standard)
returns Real from Standard;
---Purpose:
--- Returns adaptive tolerance for given aTolBase
--- if aC is trimmed curve and basis curve is parabola,
--- otherwise returns value of aTolBase
---
aC : Curve from Geom;
aTolBase : Real from Standard)
returns Real from Standard;
---Purpose:
--- Returns adaptive tolerance for given aTolBase
--- if aC is trimmed curve and basis curve is parabola,
--- otherwise returns value of aTolBase
---
--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
CheckCurve(myclass;
theC:Curve from Geom;
theTol:Real from Standard;
theBox:out Box from Bnd)
returns Boolean from Standard;
IsOnPave(myclass;
theT:Real from Standard;
theRange:Range from IntTools;
theTol: Real from Standard)
returns Boolean from Standard;
VertexParameters(myclass;
theCP:CommonPrt from IntTools;
theT1:out Real from Standard;
theT2:out Real from Standard);
VertexParameter(myclass;
theCP:CommonPrt from IntTools;
theT:out Real from Standard);
IsOnPave1(myclass;
theT:Real from Standard;
theRange:Range from IntTools;
theTol: Real from Standard)
returns Boolean from Standard;
IsInRange(myclass;
theRRef : Range from IntTools;
theR : Range from IntTools;
theTol : Real from Standard)
returns Boolean from Standard;
---Purpose: Checks if the range <theR> interfere with the range <theRRef>
SegPln(myclass;
theLin : Lin from gp;
theTLin1 : Real from Standard;
theTLin2 : Real from Standard;
theTolLin: Real from Standard;
thePln : Pln from gp;
theTolPln: Real from Standard;
theP :out Pnt from gp;
theT :out Real from Standard;
theTolP :out Real from Standard;
theTmin :out Real from Standard;
theTmax :out Real from Standard)
returns Integer from Standard;
end Tools;

270
src/IntTools/IntTools_Tools.cxx
View File

@@ -61,11 +61,11 @@
static
void ParabolaTolerance(const Handle(Geom_Curve)& ,
const Standard_Real ,
const Standard_Real ,
const Standard_Real ,
Standard_Real& ,
Standard_Real& );
const Standard_Real ,
const Standard_Real ,
const Standard_Real ,
Standard_Real& ,
Standard_Real& );
//=======================================================================
//function : HasInternalEdge
@@ -110,16 +110,11 @@ static
//
//modified by NIZNHY-PKV Mon Jul 04 11:58:23 2011f
aPC=Precision::Confusion();
aPC=aPC*aPC;
aDist=aP1.SquareDistance(aP2);
bRet=aDist<aPC;
return bRet;
//
//aDist=aP1.Distance(aP2);
//return (aDist < Precision::Confusion());
//modified by NIZNHY-PKV Mon Jul 04 11:59:50 2011t
}
//=======================================================================
@@ -127,7 +122,7 @@ static
//purpose :
//=======================================================================
void IntTools_Tools::RejectLines(const IntTools_SequenceOfCurves& aSIn,
IntTools_SequenceOfCurves& aSOut)
IntTools_SequenceOfCurves& aSOut)
{
Standard_Integer i, j, aNb;
Standard_Boolean bFlag;
@@ -157,7 +152,7 @@ static
if (aGLine.IsNull()) {
aSOut.Clear();
for (j=1; j<=aNb; j++) {
aSOut.Append(aSIn(j));
aSOut.Append(aSIn(j));
}
return;
}
@@ -198,8 +193,8 @@ static
//purpose :
//=======================================================================
Standard_Boolean IntTools_Tools::IsDirsCoinside (const gp_Dir& D1,
const gp_Dir& D2,
const Standard_Real dLim)
const gp_Dir& D2,
const Standard_Real dLim)
{
Standard_Boolean bFlag;
Standard_Real d;
@@ -215,7 +210,7 @@ static
//purpose :
//=======================================================================
Standard_Integer IntTools_Tools::SplitCurve(const IntTools_Curve& IC,
IntTools_SequenceOfCurves& aCvs)
IntTools_SequenceOfCurves& aCvs)
{
Handle (Geom_Curve) aC3D =IC.Curve();
if(aC3D.IsNull())
@@ -277,7 +272,7 @@ static
//purpose :
//=======================================================================
Standard_Real IntTools_Tools::IntermediatePoint (const Standard_Real aFirst,
const Standard_Real aLast)
const Standard_Real aLast)
{
//define parameter division number as 10*e^(-M_PI) = 0.43213918
const Standard_Real PAR_T = 0.43213918;
@@ -291,8 +286,8 @@ static
//purpose :
//=======================================================================
Standard_Boolean IntTools_Tools::IsVertex (const gp_Pnt& aP,
const Standard_Real aTolPV,
const TopoDS_Vertex& aV)
const Standard_Real aTolPV,
const TopoDS_Vertex& aV)
{
Standard_Boolean bRet;
Standard_Real aTolV, aD, dTol;
@@ -305,15 +300,10 @@ static
//
aPv=BRep_Tool::Pnt(aV);
//
//modified by NIZNHY-PKV Mon Jul 04 12:00:37 2011f
aD=aPv.SquareDistance(aP);
aTolV=aTolV*aTolV;
bRet=(aD<=aTolV);
return bRet;
//
//aD=aPv.Distance(aP);
//return (aD<=aTolV);
//modified by NIZNHY-PKV Mon Jul 04 12:00:40 2011t
}
@@ -351,8 +341,8 @@ static
//purpose :
//=======================================================================
Standard_Boolean IntTools_Tools::IsVertex (const TopoDS_Edge& aE,
const TopoDS_Vertex& aV,
const Standard_Real t)
const TopoDS_Vertex& aV,
const Standard_Real t)
{
Standard_Real aTolV, aTolV2, d2;
gp_Pnt aPv, aPt;
@@ -374,7 +364,7 @@ static
//purpose :
//=======================================================================
Standard_Boolean IntTools_Tools::IsVertex (const TopoDS_Edge& aE,
const Standard_Real t)
const Standard_Real t)
{
Standard_Real aTolV, aTolV2, d2;
TopoDS_Vertex aV;
@@ -404,7 +394,7 @@ static
//purpose :
//=======================================================================
Standard_Integer IntTools_Tools::ComputeVV(const TopoDS_Vertex& aV1,
const TopoDS_Vertex& aV2)
const TopoDS_Vertex& aV2)
{
Standard_Real aTolV1, aTolV2, aTolSum, d;
gp_Pnt aP1, aP2;
@@ -415,11 +405,8 @@ static
aP1=BRep_Tool::Pnt(aV1);
aP2=BRep_Tool::Pnt(aV2);
//modified by NIZNHY-PKV Mon Jul 04 11:55:52 2011f
aTolSum=aTolSum*aTolSum;
d=aP1.SquareDistance(aP2);
//d=aP1.Distance(aP2);
//modified by NIZNHY-PKV Mon Jul 04 11:55:53 2011t
if (d<aTolSum) {
return 0;
}
@@ -431,8 +418,8 @@ static
//purpose :
//=======================================================================
void IntTools_Tools::MakeFaceFromWireAndFace(const TopoDS_Wire& aW,
const TopoDS_Face& aF,
TopoDS_Face& aFNew)
const TopoDS_Face& aF,
TopoDS_Face& aFNew)
{
TopoDS_Face aFF;
aFF=aF;
@@ -447,7 +434,7 @@ static
//purpose :
//=======================================================================
TopAbs_State IntTools_Tools::ClassifyPointByFace(const TopoDS_Face& aF,
const gp_Pnt2d& aP2d)
const gp_Pnt2d& aP2d)
{
Standard_Real aFaceTolerance;
TopAbs_State aState;
@@ -464,8 +451,8 @@ static
//purpose :
//=======================================================================
Standard_Boolean IntTools_Tools::IsMiddlePointsEqual(const TopoDS_Edge& aE1,
const TopoDS_Edge& aE2)
const TopoDS_Edge& aE2)
{
Standard_Boolean bRet;
Standard_Real f1, l1, m1, f2, l2, m2, aTol1, aTol2, aSumTol, aD2;
@@ -482,17 +469,10 @@ static
C2->D0(m2, aP2);
aSumTol=aTol1+aTol2;
//modified by NIZNHY-PKV Mon Jul 04 12:02:20 2011f
aSumTol=aSumTol*aSumTol;
aD2=aP1.SquareDistance(aP2);
bRet=aD2<aSumTol;
return bRet;
//
//if (aP1.Distance(aP2) < aSumTol) {
// return Standard_True;
//}
//return Standard_False;
//modified by NIZNHY-PKV Mon Jul 04 12:02:24 2011t
}
//=======================================================================
@@ -500,7 +480,7 @@ static
//purpose :
//=======================================================================
Standard_Real IntTools_Tools::CurveTolerance(const Handle(Geom_Curve)& aC3D,
const Standard_Real aTolBase)
const Standard_Real aTolBase)
{
Standard_Real aTolReached, aTf, aTl, aTolMin, aTolMax;
@@ -535,16 +515,17 @@ static
#include <Geom_Parabola.hxx>
#include <gp_Parab.hxx>
#include <BndLib_Add3dCurve.hxx>
//=======================================================================
//function : ParabolaTolerance
//purpose :
//=======================================================================
void ParabolaTolerance(const Handle(Geom_Curve)& aC3D,
const Standard_Real aTf,
const Standard_Real aTl,
const Standard_Real aTol,
Standard_Real& aTolMin,
Standard_Real& aTolMax)
const Standard_Real aTf,
const Standard_Real aTl,
const Standard_Real aTol,
Standard_Real& aTolMin,
Standard_Real& aTolMax)
{
aTolMin=aTol;
@@ -603,4 +584,197 @@ void ParabolaTolerance(const Handle(Geom_Curve)& aC3D,
aTolMax=(aTol1>aTol2) ? aTol1 : aTol2;
aTolMin=(aTol1<aTol2) ? aTol1 : aTol2;
}
/////////////////////////////////////////////////////////////////////////
//=======================================================================
//function : CheckCurve
//purpose :
//=======================================================================
Standard_Boolean IntTools_Tools::CheckCurve(const Handle (Geom_Curve)& aC3D,
const Standard_Real aTolR3D,
Bnd_Box& aBox)
{
Standard_Boolean bRet;
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax, dX, dY, dZ;
Standard_Real dS, aTol;
GeomAdaptor_Curve aGAC;
//
aGAC.Load(aC3D);
BndLib_Add3dCurve::Add(aGAC, aTolR3D, aBox);
// 910/B1
aBox.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
dX=aXmax-aXmin;
dY=aYmax-aYmin;
dZ=aZmax-aZmin;
dS=1.e-12;
aTol=2.*aTolR3D+dS;
bRet=(dX>aTol || dY>aTol || dZ>aTol);
//
return bRet;
}
//=======================================================================
//function : IsOnPave
//purpose :
//=======================================================================
Standard_Boolean IntTools_Tools::IsOnPave(const Standard_Real aT1,
const IntTools_Range& aRange,
const Standard_Real aTolerance)
{
Standard_Boolean firstisonpave1, firstisonpave2, bIsOnPave;
//
firstisonpave1 = (Abs(aRange.First() - aT1) < aTolerance);
firstisonpave2 = (Abs(aRange.Last() - aT1) < aTolerance);
bIsOnPave=(firstisonpave1 || firstisonpave2);
return bIsOnPave;
}
//=======================================================================
// function: VertexParameters
// purpose:
//=======================================================================
void IntTools_Tools::VertexParameters(const IntTools_CommonPrt& aCPart,
Standard_Real& aT1,
Standard_Real& aT2)
{
const IntTools_Range& aR1=aCPart.Range1();
aT1=0.5*(aR1.First()+aR1.Last());
//
if((aCPart.VertexParameter1() >= aR1.First()) &&
(aCPart.VertexParameter1() <= aR1.Last())) {
aT1 = aCPart.VertexParameter1();
}
//
const IntTools_SequenceOfRanges& aRanges2=aCPart.Ranges2();
const IntTools_Range& aR2=aRanges2(1);
aT2=0.5*(aR2.First()+aR2.Last());
//
if((aCPart.VertexParameter2() >= aR2.First()) &&
(aCPart.VertexParameter2() <= aR2.Last())) {
aT2 = aCPart.VertexParameter2();
}
}
//=======================================================================
// function: VertexParameter
// purpose:
//=======================================================================
void IntTools_Tools::VertexParameter(const IntTools_CommonPrt& aCPart,
Standard_Real& aT)
{
const IntTools_Range& aR=aCPart.Range1();
aT=0.5*(aR.First()+aR.Last());
if((aCPart.VertexParameter1() >= aR.First()) &&
(aCPart.VertexParameter1() <= aR.Last())) {
aT = aCPart.VertexParameter1();
}
}
//=======================================================================
// function: IsOnPave1
// purpose:
//=======================================================================
Standard_Boolean IntTools_Tools::IsOnPave1(const Standard_Real aTR,
const IntTools_Range& aCPRange,
const Standard_Real aTolerance)
{
Standard_Boolean bIsOnPave;
Standard_Real aT1, aT2, dT1, dT2;
//
aT1=aCPRange.First();
aT2=aCPRange.Last();
bIsOnPave=(aTR>=aT1 && aTR<=aT1);
if (bIsOnPave) {
return bIsOnPave;
}
//
dT1=Abs(aTR-aT1);
dT2=Abs(aTR-aT2);
bIsOnPave=(dT1<=aTolerance || dT2<=aTolerance);
return bIsOnPave;
}
//=======================================================================
// function: IsInRange
// purpose:
//=======================================================================
Standard_Boolean IntTools_Tools::IsInRange(const IntTools_Range& aRRef,
const IntTools_Range& aR,
const Standard_Real aTolerance)
{
Standard_Boolean bIsIn;
Standard_Real aT1, aT2, aTRef1, aTRef2;
//
aR.Range(aT1, aT2);
aRRef.Range(aTRef1, aTRef2);
//
aTRef1-=aTolerance;
aTRef2+=aTolerance;
//
bIsIn = (aT1>=aTRef1 && aT1<=aTRef2) ||
(aT2>=aTRef1 && aT2<=aTRef2);
//
return bIsIn;
}
//=======================================================================
//function : SegPln
//purpose :
//=======================================================================
Standard_Integer IntTools_Tools::SegPln(const gp_Lin& theLin,
const Standard_Real theTLin1,
const Standard_Real theTLin2,
const Standard_Real theTolLin,
const gp_Pln& thePln,
const Standard_Real theTolPln,
gp_Pnt& theP,
Standard_Real& theTP,
Standard_Real& theTolP,
Standard_Real& theTPmin,
Standard_Real& theTPmax)
{
Standard_Integer iRet;
Standard_Real aTol, aA, aB, aC, aD, aE, aH, aTP, aDist1, aDist2;
gp_Pnt aP1, aP2;
//
iRet=0;
aTol=theTolLin+theTolPln;
//
const gp_Ax3& aPosPln=thePln.Position();
const gp_Dir& aDirPln=aPosPln.Direction();
const gp_Pnt& aLocPln=aPosPln.Location();
//
const gp_Dir& aDirLin=theLin.Direction();
const gp_Pnt& aLocLin=theLin.Location();
//
aP1.SetXYZ(aLocLin.XYZ()+theTLin1*aDirLin.XYZ());
aDist1=aDirPln.X()*(aP1.X()-aLocPln.X())+
aDirPln.Y()*(aP1.Y()-aLocPln.Y())+
aDirPln.Z()*(aP1.Z()-aLocPln.Z());
//
aP2.SetXYZ(aLocLin.XYZ()+theTLin2*aDirLin.XYZ());
aDist2=aDirPln.X()*(aP2.X()-aLocPln.X())+
aDirPln.Y()*(aP2.Y()-aLocPln.Y())+
aDirPln.Z()*(aP2.Z()-aLocPln.Z());
//
if (aDist1<aTol && aDist2<aTol){
iRet=1; // common block
return iRet;
}
//
if (aDist1*aDist2 > 0.) {
iRet=2; // segment lays on one side to the Plane
return iRet;
}
//
thePln.Coefficients(aA, aB, aC, aD);
aE=aA*aLocLin.X()+aB*aLocLin.Y()+aC*aLocLin.Z()+aD;
aH=aA*aDirLin.X()+aB*aDirLin.Y()+aC*aDirLin.Z();
aTP=-aE/aH;
if (aTP < theTLin1-aTol || aTP > theTLin2+aTol) {
iRet=3; // no intersections due to range of the Line
return iRet;
}
//
theTP=aTP;
theP.SetXYZ(aLocLin.XYZ()+aTP*aDirLin.XYZ());
theTolP=aTol;
theTPmin=theTP-theTolPln;
theTPmax=theTP+theTolPln;
iRet=0; // intersection point
return iRet;
}