024ad877141c9f1c7970e01072ca3e9baabf0cd1
[occt.git] / src / DBRep / DBRep_IsoBuilder.cxx
1 // Created on: 1994-03-25
2 // Created by: Jean Marc LACHAUME
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 #include <DBRep_IsoBuilder.ixx>
18
19 #include <Precision.hxx>
20 #include <BRepTools.hxx>
21 #include <BRep_Tool.hxx>
22 #include <Geom2dAdaptor_Curve.hxx>
23 #include <Geom2dHatch_Intersector.hxx>
24 #include <Geom2d_Curve.hxx>
25 #include <Geom2d_Line.hxx>
26 #include <Geom2d_TrimmedCurve.hxx>
27 #include <HatchGen_Domain.hxx>
28 #include <Precision.hxx>
29 #include <TopAbs_ShapeEnum.hxx>
30 #include <TopExp_Explorer.hxx>
31 #include <TopoDS.hxx>
32 #include <TopoDS_Edge.hxx>
33 #include <gp_Dir2d.hxx>
34 #include <gp_Pnt2d.hxx>
35
36 //  Modified by Sergey KHROMOV - Thu Nov  9 12:08:37 2000
37 static Standard_Real IntersectorConfusion = 1.e-10 ; // -8 ;
38 static Standard_Real IntersectorTangency  = 1.e-10 ; // -8 ;
39 //  Modified by Sergey KHROMOV - Thu Nov  9 12:08:38 2000
40 static Standard_Real HatcherConfusion2d   = 1.e-8 ;
41 static Standard_Real HatcherConfusion3d   = 1.e-8 ;
42
43 //=======================================================================
44 // Function : DBRep_IsoBuilder
45 // Purpose  : Constructeur.
46 //=======================================================================
47
48 DBRep_IsoBuilder::DBRep_IsoBuilder (const TopoDS_Face&     TopologicalFace,
49   const Standard_Real    Infinite,
50   const Standard_Integer NbIsos) :
51 Geom2dHatch_Hatcher (Geom2dHatch_Intersector (IntersectorConfusion,
52   IntersectorTangency),
53   HatcherConfusion2d,
54   HatcherConfusion3d,
55   Standard_True,
56   Standard_False) ,
57   myInfinite (Infinite) ,
58   myUMin     (0.0) ,
59   myUMax     (0.0) ,
60   myVMin     (0.0) ,
61   myVMax     (0.0) ,
62   myUPrm     (1, NbIsos) ,
63   myUInd     (1, NbIsos) ,
64   myVPrm     (1, NbIsos) ,
65   myVInd     (1, NbIsos) ,
66   myNbDom    (0)
67 {
68   myUInd.Init(0);
69   myVInd.Init(0);
70
71   //-----------------------------------------------------------------------
72   // If the Min Max bounds are infinite, there are bounded to Infinite
73   // value.
74   //-----------------------------------------------------------------------
75
76   BRepTools::UVBounds (TopologicalFace, myUMin, myUMax, myVMin, myVMax) ;
77   Standard_Boolean InfiniteUMin = Precision::IsNegativeInfinite (myUMin) ;
78   Standard_Boolean InfiniteUMax = Precision::IsPositiveInfinite (myUMax) ;
79   Standard_Boolean InfiniteVMin = Precision::IsNegativeInfinite (myVMin) ;
80   Standard_Boolean InfiniteVMax = Precision::IsPositiveInfinite (myVMax) ;
81   if (InfiniteUMin && InfiniteUMax) {
82     myUMin = - Infinite ;
83     myUMax =   Infinite ;
84   } else if (InfiniteUMin) {
85     myUMin = myUMax - Infinite ;
86   } else if (InfiniteUMax) {
87     myUMax = myUMin + Infinite ;
88   }
89   if (InfiniteVMin && InfiniteVMax) {
90     myVMin = - Infinite ;
91     myVMax =   Infinite ;
92   } else if (InfiniteVMin) {
93     myVMin = myVMax - Infinite ;
94   } else if (InfiniteVMax) {
95     myVMax = myVMin + Infinite ;
96   }
97
98   //-----------------------------------------------------------------------
99   // Retreiving the edges and loading them into the hatcher.
100   //-----------------------------------------------------------------------
101
102   TopExp_Explorer ExpEdges;
103   for (ExpEdges.Init (TopologicalFace, TopAbs_EDGE); ExpEdges.More(); ExpEdges.Next())
104   {
105     const TopoDS_Edge& TopologicalEdge = TopoDS::Edge (ExpEdges.Current());
106     Standard_Real U1, U2;
107     const Handle(Geom2d_Curve) PCurve = BRep_Tool::CurveOnSurface (TopologicalEdge, TopologicalFace, U1, U2);
108
109     if (PCurve.IsNull())
110     {
111 #ifdef OCCT_DEBUG
112       cout << "DBRep_IsoBuilder : PCurve is null\n";
113 #endif
114       return;
115     }
116     else if (U1 == U2)
117     {
118 #ifdef OCCT_DEBUG
119       cout << "DBRep_IsoBuilder PCurve : U1==U2\n";
120 #endif
121       return;
122     }
123
124     //-- Test if a TrimmedCurve is necessary
125     if (Abs(PCurve->FirstParameter()-U1)<= Precision::PConfusion()
126       && Abs(PCurve->LastParameter()-U2)<= Precision::PConfusion())
127     {
128       AddElement (PCurve, TopologicalEdge.Orientation());
129     }
130     else
131     {
132       if (!PCurve->IsPeriodic())
133       {
134         Handle (Geom2d_TrimmedCurve) TrimPCurve = Handle(Geom2d_TrimmedCurve)::DownCast (PCurve);
135         if (!TrimPCurve.IsNull())
136         {
137           if (TrimPCurve->BasisCurve()->FirstParameter() - U1 > Precision::PConfusion() ||
138             TrimPCurve->BasisCurve()->FirstParameter() - U2 > Precision::PConfusion() ||
139             U1 - TrimPCurve->BasisCurve()->LastParameter()  > Precision::PConfusion() ||
140             U2 - TrimPCurve->BasisCurve()->LastParameter()  > Precision::PConfusion())
141           {
142             AddElement (PCurve, TopologicalEdge.Orientation());
143 #ifdef OCCT_DEBUG
144             cout << "DBRep_IsoBuilder TrimPCurve : parameters out of range\n";
145             cout << "    U1(" << U1 << "), Umin(" << PCurve->FirstParameter()
146               << "), U2("  << U2 << "), Umax(" << PCurve->LastParameter() << ")\n";
147 #endif
148             return;
149           }
150         }
151         else
152         {
153           if (PCurve->FirstParameter() - U1 > Precision::PConfusion())
154           {
155 #ifdef OCCT_DEBUG
156             cout << "DBRep_IsoBuilder PCurve : parameters out of range\n";
157             cout << "    U1(" << U1 << "), Umin(" << PCurve->FirstParameter() << ")\n";
158 #endif
159             U1 = PCurve->FirstParameter();
160           }
161           if (PCurve->FirstParameter() - U2 > Precision::PConfusion())
162           {
163 #ifdef OCCT_DEBUG
164             cout << "DBRep_IsoBuilder PCurve : parameters out of range\n";
165             cout << "    U2(" << U2 << "), Umin(" << PCurve->FirstParameter() << ")\n";
166 #endif
167             U2 = PCurve->FirstParameter();
168           }
169           if (U1 - PCurve->LastParameter() > Precision::PConfusion())
170           {
171 #ifdef OCCT_DEBUG
172             cout << "DBRep_IsoBuilder PCurve : parameters out of range\n";
173             cout << "    U1(" << U1 << "), Umax(" << PCurve->LastParameter() << ")\n";
174 #endif
175             U1 = PCurve->LastParameter();
176           }
177           if (U2 - PCurve->LastParameter() > Precision::PConfusion())
178           {
179 #ifdef OCCT_DEBUG
180             cout << "DBRep_IsoBuilder PCurve : parameters out of range\n";
181             cout << "    U2(" << U2 << "), Umax(" << PCurve->LastParameter() << ")\n";
182 #endif
183             U2 = PCurve->LastParameter();
184           }
185         }
186       }
187
188       // if U1 and U2 coincide-->do nothing
189       if (Abs (U1 - U2) <= Precision::PConfusion()) continue;
190       Handle (Geom2d_TrimmedCurve) TrimPCurve = new Geom2d_TrimmedCurve (PCurve, U1, U2);
191       AddElement (TrimPCurve, TopologicalEdge.Orientation());
192     }
193   }
194
195   //-----------------------------------------------------------------------
196   // Loading and trimming the hatchings.
197   //-----------------------------------------------------------------------
198
199   Standard_Integer IIso ;
200   Standard_Real DeltaU = Abs (myUMax - myUMin) ;
201   Standard_Real DeltaV = Abs (myVMax - myVMin) ;
202   Standard_Real confusion = Min (DeltaU, DeltaV) * HatcherConfusion3d ;
203   Confusion3d (confusion) ;
204
205   Standard_Real StepU = DeltaU / (Standard_Real) NbIsos ;
206   if (StepU > confusion) {
207     Standard_Real UPrm = myUMin + StepU / 2. ;
208     gp_Dir2d Dir (0., 1.) ;
209     for (IIso = 1 ; IIso <= NbIsos ; IIso++) {
210       myUPrm(IIso) = UPrm ;
211       gp_Pnt2d Ori (UPrm, 0.) ;
212       Geom2dAdaptor_Curve HCur (new Geom2d_Line (Ori, Dir)) ;
213       myUInd(IIso) = AddHatching (HCur) ;
214       UPrm += StepU ;
215     }
216   }
217
218   Standard_Real StepV = DeltaV / (Standard_Real) NbIsos ;
219   if (StepV > confusion) {
220     Standard_Real VPrm = myVMin + StepV / 2. ;
221     gp_Dir2d Dir (1., 0.) ;
222     for (IIso = 1 ; IIso <= NbIsos ; IIso++) {
223       myVPrm(IIso) = VPrm ;
224       gp_Pnt2d Ori (0., VPrm) ;
225       Geom2dAdaptor_Curve HCur (new Geom2d_Line (Ori, Dir)) ;
226       myVInd(IIso) = AddHatching (HCur) ;
227       VPrm += StepV ;
228     }
229   }
230
231   //-----------------------------------------------------------------------
232   // Computation.
233   //-----------------------------------------------------------------------
234
235   Trim() ;
236
237   myNbDom = 0 ;
238   for (IIso = 1 ; IIso <= NbIsos ; IIso++)
239   {
240     Standard_Integer Index ;
241
242     Index = myUInd(IIso) ;
243     if (Index != 0)
244     {
245       if (TrimDone (Index) && !TrimFailed (Index))
246       {
247         ComputeDomains (Index);
248         if (IsDone (Index))
249           myNbDom = myNbDom + Geom2dHatch_Hatcher::NbDomains (Index) ;
250       }
251     }
252
253     Index = myVInd(IIso) ;
254     if (Index != 0)
255     {
256       if (TrimDone (Index) && !TrimFailed (Index))
257       {
258         ComputeDomains (Index);
259         if (IsDone (Index))
260           myNbDom = myNbDom + Geom2dHatch_Hatcher::NbDomains (Index) ;
261       }
262     }
263   }
264 }
265
266 //=======================================================================
267 // Function : LoadIsos
268 // Purpose  : Loading of the isoparametric curves in the Data Structure
269 //            of a drawable face.
270 //=======================================================================
271
272 void DBRep_IsoBuilder::LoadIsos (const Handle(DBRep_Face)& Face) const
273 {
274   Standard_Integer NumIso = 0 ;
275
276   for (Standard_Integer UIso = myUPrm.Lower() ; UIso <= myUPrm.Upper() ; UIso++) {
277     Standard_Integer UInd = myUInd.Value (UIso) ;
278     if (UInd != 0) {
279       Standard_Real UPrm = myUPrm.Value (UIso) ;
280       if (!IsDone (UInd)) {
281         cout << "DBRep_IsoBuilder:: U iso of parameter: " << UPrm ;
282         switch (Status (UInd)) {
283           case HatchGen_NoProblem          : cout << " No Problem"          << endl ; break ;
284           case HatchGen_TrimFailure        : cout << " Trim Failure"        << endl ; break ;
285           case HatchGen_TransitionFailure  : cout << " Transition Failure"  << endl ; break ;
286           case HatchGen_IncoherentParity   : cout << " Incoherent Parity"   << endl ; break ;
287           case HatchGen_IncompatibleStates : cout << " Incompatible States" << endl ; break ;
288         }
289       } else {
290         Standard_Integer NbDom = Geom2dHatch_Hatcher::NbDomains (UInd) ;
291         for (Standard_Integer IDom = 1 ; IDom <= NbDom ; IDom++) {
292           const HatchGen_Domain& Dom = Domain (UInd, IDom) ;
293           Standard_Real V1 = Dom.HasFirstPoint()  ? Dom.FirstPoint().Parameter()  : myVMin - myInfinite ;
294           Standard_Real V2 = Dom.HasSecondPoint() ? Dom.SecondPoint().Parameter() : myVMax + myInfinite ;
295           NumIso++ ;
296           Face->Iso (NumIso, GeomAbs_IsoU, UPrm, V1, V2) ;
297         }
298       }
299     }
300   }
301
302   for (Standard_Integer VIso = myVPrm.Lower() ; VIso <= myVPrm.Upper() ; VIso++) {
303     Standard_Integer VInd = myVInd.Value (VIso) ;
304     if (VInd != 0) {
305       Standard_Real VPrm = myVPrm.Value (VIso) ;
306       if (!IsDone (VInd)) {
307         cout << "DBRep_IsoBuilder:: V iso of parameter: " << VPrm ;
308         switch (Status (VInd)) {
309           case HatchGen_NoProblem          : cout << " No Problem"          << endl ; break ;
310           case HatchGen_TrimFailure        : cout << " Trim Failure"        << endl ; break ;
311           case HatchGen_TransitionFailure  : cout << " Transition Failure"  << endl ; break ;
312           case HatchGen_IncoherentParity   : cout << " Incoherent Parity"   << endl ; break ;
313           case HatchGen_IncompatibleStates : cout << " Incompatible States" << endl ; break ;
314         }
315       } else {
316         Standard_Integer NbDom = Geom2dHatch_Hatcher::NbDomains (VInd) ;
317         for (Standard_Integer IDom = 1 ; IDom <= NbDom ; IDom++) {
318           const HatchGen_Domain& Dom = Domain (VInd, IDom) ;
319           Standard_Real U1 = Dom.HasFirstPoint()  ? Dom.FirstPoint().Parameter()  : myVMin - myInfinite ;
320           Standard_Real U2 = Dom.HasSecondPoint() ? Dom.SecondPoint().Parameter() : myVMax + myInfinite ;
321           NumIso++ ;
322           Face->Iso (NumIso, GeomAbs_IsoV, VPrm, U1, U2) ;
323         }
324       }
325     }
326   }
327 }