0023024: Update headers of OCCT files
[occt.git] / src / Approx / Approx_ComputeLine.cdl
1 -- Created on: 1993-01-26
2 -- Created by: Laurent PAINNOT
3 -- Copyright (c) 1993-1999 Matra Datavision
4 -- Copyright (c) 1999-2012 OPEN CASCADE SAS
5 --
6 -- The content of this file is subject to the Open CASCADE Technology Public
7 -- License Version 6.5 (the "License"). You may not use the content of this file
8 -- except in compliance with the License. Please obtain a copy of the License
9 -- at http://www.opencascade.org and read it completely before using this file.
10 --
11 -- The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
12 -- main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
13 --
14 -- The Original Code and all software distributed under the License is
15 -- distributed on an "AS IS" basis, without warranty of any kind, and the
16 -- Initial Developer hereby disclaims all such warranties, including without
17 -- limitation, any warranties of merchantability, fitness for a particular
18 -- purpose or non-infringement. Please see the License for the specific terms
19 -- and conditions governing the rights and limitations under the License.
20
21
22
23
24 generic class ComputeLine from Approx 
25                     (MultiLine as any;
26                      LineTool  as any) --as TheLineTool(MultiLine)
27
28
29 uses ParametrizationType       from Approx,
30      SequenceOfReal            from TColStd,
31      HArray1OfReal             from TColStd,
32      Array1OfReal              from TColStd,
33      SequenceOfMultiCurve      from AppParCurves,
34      HArray1OfMultiCurve       from AppParCurves,
35      HArray1OfConstraintCouple from AppParCurves,
36      Constraint                from AppParCurves,
37      SequenceOfHArray1OfReal   from Approx,
38      MultiCurve                from AppParCurves,
39      MultiBSpCurve             from AppParCurves,
40      Vector                    from math
41      
42      
43
44 private class MyGradient instantiates Gradient from AppParCurves
45                                        (MultiLine,
46                                         LineTool);
47                                                           
48 is
49
50
51     Create(Line:            MultiLine; 
52            degreemin:       Integer = 4;
53            degreemax:       Integer = 8;
54            Tolerance3d:     Real    = 1.0e-3; 
55            Tolerance2d:     Real    = 1.0e-6;
56            NbIterations:    Integer = 5;
57            cutting:         Boolean = Standard_True; 
58            parametrization: ParametrizationType from Approx =
59            Approx_ChordLength;
60            Squares:         Boolean = Standard_False)
61            
62         ---Purpose: The MultiLine <Line> will be approximated until tolerances
63         --          will be reached.
64         --          The approximation will be done from degreemin to degreemax
65         --          with a cutting if the corresponding boolean is True.
66         --          If <Squares> is True, the computation will be done with
67         --          no iteration at all.
68
69     returns ComputeLine;
70
71
72     Create(Line:         MultiLine; 
73            Parameters:   Vector from math;
74            degreemin:    Integer = 4;
75            degreemax:    Integer = 8;
76            Tolerance3d:  Real    = 1.0e-03; 
77            Tolerance2d:  Real    = 1.0e-06; 
78            NbIterations: Integer = 5;
79            cutting:      Boolean = Standard_True; 
80            Squares:      Boolean = Standard_False)
81            
82         ---Purpose: The MultiLine <Line> will be approximated until tolerances
83         --          will be reached.
84         --          The approximation will be done from degreemin to degreemax
85         --          with a cutting if the corresponding boolean is True.
86         --          If <Squares> is True, the computation will be done with
87         --          no iteration at all.
88
89     returns ComputeLine;
90
91
92     Create(Parameters:   Vector from math;
93            degreemin:    Integer = 4;
94            degreemax:    Integer = 8;
95            Tolerance3d:  Real    = 1.0e-03; 
96            Tolerance2d:  Real    = 1.0e-06; 
97            NbIterations: Integer = 5;
98            cutting:      Boolean = Standard_True; 
99            Squares:      Boolean = Standard_False)
100            
101         ---Purpose: Initializes the fields of the algorithm.
102
103     returns ComputeLine;
104
105
106     Create(degreemin:    Integer = 4;
107            degreemax:    Integer = 8;
108            Tolerance3d:  Real    = 1.0e-03; 
109            Tolerance2d:  Real    = 1.0e-06; 
110            NbIterations: Integer = 5;
111            cutting:      Boolean = Standard_True; 
112            parametrization: ParametrizationType from Approx =
113            Approx_ChordLength;
114            Squares:      Boolean = Standard_False)
115            
116         ---Purpose: Initializes the fields of the algorithm.
117
118     returns ComputeLine;
119
120
121     Init(me: in out; degreemin:    Integer = 4;
122                      degreemax:    Integer = 8;
123                      Tolerance3d:  Real    = 1.0e-03; 
124                      Tolerance2d:  Real    = 1.0e-06; 
125                      NbIterations: Integer = 5;
126                      cutting:      Boolean = Standard_True; 
127                      parametrization: ParametrizationType from Approx =
128                      Approx_ChordLength;
129                      Squares:      Boolean = Standard_False)
130            
131         ---Purpose: Initializes the fields of the algorithm.
132
133     is static;
134
135
136
137
138     Perform(me: in out; Line: MultiLine)
139         ---Purpose: runs the algorithm after having initialized the fields.
140     
141     is static;
142
143
144     Compute(me: in out; Line: MultiLine; fpt, lpt: Integer;
145             Para: in out Vector from math; TheTol3d, TheTol2d: in out Real)
146         ---Purpose: is internally used in the algorithm.
147
148     returns Boolean
149     is static private;
150     
151     
152     ComputeCurve(me: in out; Line: MultiLine; firspt, lastpt: Integer) 
153         ---Purpose: is internally used in the algorithm.
154     
155     returns Boolean
156     is static private;
157     
158     
159     Parameters(me; Line: MultiLine; firstP, LastP: Integer;
160                TheParameters: in out Vector)
161         ---Purpose: computes new parameters between firstP and lastP.
162
163     is static private;
164     
165     
166     SetDegrees(me: in out; degreemin, degreemax: Integer)
167         ---Purpose: changes the degrees of the approximation.
168     
169     is static;
170     
171     
172     SetTolerances(me: in out; Tolerance3d, Tolerance2d: Real)
173         ---Purpose: Changes the tolerances of the approximation.
174     
175     is static;
176     
177
178     SetConstraints(me: in out; firstC, lastC: Constraint from AppParCurves)
179             ---Purpose: changes the first and the last constraint points.
180     is static;
181
182
183     IsAllApproximated(me) 
184         ---Purpose: returns False if at a moment of the approximation,
185         --          the status NoApproximation has been sent by the user
186         --          when more points were needed.
187     
188     returns Boolean
189     is static;
190     
191
192     IsToleranceReached(me)
193         ---Purpose: returns False if the status NoPointsAdded has been sent.
194     
195     returns Boolean
196     is static;
197     
198
199     Error(me; Index: Integer; tol3d: in out Real; tol2d: in out Real)
200         ---Purpose: returns the tolerances 2d and 3d of the <Index> MultiCurve.
201
202     is static;
203     
204
205     NbMultiCurves(me)
206         ---Purpose: Returns the number of MultiCurve doing the approximation
207         --          of the MultiLine.
208     returns Integer
209     is static;
210
211
212     Value(me; Index: Integer = 1)
213         ---Purpose: returns the result of the approximation.
214         ---C++: return const&
215     returns MultiCurve from AppParCurves
216     is static;
217
218     ChangeValue(me: in out; Index: Integer = 1)
219         ---Purpose: returns the result of the approximation.
220         ---C++: return &
221     returns MultiCurve from AppParCurves
222     is static;
223
224
225     SplineValue(me: in out)
226         ---Purpose: returns the result of the approximation.
227         ---C++: return const&
228     returns MultiBSpCurve from AppParCurves
229     is static;
230
231     Parametrization(me; partype :  in  out ParametrizationType from Approx) 
232         ---Purpose: returns the type  of  parametrization
233     is static;
234
235
236     Parameters(me; Index: Integer = 1)
237         ---Purpose: returns the new parameters of the approximation
238         --          corresponding to the points of the multicurve <Index>.
239         ---C++: return const&
240     returns Array1OfReal from TColStd
241     is static;
242  
243      
244     
245     SearchFirstLambda(me; Line: MultiLine; Para: Vector; 
246                       V: Vector; index: Integer)
247     returns Real
248     is static private;
249     
250     SearchLastLambda(me: ; Line: MultiLine; Para: Vector;
251                      V: Vector; index: Integer)
252     returns Real
253     is static private;
254     
255     FirstTangencyVector(me; Line: MultiLine; index: Integer; V: in out Vector)
256     is static private;
257     
258     LastTangencyVector(me; Line: MultiLine; index: Integer; V: in out Vector)
259     is static private;
260
261
262 fields
263
264
265 myMultiCurves: SequenceOfMultiCurve      from AppParCurves;    
266 TheMultiCurve: MultiCurve                from AppParCurves;
267 myspline     : MultiBSpCurve             from AppParCurves;
268 alldone:       Boolean                   from Standard;
269 tolreached:    Boolean                   from Standard;
270 Par:           ParametrizationType       from Approx;
271 myParameters:  HArray1OfReal             from TColStd;
272 myfirstParam:  HArray1OfReal             from TColStd;
273 myPar:         SequenceOfHArray1OfReal   from Approx;
274 Tolers3d:      SequenceOfReal            from TColStd;
275 Tolers2d:      SequenceOfReal            from TColStd;
276 myConstraints: HArray1OfConstraintCouple from AppParCurves;
277 mydegremin:    Integer                   from Standard;
278 mydegremax:    Integer                   from Standard;
279 mytol3d:       Real                      from Standard;
280 mytol2d:       Real                      from Standard;
281 currenttol3d:  Real                      from Standard;
282 currenttol2d:  Real                      from Standard;
283 mycut:         Boolean                   from Standard;
284 mysquares:     Boolean                   from Standard;
285 myitermax:     Integer                   from Standard;
286 myfirstC:      Constraint                from AppParCurves;
287 mylastC:       Constraint                from AppParCurves;
288 myMultiLineNb: Integer                   from Standard;
289 myIsClear    : Boolean                   from Standard;
290
291 end ComputeLine;