0030878: Modeling Algorithms - BRepLib_MakeFace produces face with abnormal surface
[occt.git] / src / Geom2dHatch / Geom2dHatch_Elements.cxx
1 // Created on: 1994-12-16
2 // Created by: Laurent BUCHARD
3 // Copyright (c) 1994-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 //  Modified by skv - Fri Jul 14 17:03:47 2006 OCC12627
18
19 #include <Geom2dAdaptor_Curve.hxx>
20 #include <Geom2dHatch_Element.hxx>
21 #include <Geom2dHatch_Elements.hxx>
22 #include <gp.hxx>
23 #include <gp_Lin2d.hxx>
24 #include <gp_Pnt2d.hxx>
25 #include <gp_Vec2d.hxx>
26 #include <Standard_DomainError.hxx>
27 #include <Standard_Integer.hxx>
28 #include <Standard_NoSuchObject.hxx>
29 #include <TColStd_MapIntegerHasher.hxx>
30 #include <TopAbs_Orientation.hxx>
31 #include <Precision.hxx>
32
33 static const Standard_Real Probing_Start = 0.123;
34 static const Standard_Real Probing_End = 0.8;
35 static const Standard_Real Probing_Step = 0.2111;
36
37 Geom2dHatch_Elements::Geom2dHatch_Elements(const Geom2dHatch_Elements& )
38 {
39 #ifdef OCCT_DEBUG
40   std::cout<<" Magic Constructor in Geom2dHatch_Elements:: "<<std::endl;
41 #endif
42 }
43
44 Geom2dHatch_Elements::Geom2dHatch_Elements()
45 {
46   NumWire = 0;
47   NumEdge = 0;
48   myCurEdge = 1;
49   myCurEdgePar = Probing_Start;
50 }
51
52 void Geom2dHatch_Elements::Clear()
53 {
54   myMap.Clear();
55 }
56
57 Standard_Boolean Geom2dHatch_Elements::IsBound(const Standard_Integer K) const
58 {
59   return(myMap.IsBound(K));
60 }
61
62 Standard_Boolean Geom2dHatch_Elements::UnBind(const Standard_Integer K)
63 {
64   return(myMap.UnBind(K));
65 }
66
67 Standard_Boolean Geom2dHatch_Elements::Bind(const Standard_Integer K,const Geom2dHatch_Element& I)
68 {
69   return(myMap.Bind(K,I));
70 }
71
72 const Geom2dHatch_Element& Geom2dHatch_Elements::Find(const Standard_Integer K) const
73 {
74   return(myMap.Find(K));
75 }
76
77 Geom2dHatch_Element& Geom2dHatch_Elements::ChangeFind(const Standard_Integer K)
78 {
79   return(myMap.ChangeFind(K));
80 }
81
82 //=======================================================================
83 //function : CheckPoint
84 //purpose  : 
85 //=======================================================================
86
87 Standard_Boolean  Geom2dHatch_Elements::CheckPoint(gp_Pnt2d&)
88 {
89   return Standard_True;
90 }
91
92 //=======================================================================
93 //function : Reject
94 //purpose  : 
95 //=======================================================================
96
97 Standard_Boolean  Geom2dHatch_Elements::Reject(const gp_Pnt2d&) const  {
98   return Standard_False;
99 }
100
101 //=======================================================================
102 //function : Segment
103 //purpose  : 
104 //=======================================================================
105
106 Standard_Boolean Geom2dHatch_Elements::Segment(const gp_Pnt2d& P, 
107                                                      gp_Lin2d& L, 
108                                                      Standard_Real& Par)
109 {
110   myCurEdge = 1;
111   myCurEdgePar = Probing_Start;
112   return OtherSegment(P, L, Par);
113 }
114
115 //=======================================================================
116 //function : Segment
117 //purpose  : 
118 //=======================================================================
119
120 Standard_Boolean Geom2dHatch_Elements::OtherSegment (const gp_Pnt2d& P, 
121                                                      gp_Lin2d& L, 
122                                                      Standard_Real& Par)
123 {
124   Geom2dHatch_DataMapIteratorOfMapOfElements Itertemp;
125   Standard_Integer                        i;
126   
127   for (Itertemp.Initialize (myMap), i = 1; Itertemp.More(); Itertemp.Next(), i++)
128   {
129     if (i < myCurEdge)
130       continue;
131
132     void *ptrmyMap = (void *)(&myMap);
133     Geom2dHatch_Element& Item = ((Geom2dHatch_MapOfElements*)ptrmyMap)->ChangeFind (Itertemp.Key());
134     Geom2dAdaptor_Curve& E = Item.ChangeCurve();
135     TopAbs_Orientation Or = Item.Orientation();
136     if (Or == TopAbs_FORWARD || Or == TopAbs_REVERSED)
137     {
138       Standard_Real aFPar = E.FirstParameter(), aLPar = E.LastParameter();
139       if (Precision::IsNegativeInfinite (aFPar))
140       {
141         if (Precision::IsPositiveInfinite (aLPar))
142         {
143           aFPar = -1.;
144           aLPar = 1.;
145         }
146         else
147           aFPar = aLPar - 1.;
148       }
149       else if (Precision::IsPositiveInfinite (aLPar))
150         aLPar = aFPar + 1.;
151
152       for (; myCurEdgePar < Probing_End; myCurEdgePar += Probing_Step)
153       {
154         Standard_Real aParam = myCurEdgePar * aFPar + (1. - myCurEdgePar) * aLPar;
155         gp_Vec2d aTanVec;
156         gp_Pnt2d aPOnC;
157         E.D1 (aParam, aPOnC, aTanVec);
158         gp_Vec2d aLinVec (P, aPOnC);
159         Par = aLinVec.SquareMagnitude();
160         if (Par > Precision::SquarePConfusion())
161         {
162           gp_Dir2d aLinDir (aLinVec);
163           Standard_Real aTanMod = aTanVec.SquareMagnitude();
164           if (aTanMod < Precision::SquarePConfusion())
165             continue;
166
167           aTanVec /= Sqrt (aTanMod);
168           Standard_Real aSinA = aTanVec.Crossed (aLinDir);
169           if (Abs (aSinA) < 0.001)
170           {
171             // too small angle - line and edge may be considered
172             // as tangent which is bad for classifier
173             if (myCurEdgePar + Probing_Step < Probing_End)
174               continue;
175           }
176
177           L = gp_Lin2d (P, aLinDir);
178
179           aPOnC = E.Value (aFPar);
180           if (L.SquareDistance (aPOnC) > Precision::SquarePConfusion())
181           {
182             aPOnC = E.Value (aLPar);
183             if (L.SquareDistance (aPOnC) > Precision::SquarePConfusion())
184             {
185               myCurEdgePar += Probing_Step;
186               if (myCurEdgePar >= Probing_End)
187               {
188                 myCurEdge++;
189                 myCurEdgePar = Probing_Start;
190               }
191               Par = Sqrt (Par);
192               return Standard_True;
193             }
194           }
195         }
196       }
197     }
198     myCurEdge++;
199     myCurEdgePar = Probing_Start;
200   }
201
202   Par = RealLast();
203   L = gp_Lin2d (P, gp_Dir2d (1, 0));
204
205   return Standard_False;
206 }
207
208 //=======================================================================
209 //function : InitWires
210 //purpose  : 
211 //=======================================================================
212
213 void  Geom2dHatch_Elements::InitWires()  {
214   NumWire = 0;
215 }
216
217 //=======================================================================
218 //function : RejectWire NYI
219 //purpose  : 
220 //=======================================================================
221
222 Standard_Boolean Geom2dHatch_Elements::RejectWire(const gp_Lin2d& , 
223                                                    const Standard_Real) const 
224 {
225   return Standard_False;
226 }
227
228 //=======================================================================
229 //function : InitEdges
230 //purpose  : 
231 //=======================================================================
232
233 void  Geom2dHatch_Elements::InitEdges()  {
234   NumEdge = 0;
235   Iter.Initialize(myMap);
236 }
237
238 //=======================================================================
239 //function : RejectEdge NYI
240 //purpose  : 
241 //=======================================================================
242
243 Standard_Boolean Geom2dHatch_Elements::RejectEdge(const gp_Lin2d& , 
244                                                   const Standard_Real ) const 
245 {
246   return Standard_False;
247 }
248
249
250 //=======================================================================
251 //function : CurrentEdge
252 //purpose  : 
253 //=======================================================================
254
255 void  Geom2dHatch_Elements::CurrentEdge(Geom2dAdaptor_Curve& E, 
256                                         TopAbs_Orientation& Or) const 
257 {
258   void *ptrmyMap = (void *)(&myMap);
259   Geom2dHatch_Element& Item=((Geom2dHatch_MapOfElements*)ptrmyMap)->ChangeFind(Iter.Key());
260
261   E = Item.ChangeCurve();
262   Or= Item.Orientation();
263 #if 0 
264   E.Edge() = TopoDS::Edge(myEExplorer.Current());
265   E.Face() = myFace;
266   Or = E.Edge().Orientation();
267 #endif
268 }
269
270
271 //=======================================================================
272 //function : MoreWires
273 //purpose  : 
274 //=======================================================================
275
276 Standard_Boolean  Geom2dHatch_Elements::MoreWires() const 
277 {
278   return (NumWire == 0);
279 }
280
281 //=======================================================================
282 //function : NextWire
283 //purpose  : 
284 //=======================================================================
285
286 void Geom2dHatch_Elements::NextWire()  {
287   NumWire++;
288 }
289
290 //=======================================================================
291 //function : MoreEdges
292 //purpose  : 
293 //=======================================================================
294
295 Standard_Boolean  Geom2dHatch_Elements::MoreEdges() const  {
296   return(Iter.More());
297 }
298
299 //=======================================================================
300 //function : NextEdge
301 //purpose  : 
302 //=======================================================================
303
304 void Geom2dHatch_Elements::NextEdge()  {
305   Iter.Next();
306 }
307
308
309