0026937: Eliminate NO_CXX_EXCEPTION macro support
[occt.git] / src / LocOpe / LocOpe_CurveShapeIntersector.cxx
1 // Created on: 1995-05-29
2 // Created by: Jacques GOUSSARD
3 // Copyright (c) 1995-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17
18 #include <BRepIntCurveSurface_Inter.hxx>
19 #include <Geom_Circle.hxx>
20 #include <GeomAdaptor_Curve.hxx>
21 #include <gp_Ax1.hxx>
22 #include <gp_Circ.hxx>
23 #include <gp_Lin.hxx>
24 #include <LocOpe_CurveShapeIntersector.hxx>
25 #include <LocOpe_PntFace.hxx>
26 #include <Precision.hxx>
27 #include <Standard_OutOfRange.hxx>
28 #include <StdFail_NotDone.hxx>
29 #include <TopoDS_Shape.hxx>
30
31 static void Perform(BRepIntCurveSurface_Inter&,
32                     LocOpe_SequenceOfPntFace&);
33
34
35 //=======================================================================
36 //function : Init
37 //purpose  : 
38 //=======================================================================
39
40 void LocOpe_CurveShapeIntersector::Init(const gp_Ax1& Axis,
41                                         const TopoDS_Shape& S)
42 {
43   myDone = Standard_False;
44   myPoints.Clear();
45   if (S.IsNull()) {
46     return ;
47   }
48   Standard_Real Tol = Precision::Confusion();
49
50   BRepIntCurveSurface_Inter theInt;
51   theInt.Init(S,gp_Lin(Axis),Tol);
52   Perform(theInt,myPoints);
53   myDone = Standard_True;
54 }
55     
56
57 //=======================================================================
58 //function : Init
59 //purpose  : 
60 //=======================================================================
61
62 void LocOpe_CurveShapeIntersector::Init(const gp_Circ& C,
63                                         const TopoDS_Shape& S)
64 {
65   myDone = Standard_False;
66   myPoints.Clear();
67   if (S.IsNull()) {
68     return ;
69   }
70   Standard_Real Tol = Precision::Confusion();
71
72   Handle(Geom_Circle) GC = new Geom_Circle(C);
73   GeomAdaptor_Curve AC(GC,0.,2.*M_PI);
74
75   BRepIntCurveSurface_Inter theInt;
76   theInt.Init(S,AC,Tol);
77
78   Perform(theInt,myPoints);
79   myDone = Standard_True;
80 }
81     
82
83 //=======================================================================
84 //function : LocalizeAfter
85 //purpose  : 
86 //=======================================================================
87
88 Standard_Boolean LocOpe_CurveShapeIntersector::LocalizeAfter
89    (const Standard_Real From,
90     TopAbs_Orientation& Or,
91     Standard_Integer& IndFrom,
92     Standard_Integer& IndTo) const
93 {
94   if (!myDone) {
95     throw StdFail_NotDone();
96   }
97   Standard_Real Eps = Precision::Confusion();
98   Standard_Real param,FMEPS = From - Eps;
99   Standard_Integer i,ifirst,nbpoints = myPoints.Length();
100   for (ifirst=1; ifirst<=nbpoints; ifirst++) {
101     if (myPoints(ifirst).Parameter() >= FMEPS) {
102       break;
103     }
104   }
105   Standard_Boolean RetVal = Standard_False;
106   if (ifirst <= nbpoints) {
107     i = ifirst;
108     IndFrom = ifirst;
109     Standard_Boolean found = Standard_False;
110     while (!found) {
111       Or = myPoints(i).Orientation();
112       param = myPoints(i).Parameter();
113       i = i+1;
114       while (i<=nbpoints) {
115         if (myPoints(i).Parameter()-param <= Eps) {
116           if (Or != TopAbs_EXTERNAL && Or != myPoints(i).Orientation()) {
117             Or = TopAbs_EXTERNAL;
118           }
119           i++;
120         }
121         else {
122           break;
123         }
124       }
125       if (Or == TopAbs_EXTERNAL) {
126         found = (i > nbpoints);
127         IndFrom = i;
128       }
129       else { // on a une intersection franche
130         IndTo = i-1;
131         found = Standard_True;
132         RetVal = Standard_True;
133       }
134     }
135   }
136
137   return RetVal;
138 }
139
140 //=======================================================================
141 //function : LocalizeBefore
142 //purpose  : 
143 //=======================================================================
144
145 Standard_Boolean LocOpe_CurveShapeIntersector::LocalizeBefore
146    (const Standard_Real From,
147      TopAbs_Orientation& Or,
148     Standard_Integer& IndFrom,
149     Standard_Integer& IndTo) const
150 {
151   if (!myDone) {
152     throw StdFail_NotDone();
153   }
154   Standard_Real Eps = Precision::Confusion();
155   Standard_Real param,FPEPS = From + Eps;
156   Standard_Integer i,ifirst,nbpoints = myPoints.Length();
157   for (ifirst=nbpoints; ifirst>=1; ifirst--) {
158     if (myPoints(ifirst).Parameter() <= FPEPS) {
159       break;
160     }
161   }
162   Standard_Boolean RetVal = Standard_False;
163   if (ifirst >= 1) {
164     i = ifirst;
165     IndTo = ifirst;
166     Standard_Boolean found = Standard_False;
167     while (!found) {
168       Or = myPoints(i).Orientation();
169       param = myPoints(i).Parameter();
170       i = i-1;
171       while (i>=1) {
172         if (param - myPoints(i).Parameter() <= Eps) {
173           if (Or != TopAbs_EXTERNAL && Or != myPoints(i).Orientation()) {
174             Or = TopAbs_EXTERNAL;
175           }
176           i--;
177         }
178         else {
179           break;
180         }
181       }
182       if (Or == TopAbs_EXTERNAL) {
183         found = (i < 1);
184         IndTo = i;
185       }
186       else { // on a une intersection franche
187         IndFrom = i+1;
188         found = Standard_True;
189         RetVal = Standard_True;
190       }
191     }
192   }
193
194   return RetVal;
195 }
196
197 //=======================================================================
198 //function : LocalizeAfter
199 //purpose  : 
200 //=======================================================================
201
202 Standard_Boolean LocOpe_CurveShapeIntersector::LocalizeAfter
203    (const Standard_Integer FromInd,
204     TopAbs_Orientation& Or,
205     Standard_Integer& IndFrom,
206     Standard_Integer& IndTo) const
207 {
208   if (!myDone) {
209     throw StdFail_NotDone();
210   }
211   Standard_Integer nbpoints = myPoints.Length();
212   if (FromInd >= nbpoints) {
213     return Standard_False;
214   }
215  
216   Standard_Real Eps = Precision::Confusion();
217   Standard_Real param,FMEPS;
218   Standard_Integer i,ifirst;
219   if (FromInd >= 1) {
220     FMEPS = myPoints(FromInd).Parameter() - Eps;
221     for (ifirst=FromInd+1; ifirst<=nbpoints; ifirst++) {
222       if (myPoints(ifirst).Parameter() >= FMEPS) {
223         break;
224       }
225     }
226   }
227   else {
228     ifirst = 1;
229   }
230
231   Standard_Boolean RetVal = Standard_False;
232   if (ifirst <= nbpoints) {
233     i = ifirst;
234     IndFrom = ifirst;
235     Standard_Boolean found = Standard_False;
236     while (!found) {
237       Or = myPoints(i).Orientation();
238       param = myPoints(i).Parameter();
239       i = i+1;
240       while (i<=nbpoints) {
241         if (myPoints(i).Parameter()-param <= Eps) {
242           if (Or != TopAbs_EXTERNAL && Or != myPoints(i).Orientation()) {
243             Or = TopAbs_EXTERNAL;
244           }
245           i++;
246         }
247         else {
248           break;
249         }
250       }
251       if (Or == TopAbs_EXTERNAL) {
252         found = (i > nbpoints);
253         IndFrom = i;
254       }
255       else { // on a une intersection franche
256         IndTo = i-1;
257         found = Standard_True;
258         RetVal = Standard_True;
259       }
260     }
261   }
262   return RetVal;
263 }
264
265
266 //=======================================================================
267 //function : LocalizeBefore
268 //purpose  : 
269 //=======================================================================
270
271 Standard_Boolean LocOpe_CurveShapeIntersector::LocalizeBefore
272    (const Standard_Integer FromInd,
273      TopAbs_Orientation& Or,
274     Standard_Integer& IndFrom,
275     Standard_Integer& IndTo) const
276 {
277   if (!myDone) {
278     throw StdFail_NotDone();
279   }
280   Standard_Integer nbpoints = myPoints.Length();
281   if (FromInd <= 1) {
282     return Standard_False;
283   }
284  
285   Standard_Real Eps = Precision::Confusion();
286   Standard_Real param,FPEPS;
287   Standard_Integer i,ifirst;
288   if (FromInd <= nbpoints) {
289     FPEPS = myPoints(FromInd).Parameter() + Eps;
290     for (ifirst=FromInd-1; ifirst>=1; ifirst--) {
291       if (myPoints(ifirst).Parameter() <= FPEPS) {
292         break;
293       }
294     }
295   }
296   else {
297     ifirst = nbpoints;
298   }
299
300   Standard_Boolean RetVal = Standard_False;
301   if (ifirst >= 1) {
302     i = ifirst;
303     IndTo = ifirst;
304     Standard_Boolean found = Standard_False;
305     while (!found) {
306       Or = myPoints(i).Orientation();
307       param = myPoints(i).Parameter();
308       i = i-1;
309       while (i>=1) {
310         if (param - myPoints(i).Parameter() <= Eps) {
311           if (Or != TopAbs_EXTERNAL && Or != myPoints(i).Orientation()) {
312             Or = TopAbs_EXTERNAL;
313           }
314           i--;
315         }
316         else {
317           break;
318         }
319       }
320       if (Or == TopAbs_EXTERNAL) {
321         found = (i < 1);
322         IndTo = i;
323       }
324       else { // on a une intersection franche
325         IndFrom = i+1;
326         found = Standard_True;
327         RetVal = Standard_True;
328       }
329     }
330   }
331   return RetVal;
332 }
333
334
335 //=======================================================================
336 //function : Perform
337 //purpose  : 
338 //=======================================================================
339
340 static void Perform(BRepIntCurveSurface_Inter & theInt,
341                     LocOpe_SequenceOfPntFace& thePoints)
342 {
343   Standard_Real param,paramu,paramv;
344   Standard_Integer i, nbpoints=0;
345
346   TopAbs_Orientation theor=TopAbs_FORWARD, orface;
347
348   while (theInt.More()) {
349     const gp_Pnt& thept = theInt.Pnt();
350     const TopoDS_Face& theface = theInt.Face();
351     orface = theface.Orientation();
352     param = theInt.W();
353     paramu = theInt.U();
354     paramv = theInt.V();
355
356     switch (theInt.Transition()) {
357     case IntCurveSurface_In:
358       if ( orface == TopAbs_FORWARD) {
359         theor = TopAbs_FORWARD;
360       }
361       else if (orface == TopAbs_REVERSED) {
362         theor = TopAbs_REVERSED;
363       }
364       else {
365         theor = TopAbs_EXTERNAL;
366       }
367       break;
368     case IntCurveSurface_Out:
369       if ( orface == TopAbs_FORWARD) {
370         theor = TopAbs_REVERSED;
371       }
372       else if (orface == TopAbs_REVERSED) {
373         theor = TopAbs_FORWARD;
374       }
375       else {
376         theor = TopAbs_EXTERNAL;
377       }
378       break;
379     case IntCurveSurface_Tangent:
380       theor = TopAbs_EXTERNAL;
381       break;
382
383     }
384
385     LocOpe_PntFace newpt(thept,theface,theor,param,paramu,paramv);
386
387     for (i=1; i <= nbpoints; i++) {
388       if (thePoints(i).Parameter() - param > 0.) {
389         break;
390       }
391     }
392     if (i <= nbpoints) {
393       thePoints.InsertBefore(i,newpt);
394     }
395     else {
396       thePoints.Append(newpt);
397     }
398     nbpoints++;
399     theInt.Next();
400   }
401 }