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

0024002: Overall code and build procedure refactoring -- automatic

Browse Source 
Automatic upgrade of OCCT code by command "occt_upgrade . -nocdl":
- WOK-generated header files from inc and sources from drv are moved to src
- CDL files removed
- All packages are converted to nocdlpack
This commit is contained in:
abv
2015-07-12 07:42:38 +03:00
parent 543a996496
commit 42cf5bc1ca
15354 changed files with 623957 additions and 509844 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/IntWalk/FILES
View File

@@ -1,8 +1,20 @@
IntWalk_IWalking.gxx
IntWalk_IWalking.lxx
IntWalk_IWalking_1.gxx
IntWalk_IWalking_2.gxx
IntWalk_IWalking_3.gxx
IntWalk_IWalking_4.gxx
IntWalk_IWalking_5.gxx
IntWalk_IWalking_6.gxx
IntWalk_IWLine.gxx
IntWalk_IWLine.lxx
IntWalk_PWalking.cxx
IntWalk_PWalking.hxx
IntWalk_PWalking.lxx
IntWalk_StatusDeflection.hxx
IntWalk_TheFunctionOfTheInt2S.hxx
IntWalk_TheFunctionOfTheInt2S_0.cxx
IntWalk_TheInt2S.hxx
IntWalk_TheInt2S_0.cxx
IntWalk_VectorOfInteger.hxx
IntWalk_VectorOfWalkingData.hxx

66
src/IntWalk/IntWalk.cdl
View File

@@ -1,66 +0,0 @@
-- Created on: 1991-03-28
-- Created by: Jacques GOUSSARD
-- Copyright (c) 1991-1999 Matra Datavision
-- Copyright (c) 1999-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
package IntWalk
---Purpose: This package defines the "walking" (marching) algorithmes
-- for the intersection between two surfaces.
-- One of the surfaces is a parametric one.
-- If the other is an implicit one, the "IWalking" class will
-- be used.
-- If both surfaces are parametric, the "PWalking" class will
-- be used.
---Level: Internal
--
-- All the methods of the classes of this package are Internal.
--
uses
Standard, MMgt, TCollection, TColStd, gp, math, StdFail, IntSurf, IntImp, Adaptor3d
is
enumeration StatusDeflection is
PasTropGrand, PointConfondu, ArretSurPointPrecedent,
ArretSurPoint, OK;
-- StepTooGreat, ConfusedPoint, StopOnPreviousPoint, StopOnPoint, OK
--class of result objects marching on a biparametric surface
generic class IWLine;
--algorithm marching/solution
generic class IWalking, TheIWLine, SequenceOfIWLine;
imported VectorOfWalkingData;
imported VectorOfInteger;
--algorithm/solution for a marching on intersection between
-- 2 biparametric surfaces
class PWalking;
--internal of PWalking
class TheInt2S instantiates Int2S from IntImp
(HSurface from Adaptor3d, HSurfaceTool from Adaptor3d);
end IntWalk;

327
src/IntWalk/IntWalk_IWLine.cdl
View File

@@ -1,327 +0,0 @@
-- Created on: 1992-03-25
-- Created by: Isabelle GRIGNON
-- Copyright (c) 1992-1999 Matra Datavision
-- Copyright (c) 1999-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
generic class IWLine from IntWalk
(TheStartPoint as any)
inherits TShared from MMgt
---Purpose: Definition of a polyline resulting of the IWalking algoritm.
-- Each point verifies :
-- F(x(u,v),y(u,v),z(u,v))=0, F=implicit function.
-- (x(u,v),y(u,v),z(u,v)) point on a parametric surface.
-- This polyline is computed marching from a starting a point
-- located on the surface 's boundary or inside the surface
-- domain.
-- a marching status is returned:
-- ok --> the polyline starts and ends on a marching
-- point
-- tangent --> the polyline ends on a tangent point
-- outside the boundaries --> the polyline is outside the
-- surface 's boundaries .it ends on the natural boundaries
-- because no marching points where found to stop
-- beware : the directions are not oriented.
uses Allocator from IntSurf,
Couple from IntSurf,
SequenceOfCouple from IntSurf,
PntOn2S from IntSurf,
LineOn2S from IntSurf,
Vec from gp
raises OutOfRange from Standard,
DomainError from Standard
is
Create (theAllocator: Allocator from IntSurf = 0)
returns IWLine;
Reverse(me : mutable)
---Purpose: reverse the points in the line. Hasfirst, HasLast are kept.
is static;
Cut(me : mutable; Index : Integer from Standard)
---Purpose: Cut the line at the point of rank Index.
---C++: inline
is static;
AddPoint(me : mutable; P : PntOn2S from IntSurf)
---Purpose: Add a point in the line.
---C++: inline
is static;
AddStatusFirst(me : mutable; Closed, HasFirst : Boolean from Standard)
---Purpose:
---C++: inline
is static;
AddStatusFirst(me : mutable; Closed, HasLast : Boolean from Standard;
Index : Integer from Standard;
P : TheStartPoint)
---Purpose:
---C++: inline
is static;
AddStatusFirstLast(me : mutable;
Closed, HasFirst, HasLast: Boolean from Standard)
---Purpose:
---C++: inline
is static;
AddStatusLast(me : mutable; HasLast : Boolean from Standard)
---Purpose:
---C++: inline
is static;
AddStatusLast(me : mutable; HasLast : Boolean from Standard;
Index : Integer from Standard;
P : TheStartPoint)
---Purpose:
---C++: inline
is static;
AddIndexPassing(me : mutable; Index : Integer from Standard)
---Purpose: associer a l 'indice du point sur la ligne l'indice du point
-- passant dans l'iterateur de depart
---C++: inline
is static;
SetTangentVector(me: mutable; V: Vec from gp;
Index: Integer from Standard)
---C++: inline
is static;
SetTangencyAtBegining(me: mutable; IsTangent: Boolean from Standard)
---C++: inline
is static;
SetTangencyAtEnd(me: mutable; IsTangent: Boolean from Standard)
---C++: inline
is static;
NbPoints(me)
---Purpose: Returns the number of points of the line (including first
-- point and end point : see HasLastPoint and HasFirstPoint).
returns Integer from Standard
---C++: inline
is static;
Value(me; Index: Integer from Standard)
---Purpose: Returns the point of range Index.
-- If index <= 0 or Index > NbPoints, an exception is raised.
returns PntOn2S from IntSurf
---C++: return const&
---C++: inline
raises OutOfRange from Standard
is static;
Line(me)
---Purpose: Returns the LineOn2S contained in the walking line.
returns LineOn2S from IntSurf
---C++: return const&
---C++: inline
is static;
IsClosed(me)
---Purpose: Returns True if the line is closed.
returns Boolean from Standard
---C++: inline
is static;
HasFirstPoint(me)
---Purpose: Returns True if the first point of the line is a
-- marching point . when is HasFirstPoint==False ,the line
-- begins on the natural bound of the surface.the line can be
-- too long
returns Boolean from Standard
---C++: inline
is static;
HasLastPoint(me)
---Purpose: Returns True if the end point of the line is a
-- marching point (Point from IntWS).
-- when is HasFirstPoint==False ,the line ends
-- on the natural bound of the surface.the line can be
-- too long.
returns Boolean from Standard
---C++: inline
is static;
FirstPoint(me)
---Purpose: Returns the first point of the line when it is a
-- marching point.
-- An exception is raised if HasFirstPoint returns False.
returns any TheStartPoint
---C++: return const&
---C++: inline
raises DomainError from Standard
is static;
FirstPointIndex(me)
---Purpose: Returns the Index of first point of the line when it is a
-- marching point.This index is the index in the
-- PointStartIterator.
-- An exception is raised if HasFirstPoint returns False.
returns Integer from Standard
---C++: inline
raises DomainError from Standard
is static;
LastPoint(me)
---Purpose: Returns the last point of the line when it is a
-- marching point.
-- An exception is raised if HasLastPoint returns False.
returns any TheStartPoint
---C++: return const&
---C++: inline
raises DomainError from Standard
is static;
LastPointIndex(me)
---Purpose: Returns the index of last point of the line when it is a
-- marching point.This index is the index in the
-- PointStartIterator.
-- An exception is raised if HasLastPoint returns False.
returns Integer from Standard
---C++: inline
raises DomainError from Standard
is static;
NbPassingPoint(me)
---Purpose: returns the number of points belonging to Pnts1 which are
-- passing point.
returns Integer from Standard
---C++: inline
is static;
PassingPoint(me; Index: Integer from Standard;
IndexLine, IndexPnts : out Integer from Standard)
---Purpose: returns the index of the point belonging to the line which
-- is associated to the passing point belonging to Pnts1
-- an exception is raised if Index > NbPassingPoint()
raises OutOfRange from Standard
---C++: inline
is static;
TangentVector(me; Index: out Integer from Standard)
returns Vec from gp
---C++: return const&
---C++: inline
is static;
IsTangentAtBegining(me)
returns Boolean from Standard
---C++: inline
is static;
IsTangentAtEnd(me)
returns Boolean from Standard
---C++: inline
is static;
fields
line : LineOn2S from IntSurf;
couple : SequenceOfCouple from IntSurf;
closed : Boolean from Standard;
hasFirst : Boolean from Standard;
hasLast : Boolean from Standard;
firstIndex : Integer from Standard;
lastIndex : Integer from Standard;
theFirstPoint : TheStartPoint;
theLastPoint : TheStartPoint;
indextg : Integer from Standard;
vcttg : Vec from gp;
istgtbeg : Boolean from Standard;
istgtend : Boolean from Standard;
end IWLine;

297
src/IntWalk/IntWalk_IWalking.cdl
View File

@@ -1,297 +0,0 @@
-- Created on: 1992-03-25
-- Created by: Isabelle GRIGNON
-- Copyright (c) 1992-1999 Matra Datavision
-- Copyright (c) 1999-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
generic class IWalking from IntWalk (
ThePointOfPath as any;
ThePointOfPathTool as any;
ThePOPIterator as any;
ThePointOfLoop as any;
ThePointOfLoopTool as any;
ThePOLIterator as any;
ThePSurface as any;
ThePSurfaceTool as any;
TheIWFunction as any)
---Purpose: This class implements an algorithm to find all the points
-- on a parametric surface verifying f(u,v)=0
-- where f is defined in the IWFunction class.
-- These points are found by a marching algorithm, using a set of
-- points as starting points.
uses Vector from math,
SequenceOfInteger from TColStd,
SequenceOfReal from TColStd,
StatusDeflection from IntWalk,
VectorOfInteger from IntWalk,
VectorOfWalkingData from IntWalk,
Vec from gp,
Dir2d from gp,
PntOn2S from IntSurf
raises NotDone from StdFail,
OutOfRange from Standard
class TheIWLine instantiates IWLine from IntWalk
(ThePointOfPath);
class SequenceOfIWLine instantiates Sequence from TCollection
(TheIWLine);
is
Create(Epsilon, Deflection, Step : Real from Standard)
---Purpose: Deflection is the maximum deflection admitted between two
-- consecutive points on a resulting polyline.
-- Step is the maximum increment admitted between two
-- consecutive points (in 2d space).
-- Epsilon is the tolerance beyond which 2 points
-- are confused.
returns IWalking from IntWalk;
SetTolerance(me: in out;Epsilon, Deflection, Step : Real from Standard)
---Purpose: Deflection is the maximum deflection admitted between two
-- consecutive points on a resulting polyline.
-- Step is the maximum increment admitted between two
-- consecutive points (in 2d space).
-- Epsilon is the tolerance beyond which 2 points
-- are confused
---C++: inline
is static;
Perform(me: in out;
Pnts1 : ThePOPIterator;
Pnts2 : ThePOLIterator;
Func : in out TheIWFunction;
S : ThePSurface;
Reversed : Boolean from Standard = Standard_False)
---Purpose: Searches a set of polylines starting on a point of Pnts1
-- or Pnts2.
-- Each point on a resulting polyline verifies F(u,v)=0
is static;
Perform(me: in out;
Pnts1 : ThePOPIterator;
Func : in out TheIWFunction;
S : ThePSurface;
Reversed : Boolean from Standard = Standard_False)
---Purpose: Searches a set of polylines starting on a point of Pnts1.
-- Each point on a resulting polyline verifies F(u,v)=0
is static;
IsDone(me)
---Purpose: Returns true if the calculus was successful.
returns Boolean from Standard
---C++: inline
is static;
NbLines(me)
---Purpose: Returns the number of resulting polylines.
-- An exception is raised if IsDone returns False.
returns Integer from Standard
---C++: inline
raises NotDone from StdFail
is static;
Value(me; Index: Integer from Standard)
---Purpose: Returns the polyline of range Index.
-- An exception is raised if IsDone is False.
-- An exception is raised if Index<=0 or Index>NbLines.
returns TheIWLine
---C++: return const&
---C++: inline
raises OutOfRange from Standard,
NotDone from StdFail
is static;
NbSinglePnts(me)
---Purpose: Returns the number of points belonging to Pnts on which no
-- line starts or ends.
-- An exception is raised if IsDone returns False.
returns Integer from Standard
---C++: inline
raises NotDone from StdFail
is static;
SinglePnt(me ; Index: Integer from Standard)
---Purpose: Returns the point of range Index .
-- An exception is raised if IsDone returns False.
-- An exception is raised if Index<=0 or
-- Index > NbSinglePnts.
returns ThePointOfPath
---C++: return const&
---C++: inline
raises OutOfRange from Standard,
NotDone from StdFail
is static;
-- -- private
Cadrage(me; BornInf, BornSup, UVap : in out Vector from math;
Step : in out Real from Standard;
-- StepV : in out Real from Standard;
StepSign : Integer from Standard)
returns Boolean from Standard
is static protected;
TestArretPassage (me: in out; Umult : SequenceOfReal from TColStd;
Vmult : SequenceOfReal from TColStd;
Section: in out TheIWFunction;
UV : in out Vector from math;
Irang : out Integer from Standard)
returns Boolean from Standard
is static protected;
TestArretPassage (me: in out; Umult : SequenceOfReal from TColStd;
Vmult : SequenceOfReal from TColStd;
UV : Vector from math;
Index : Integer from Standard;
Irang : out Integer from Standard)
returns Boolean from Standard
is static protected;
TestArretAjout(me: in out; Section: in out TheIWFunction;
UV : in out Vector from math;
Irang : out Integer from Standard;
PSol : out PntOn2S from IntSurf )
returns Boolean from Standard
is static protected;
TestArretCadre(me : in out; Umult : SequenceOfReal from TColStd;
Vmult : SequenceOfReal from TColStd;
Line : TheIWLine;
Section: in out TheIWFunction;
UV : in out Vector from math;
Irang : out Integer from Standard)
is static protected;
TestDeflection(me: in out; Section : in out TheIWFunction;
Finished : Boolean from Standard;
UV : Vector from math;
StatusPrecedent : StatusDeflection from IntWalk;
NbDivision : in out Integer from Standard;
Step : in out Real from Standard;
-- StepV : in out Real from Standard;
StepSign : Integer from Standard)
returns StatusDeflection from IntWalk
is static protected;
ComputeOpenLine(me : in out; Umult : SequenceOfReal from TColStd;
Vmult : SequenceOfReal from TColStd;
Pnts1 : ThePOPIterator;
Section: in out TheIWFunction;
Rajout : in out Boolean from Standard)
is static protected;
OpenLine(me : in out; N : Integer from Standard;
Psol : PntOn2S from IntSurf;
Pnts1 : ThePOPIterator;
Section: in out TheIWFunction;
Line : TheIWLine)
is static protected;
ComputeCloseLine(me : in out; Umult : SequenceOfReal from TColStd;
Vmult : SequenceOfReal from TColStd;
Pnts1 : ThePOPIterator;
Pnts2 : ThePOLIterator;
Section: in out TheIWFunction;
Rajout : in out Boolean from Standard)
is static protected;
AddPointInCurrentLine(me ; N : Integer from Standard;
PathPnt : ThePointOfPath;
CurrentLine : TheIWLine)
is static protected;
MakeWalkingPoint(me : in out ; Case : Integer from Standard;
U,V : Real from Standard;
Section : in out TheIWFunction;
Psol : in out PntOn2S from IntSurf)
is static protected;
Clear (me: in out) is static protected;
---Purpose: Clears up internal containers
fields
done : Boolean from Standard;
seqSingle : ThePOPIterator;
fleche : Real from Standard;
pas : Real from Standard;
tolerance : Vector from math;
epsilon : Real from Standard;
reversed : Boolean from Standard;
wd1 : VectorOfWalkingData from IntWalk;
wd2 : VectorOfWalkingData from IntWalk;
nbMultiplicities : VectorOfInteger from IntWalk;
Um : Real from Standard; -- Min U de la surf
UM : Real from Standard; -- Max U de la surf
Vm : Real from Standard; -- Min V de la surf
VM : Real from Standard; -- Max V de la surf
previousPoint : PntOn2S from IntSurf;
previousd3d : Vec from gp;
previousd2d : Dir2d from gp;
seqAjout : SequenceOfInteger from TColStd;
lines : SequenceOfIWLine;
end IWalking;

354
src/IntWalk/IntWalk_PWalking.cdl
View File

@@ -1,354 +0,0 @@
-- Created on: 1992-04-03
-- Created by: Isabelle GRIGNON
-- Copyright (c) 1992-1999 Matra Datavision
-- Copyright (c) 1999-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class PWalking from IntWalk
---Purpose: This class implements an algorithm to determine the
-- intersection between 2 parametrized surfaces, marching from
-- a starting point. The intersection line
-- starts and ends on the natural surface's boundaries .
uses XY from gp,
StatusDeflection from IntWalk,
ConstIsoparametric from IntImp,
Array1OfReal from TColStd,
PntOn2S from IntSurf,
LineOn2S from IntSurf,
Dir from gp,
Dir2d from gp,
Pnt from gp,
TheInt2S from IntWalk,
HSurface from Adaptor3d,
HSurfaceTool from Adaptor3d
raises OutOfRange from Standard,
NotDone from StdFail
is
Create ( Caro1 ,
Caro2 : HSurface from Adaptor3d ;
TolTangency,
Epsilon,
Deflection,
Increment : Real from Standard)
---Purpose: Constructor used to set the data to compute intersection
-- lines between Caro1 and Caro2.
-- Deflection is the maximum deflection admitted between two
-- consecutive points on the resulting polyline.
-- TolTangency is the tolerance to find a tangent point.
-- Func is the criterion which has to be evaluated at each
-- solution point (each point of the line).
-- It is necessary to call the Perform method to compute
-- the intersection lines.
-- The line found starts at a point on or in 2 natural domains
-- of surfaces. It can be closed in the
-- standard case if it is open it stops and begins at the
-- border of one of the domains. If an open line
-- stops at the middle of a domain, one stops at the tangent point.
-- Epsilon is SquareTolerance of points confusion.
returns PWalking;
Create ( Caro1 ,
Caro2 : HSurface from Adaptor3d ;
TolTangency,
Epsilon,
Deflection,
Increment : Real from Standard;
U1,V1,U2,V2 :Real from Standard)
---Purpose: Returns the intersection line containing the exact
-- point Poin. This line is a polygonal line.
-- Deflection is the maximum deflection admitted between two
-- consecutive points on the resulting polyline.
-- TolTangency is the tolerance to find a tangent point.
-- Func is the criterion which has to be evaluated at each
-- solution point (each point of the line).
-- The line found starts at a point on or in 2 natural domains
-- of surfaces. It can be closed in the
-- standard case if it is open it stops and begins at the
-- border of one of the domains. If an open line
-- stops at the middle of a domain, one stops at the tangent point.
-- Epsilon is SquareTolerance of points confusion.
returns PWalking;
Perform(me :in out;ParDep : Array1OfReal from TColStd)
---Purpose: calculate the line of intersection
is static;
Perform(me :in out;ParDep : Array1OfReal from TColStd;
u1min,v1min,u2min,v2min,u1max,v1max,u2max,v2max: Real from Standard)
---Purpose: calculate the line of intersection. The regulation
-- of steps is done using min and max values on u and
-- v. (if this data is not presented as in the
-- previous method, the initial steps are calculated
-- starting from min and max uv of faces).
is static;
PerformFirstPoint(me :in out;
ParDep : Array1OfReal from TColStd;
FirstPoint: in out PntOn2S from IntSurf)
---Purpose: calculate the first point of a line of intersection
--
returns Boolean from Standard
is static;
IsDone(me)
---Purpose: Returns true if the calculus was successful.
returns Boolean from Standard
---C++: inline
is static;
NbPoints(me)
---Purpose: Returns the number of points of the resulting polyline.
-- An exception is raised if IsDone returns False.
returns Integer from Standard
---C++: inline
raises NotDone from StdFail
is static;
Value(me ; Index : Integer from Standard)
---Purpose: Returns the point of range Index on the polyline.
-- An exception is raised if IsDone returns False.
-- An exception is raised if Index<=0 or Index>NbPoints.
returns PntOn2S from IntSurf
---C++: inline
---C++: return const&
raises NotDone from StdFail,
OutOfRange from Standard
is static;
Line(me)
returns LineOn2S from IntSurf
---C++: inline
---C++: return const&
raises NotDone from StdFail
is static;
TangentAtFirst(me)
---Purpose: Returns True if the surface are tangent at the first point
-- of the line.
-- An exception is raised if IsDone returns False.
returns Boolean from Standard
---C++: inline
raises NotDone from StdFail
is static;
TangentAtLast(me)
---Purpose: Returns true if the surface are tangent at the last point
-- of the line.
-- An exception is raised if IsDone returns False.
returns Boolean from Standard
---C++: inline
raises NotDone from StdFail
is static;
IsClosed(me)
---Purpose: Returns True if the line is closed.
-- An exception is raised if IsDone returns False.
returns Boolean from Standard
---C++: inline
raises NotDone from StdFail
is static;
TangentAtLine(me; Index: out Integer from Standard)
returns Dir from gp
---C++: return const&
---C++: inline
raises NotDone from StdFail
is static;
--private
TestDeflection(me : in out)
returns StatusDeflection from IntWalk
is static;
TestArret(me : in out; DejaReparti : Boolean from Standard;
Param : in out Array1OfReal from TColStd;
ChoixIso : out ConstIsoparametric from IntImp)
returns Boolean from Standard
is static;
RepartirOuDiviser(me : in out; DejaReparti : in out Boolean from Standard;
ChoixIso : out ConstIsoparametric from IntImp;
Arrive : in out Boolean from Standard )
is static;
AddAPoint ( me : in out ;
line : in out LineOn2S from IntSurf ;
POn2S : PntOn2S from IntSurf ) ;
---C++: inline
ExtendLineInCommonZone(me: in out; theChoixIso: ConstIsoparametric from IntImp;
theDirectionFlag: Boolean from Standard)
returns Boolean from Standard
is private;
DistanceMinimizeByGradient( me : in out;
theASurf1 , theASurf2 : HSurface from Adaptor3d ;
theU1, theV1, theU2, theV2: out Real from Standard;
theStep0U1V1: Real from Standard = 1.0e-6;
theStep0U2V2: Real from Standard = 1.0e-6)
returns Boolean from Standard
is private;
-- Finds one intersection point of two given surfaces with given
-- initial point.
DistanceMinimizeByExtrema(me : in out;
theASurf1 : HSurface from Adaptor3d ;
theP0 : Pnt from gp;
theU0, theV0: out Real from Standard;
theStep0U: Real from Standard = 1.0;
theStep0V: Real from Standard = 1.0)
returns Boolean from Standard
is private;
-- Finds one intersection point of two given surfaces with given
-- initial point.
SeekPointOnBoundary(me : in out;
theASurf1 , theASurf2 : HSurface from Adaptor3d ;
theU1, theV1, theU2, theV2: Real from Standard;
isTheFirst : Boolean from Standard)
returns Boolean from Standard
is private;
-- Unites and correctly coordinates of work of
-- "DistanceMinimizeByGradient" and "DistanceMinimizeByExtrema" functions.
PutToBoundary( me : in out;
theASurf1 , theASurf2 : HSurface from Adaptor3d)
-- Tries to extend existing intersection line
-- (as set of points) to surface's boundaries,
-- if it is possibly.
-- If line is scienter far from boundaries
-- or is (almost) parralel with some boundary,
-- extending is not required.
returns Boolean from Standard;
SeekAdditionalPoints( me : in out;
theASurf1 , theASurf2 : HSurface from Adaptor3d;
theMinNbPoints : Integer from Standard)
returns Boolean from Standard;
-- Unites and correctly coordinates of work of
-- "DistanceMinimizeByGradient" and "DistanceMinimizeByExtrema" functions.
fields
done : Boolean from Standard;
line : LineOn2S from IntSurf;
close : Boolean from Standard;
tgfirst : Boolean from Standard;
tglast : Boolean from Standard;
indextg : Integer from Standard;
tgdir : Dir from gp;
fleche : Real from Standard; -- max possible vector
pasMax : Real from Standard; -- max possible uv ratio
tolconf : Real from Standard; -- tol of confusion of 2 points
pasuv : Real from Standard[4];-- uv step on squares
pasSav : Real from Standard[4];-- first saved step
pasInit : Real from Standard[4];-- saving of steps
Um1 : Real from Standard;
UM1 : Real from Standard;
Vm1 : Real from Standard;
VM1 : Real from Standard;
Um2 : Real from Standard;
UM2 : Real from Standard;
Vm2 : Real from Standard;
VM2 : Real from Standard;
ResoU1 : Real from Standard;
ResoU2 : Real from Standard;
ResoV1 : Real from Standard;
ResoV2 : Real from Standard;
sensCheminement : Integer from Standard;
choixIsoSav : ConstIsoparametric from IntImp;
-- save 1st iso choice
previousPoint : PntOn2S from IntSurf;
-- previous intersection point
previoustg : Boolean from Standard;
previousd : Dir from gp;
previousd1 : Dir2d from gp;
previousd2 : Dir2d from gp;
firstd1 : Dir2d from gp;
firstd2 : Dir2d from gp;
myIntersectionOn2S : TheInt2S from IntWalk;
STATIC_BLOCAGE_SUR_PAS_TROP_GRAND : Integer from Standard;
STATIC_PRECEDENT_INFLEXION : Integer from Standard;
end PWalking;

33
src/IntWalk/IntWalk_PWalking.cxx
View File

@@ -12,27 +12,26 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <IntWalk_PWalking.ixx>
#include <IntWalk_StatusDeflection.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <IntImp_ComputeTangence.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <Precision.hxx>
#include <math_FunctionSetRoot.hxx>
#include <Geom_Surface.hxx>
#include <Standard_Failure.hxx>
#include <gp_Pnt2d.hxx>
#include <Extrema_GenLocateExtPS.hxx>
#include <Geom_Surface.hxx>
#include <gp_Dir.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <IntImp_ComputeTangence.hxx>
#include <IntSurf_LineOn2S.hxx>
#include <IntSurf_PntOn2S.hxx>
#include <IntWalk_PWalking.hxx>
#include <IntWalk_StatusDeflection.hxx>
#include <math_FunctionSetRoot.hxx>
#include <Precision.hxx>
#include <Standard_Failure.hxx>
#include <Standard_OutOfRange.hxx>
#include <StdFail_NotDone.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfReal.hxx>
//==================================================================================
// function : IntWalk_PWalking::IntWalk_PWalking

210
src/IntWalk/IntWalk_PWalking.hxx Normal file
View File

@@ -0,0 +1,210 @@
// Created on: 1992-04-03
// Created by: Isabelle GRIGNON
// Copyright (c) 1992-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _IntWalk_PWalking_HeaderFile
#define _IntWalk_PWalking_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <gp_Dir.hxx>
#include <Standard_Real.hxx>
#include <IntImp_ConstIsoparametric.hxx>
#include <IntSurf_PntOn2S.hxx>
#include <gp_Dir2d.hxx>
#include <IntWalk_TheInt2S.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <IntWalk_StatusDeflection.hxx>
class IntSurf_LineOn2S;
class Standard_OutOfRange;
class StdFail_NotDone;
class Adaptor3d_HSurface;
class IntSurf_PntOn2S;
class gp_Dir;
class gp_Pnt;
//! This class implements an algorithm to determine the
//! intersection between 2 parametrized surfaces, marching from
//! a starting point. The intersection line
//! starts and ends on the natural surface's boundaries .
class IntWalk_PWalking
{
public:
DEFINE_STANDARD_ALLOC
//! Constructor used to set the data to compute intersection
//! lines between Caro1 and Caro2.
//! Deflection is the maximum deflection admitted between two
//! consecutive points on the resulting polyline.
//! TolTangency is the tolerance to find a tangent point.
//! Func is the criterion which has to be evaluated at each
//! solution point (each point of the line).
//! It is necessary to call the Perform method to compute
//! the intersection lines.
//! The line found starts at a point on or in 2 natural domains
//! of surfaces. It can be closed in the
//! standard case if it is open it stops and begins at the
//! border of one of the domains. If an open line
//! stops at the middle of a domain, one stops at the tangent point.
//! Epsilon is SquareTolerance of points confusion.
Standard_EXPORT IntWalk_PWalking(const Handle(Adaptor3d_HSurface)& Caro1, const Handle(Adaptor3d_HSurface)& Caro2, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment);
//! Returns the intersection line containing the exact
//! point Poin. This line is a polygonal line.
//! Deflection is the maximum deflection admitted between two
//! consecutive points on the resulting polyline.
//! TolTangency is the tolerance to find a tangent point.
//! Func is the criterion which has to be evaluated at each
//! solution point (each point of the line).
//! The line found starts at a point on or in 2 natural domains
//! of surfaces. It can be closed in the
//! standard case if it is open it stops and begins at the
//! border of one of the domains. If an open line
//! stops at the middle of a domain, one stops at the tangent point.
//! Epsilon is SquareTolerance of points confusion.
Standard_EXPORT IntWalk_PWalking(const Handle(Adaptor3d_HSurface)& Caro1, const Handle(Adaptor3d_HSurface)& Caro2, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment, const Standard_Real U1, const Standard_Real V1, const Standard_Real U2, const Standard_Real V2);
//! calculate the line of intersection
Standard_EXPORT void Perform (const TColStd_Array1OfReal& ParDep);
//! calculate the line of intersection. The regulation
//! of steps is done using min and max values on u and
//! v. (if this data is not presented as in the
//! previous method, the initial steps are calculated
//! starting from min and max uv of faces).
Standard_EXPORT void Perform (const TColStd_Array1OfReal& ParDep, const Standard_Real u1min, const Standard_Real v1min, const Standard_Real u2min, const Standard_Real v2min, const Standard_Real u1max, const Standard_Real v1max, const Standard_Real u2max, const Standard_Real v2max);
//! calculate the first point of a line of intersection
Standard_EXPORT Standard_Boolean PerformFirstPoint (const TColStd_Array1OfReal& ParDep, IntSurf_PntOn2S& FirstPoint);
//! Returns true if the calculus was successful.
Standard_Boolean IsDone() const;
//! Returns the number of points of the resulting polyline.
//! An exception is raised if IsDone returns False.
Standard_Integer NbPoints() const;
//! Returns the point of range Index on the polyline.
//! An exception is raised if IsDone returns False.
//! An exception is raised if Index<=0 or Index>NbPoints.
const IntSurf_PntOn2S& Value (const Standard_Integer Index) const;
const Handle(IntSurf_LineOn2S)& Line() const;
//! Returns True if the surface are tangent at the first point
//! of the line.
//! An exception is raised if IsDone returns False.
Standard_Boolean TangentAtFirst() const;
//! Returns true if the surface are tangent at the last point
//! of the line.
//! An exception is raised if IsDone returns False.
Standard_Boolean TangentAtLast() const;
//! Returns True if the line is closed.
//! An exception is raised if IsDone returns False.
Standard_Boolean IsClosed() const;
const gp_Dir& TangentAtLine (Standard_Integer& Index) const;
Standard_EXPORT IntWalk_StatusDeflection TestDeflection();
Standard_EXPORT Standard_Boolean TestArret (const Standard_Boolean DejaReparti, TColStd_Array1OfReal& Param, IntImp_ConstIsoparametric& ChoixIso);
Standard_EXPORT void RepartirOuDiviser (Standard_Boolean& DejaReparti, IntImp_ConstIsoparametric& ChoixIso, Standard_Boolean& Arrive);
void AddAPoint (Handle(IntSurf_LineOn2S)& line, const IntSurf_PntOn2S& POn2S);
Standard_EXPORT Standard_Boolean PutToBoundary (const Handle(Adaptor3d_HSurface)& theASurf1, const Handle(Adaptor3d_HSurface)& theASurf2);
Standard_EXPORT Standard_Boolean SeekAdditionalPoints (const Handle(Adaptor3d_HSurface)& theASurf1, const Handle(Adaptor3d_HSurface)& theASurf2, const Standard_Integer theMinNbPoints);
protected:
private:
Standard_EXPORT Standard_Boolean ExtendLineInCommonZone (const IntImp_ConstIsoparametric theChoixIso, const Standard_Boolean theDirectionFlag);
Standard_EXPORT Standard_Boolean DistanceMinimizeByGradient (const Handle(Adaptor3d_HSurface)& theASurf1, const Handle(Adaptor3d_HSurface)& theASurf2, Standard_Real& theU1, Standard_Real& theV1, Standard_Real& theU2, Standard_Real& theV2, const Standard_Real theStep0U1V1 = 1.0e-6, const Standard_Real theStep0U2V2 = 1.0e-6);
Standard_EXPORT Standard_Boolean DistanceMinimizeByExtrema (const Handle(Adaptor3d_HSurface)& theASurf1, const gp_Pnt& theP0, Standard_Real& theU0, Standard_Real& theV0, const Standard_Real theStep0U = 1.0, const Standard_Real theStep0V = 1.0);
Standard_EXPORT Standard_Boolean SeekPointOnBoundary (const Handle(Adaptor3d_HSurface)& theASurf1, const Handle(Adaptor3d_HSurface)& theASurf2, const Standard_Real theU1, const Standard_Real theV1, const Standard_Real theU2, const Standard_Real theV2, const Standard_Boolean isTheFirst);
Standard_Boolean done;
Handle(IntSurf_LineOn2S) line;
Standard_Boolean close;
Standard_Boolean tgfirst;
Standard_Boolean tglast;
Standard_Integer indextg;
gp_Dir tgdir;
Standard_Real fleche;
Standard_Real pasMax;
Standard_Real tolconf;
Standard_Real pasuv[4];
Standard_Real pasSav[4];
Standard_Real pasInit[4];
Standard_Real Um1;
Standard_Real UM1;
Standard_Real Vm1;
Standard_Real VM1;
Standard_Real Um2;
Standard_Real UM2;
Standard_Real Vm2;
Standard_Real VM2;
Standard_Real ResoU1;
Standard_Real ResoU2;
Standard_Real ResoV1;
Standard_Real ResoV2;
Standard_Integer sensCheminement;
IntImp_ConstIsoparametric choixIsoSav;
IntSurf_PntOn2S previousPoint;
Standard_Boolean previoustg;
gp_Dir previousd;
gp_Dir2d previousd1;
gp_Dir2d previousd2;
gp_Dir2d firstd1;
gp_Dir2d firstd2;
IntWalk_TheInt2S myIntersectionOn2S;
Standard_Integer STATIC_BLOCAGE_SUR_PAS_TROP_GRAND;
Standard_Integer STATIC_PRECEDENT_INFLEXION;
};
#include <IntWalk_PWalking.lxx>
#endif // _IntWalk_PWalking_HeaderFile

30
src/IntWalk/IntWalk_StatusDeflection.hxx Normal file
View File

@@ -0,0 +1,30 @@
// Created on: 1991-03-28
// Created by: Jacques GOUSSARD
// Copyright (c) 1991-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _IntWalk_StatusDeflection_HeaderFile
#define _IntWalk_StatusDeflection_HeaderFile
enum IntWalk_StatusDeflection
{
IntWalk_PasTropGrand,
IntWalk_PointConfondu,
IntWalk_ArretSurPointPrecedent,
IntWalk_ArretSurPoint,
IntWalk_OK
};
#endif // _IntWalk_StatusDeflection_HeaderFile

142
src/IntWalk/IntWalk_TheFunctionOfTheInt2S.hxx Normal file
View File

@@ -0,0 +1,142 @@
// Created on: 1991-03-28
// Created by: Jacques GOUSSARD
// Copyright (c) 1991-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _IntWalk_TheFunctionOfTheInt2S_HeaderFile
#define _IntWalk_TheFunctionOfTheInt2S_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Address.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <gp_Vec.hxx>
#include <IntImp_ConstIsoparametric.hxx>
#include <math_FunctionSetWithDerivatives.hxx>
#include <Standard_Integer.hxx>
#include <math_Vector.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <gp_Dir.hxx>
#include <gp_Dir2d.hxx>
class StdFail_UndefinedDerivative;
class Standard_ConstructionError;
class Adaptor3d_HSurface;
class Adaptor3d_HSurfaceTool;
class math_Matrix;
class IntWalk_TheFunctionOfTheInt2S : public math_FunctionSetWithDerivatives
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT IntWalk_TheFunctionOfTheInt2S();
Standard_EXPORT IntWalk_TheFunctionOfTheInt2S(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2);
Standard_EXPORT Standard_Integer NbVariables() const;
Standard_EXPORT Standard_Integer NbEquations() const;
Standard_EXPORT Standard_Boolean Value (const math_Vector& X, math_Vector& F);
Standard_EXPORT Standard_Boolean Derivatives (const math_Vector& X, math_Matrix& D);
Standard_EXPORT Standard_Boolean Values (const math_Vector& X, math_Vector& F, math_Matrix& D);
Standard_EXPORT void ComputeParameters (const IntImp_ConstIsoparametric ChoixIso, const TColStd_Array1OfReal& Param, math_Vector& UVap, math_Vector& BornInf, math_Vector& BornSup, math_Vector& Tolerance);
Standard_Real Root() const;
gp_Pnt Point() const;
Standard_EXPORT Standard_Boolean IsTangent (const math_Vector& UVap, TColStd_Array1OfReal& Param, IntImp_ConstIsoparametric& BestChoix);
gp_Dir Direction() const;
gp_Dir2d DirectionOnS1() const;
gp_Dir2d DirectionOnS2() const;
const Handle(Adaptor3d_HSurface)& AuxillarSurface1() const;
const Handle(Adaptor3d_HSurface)& AuxillarSurface2() const;
protected:
private:
Standard_Address surf1;
Standard_Address surf2;
gp_Pnt pntsol1;
gp_Pnt pntsol2;
Standard_Real f[3];
Standard_Boolean compute;
Standard_Boolean tangent;
Standard_Real tgduv[4];
gp_Vec dpuv[4];
IntImp_ConstIsoparametric chxIso;
Standard_Real paramConst;
Standard_Real ua0;
Standard_Real va0;
Standard_Real ua1;
Standard_Real va1;
Standard_Real ub0;
Standard_Real vb0;
Standard_Real ub1;
Standard_Real vb1;
Standard_Real ures1;
Standard_Real ures2;
Standard_Real vres1;
Standard_Real vres2;
};
#define ThePSurface Handle(Adaptor3d_HSurface)
#define ThePSurface_hxx <Adaptor3d_HSurface.hxx>
#define ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define IntImp_ZerParFunc IntWalk_TheFunctionOfTheInt2S
#define IntImp_ZerParFunc_hxx <IntWalk_TheFunctionOfTheInt2S.hxx>
#include <IntImp_ZerParFunc.lxx>
#undef ThePSurface
#undef ThePSurface_hxx
#undef ThePSurfaceTool
#undef ThePSurfaceTool_hxx
#undef IntImp_ZerParFunc
#undef IntImp_ZerParFunc_hxx
#endif // _IntWalk_TheFunctionOfTheInt2S_HeaderFile

33
src/IntWalk/IntWalk_TheFunctionOfTheInt2S_0.cxx Normal file
View File

@@ -0,0 +1,33 @@
// Created on: 1991-03-28
// Created by: Jacques GOUSSARD
// Copyright (c) 1991-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <IntWalk_TheFunctionOfTheInt2S.hxx>
#include <StdFail_UndefinedDerivative.hxx>
#include <Standard_ConstructionError.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <math_Matrix.hxx>
#define ThePSurface Handle(Adaptor3d_HSurface)
#define ThePSurface_hxx <Adaptor3d_HSurface.hxx>
#define ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define IntImp_ZerParFunc IntWalk_TheFunctionOfTheInt2S
#define IntImp_ZerParFunc_hxx <IntWalk_TheFunctionOfTheInt2S.hxx>
#include <IntImp_ZerParFunc.gxx>

142
src/IntWalk/IntWalk_TheInt2S.hxx Normal file
View File

@@ -0,0 +1,142 @@
// Created on: 1991-03-28
// Created by: Jacques GOUSSARD
// Copyright (c) 1991-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _IntWalk_TheInt2S_HeaderFile
#define _IntWalk_TheInt2S_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <IntSurf_PntOn2S.hxx>
#include <gp_Dir.hxx>
#include <gp_Dir2d.hxx>
#include <IntWalk_TheFunctionOfTheInt2S.hxx>
#include <Standard_Real.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <IntImp_ConstIsoparametric.hxx>
class StdFail_NotDone;
class Standard_DomainError;
class Standard_ConstructionError;
class StdFail_UndefinedDerivative;
class Adaptor3d_HSurface;
class Adaptor3d_HSurfaceTool;
class IntWalk_TheFunctionOfTheInt2S;
class math_FunctionSetRoot;
class IntSurf_PntOn2S;
class gp_Dir;
class gp_Dir2d;
class IntWalk_TheInt2S
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT IntWalk_TheInt2S();
Standard_EXPORT IntWalk_TheInt2S(const TColStd_Array1OfReal& Param, const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2, const Standard_Real TolTangency);
Standard_EXPORT IntWalk_TheInt2S(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2, const Standard_Real TolTangency);
Standard_EXPORT IntImp_ConstIsoparametric Perform (const TColStd_Array1OfReal& Param, math_FunctionSetRoot& Rsnld);
Standard_EXPORT IntImp_ConstIsoparametric Perform (const TColStd_Array1OfReal& Param, math_FunctionSetRoot& Rsnld, const IntImp_ConstIsoparametric ChoixIso);
Standard_Boolean IsDone() const;
Standard_Boolean IsEmpty() const;
const IntSurf_PntOn2S& Point() const;
Standard_Boolean IsTangent() const;
const gp_Dir& Direction() const;
const gp_Dir2d& DirectionOnS1() const;
const gp_Dir2d& DirectionOnS2() const;
IntWalk_TheFunctionOfTheInt2S& Function();
IntSurf_PntOn2S& ChangePoint();
protected:
private:
Standard_Boolean done;
Standard_Boolean empty;
IntSurf_PntOn2S pint;
Standard_Boolean tangent;
gp_Dir d3d;
gp_Dir2d d2d1;
gp_Dir2d d2d2;
IntWalk_TheFunctionOfTheInt2S myZerParFunc;
Standard_Real tol;
Standard_Real ua0;
Standard_Real va0;
Standard_Real ua1;
Standard_Real va1;
Standard_Real ub0;
Standard_Real vb0;
Standard_Real ub1;
Standard_Real vb1;
Standard_Real ures1;
Standard_Real ures2;
Standard_Real vres1;
Standard_Real vres2;
};
#define ThePSurface Handle(Adaptor3d_HSurface)
#define ThePSurface_hxx <Adaptor3d_HSurface.hxx>
#define ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define IntImp_TheFunction IntWalk_TheFunctionOfTheInt2S
#define IntImp_TheFunction_hxx <IntWalk_TheFunctionOfTheInt2S.hxx>
#define IntImp_Int2S IntWalk_TheInt2S
#define IntImp_Int2S_hxx <IntWalk_TheInt2S.hxx>
#include <IntImp_Int2S.lxx>
#undef ThePSurface
#undef ThePSurface_hxx
#undef ThePSurfaceTool
#undef ThePSurfaceTool_hxx
#undef IntImp_TheFunction
#undef IntImp_TheFunction_hxx
#undef IntImp_Int2S
#undef IntImp_Int2S_hxx
#endif // _IntWalk_TheInt2S_HeaderFile

41
src/IntWalk/IntWalk_TheInt2S_0.cxx Normal file
View File

@@ -0,0 +1,41 @@
// Created on: 1991-03-28
// Created by: Jacques GOUSSARD
// Copyright (c) 1991-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <IntWalk_TheInt2S.hxx>
#include <StdFail_NotDone.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_ConstructionError.hxx>
#include <StdFail_UndefinedDerivative.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <IntWalk_TheFunctionOfTheInt2S.hxx>
#include <math_FunctionSetRoot.hxx>
#include <IntSurf_PntOn2S.hxx>
#include <gp_Dir.hxx>
#include <gp_Dir2d.hxx>
#define ThePSurface Handle(Adaptor3d_HSurface)
#define ThePSurface_hxx <Adaptor3d_HSurface.hxx>
#define ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define IntImp_TheFunction IntWalk_TheFunctionOfTheInt2S
#define IntImp_TheFunction_hxx <IntWalk_TheFunctionOfTheInt2S.hxx>
#define IntImp_Int2S IntWalk_TheInt2S
#define IntImp_Int2S_hxx <IntWalk_TheInt2S.hxx>
#include <IntImp_Int2S.gxx>