332be97de3d575f72c9877574176f45f06e967d4
[occt.git] / src / BRepMesh / BRepMesh_NURBSRangeSplitter.cxx
1 // Created on: 2016-04-19
2 // Copyright (c) 2016 OPEN CASCADE SAS
3 // Created by: Oleg AGASHIN
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <BRepMesh_NURBSRangeSplitter.hxx>
17
18 #include <algorithm>
19 #include <BRepMesh_GeomTool.hxx>
20 #include <GeomAdaptor_Curve.hxx>
21 #include <GeomLib.hxx>
22 #include <IMeshData_Edge.hxx>
23 #include <IMeshData_Wire.hxx>
24 #include <NCollection_Handle.hxx>
25
26 namespace
27 {
28   class AnalyticalFilter
29   {
30   public:
31     //! Constructor.
32     AnalyticalFilter(
33       const IMeshData::IFaceHandle&             theDFace,
34       const GeomAbs_IsoType                     theIsoType,
35       const Handle(IMeshData::SequenceOfReal)&  theParams,
36       const Handle(IMeshData::SequenceOfReal)&  theControlParams,
37       const Handle(IMeshData::MapOfReal)&       theParamsForbiddenToRemove,
38       const Handle(IMeshData::MapOfReal)&       theControlParamsForbiddenToRemove)
39       : myDFace(theDFace),
40         mySurface(myDFace->GetSurface()->ChangeSurface().Surface().Surface()),
41         myIsoU(theIsoType == GeomAbs_IsoU),
42         myParams(theParams),
43         myControlParams(theControlParams),
44         myParamsForbiddenToRemove(theParamsForbiddenToRemove),
45         myControlParamsForbiddenToRemove(theControlParamsForbiddenToRemove),
46         myAllocator(new NCollection_IncAllocator(IMeshData::MEMORY_BLOCK_SIZE_HUGE)),
47         myControlParamsToRemove(new IMeshData::MapOfReal(1, myAllocator))
48     {
49     }
50
51     //! Returns map of parameters supposed to be removed.
52     const Handle(IMeshData::MapOfReal)& GetControlParametersToRemove(
53       const IMeshTools_Parameters& theParameters)
54     {
55       myParameters = theParameters;
56
57       Standard_Integer aStartIndex, aEndIndex;
58       if (myIsoU)
59       {
60         aStartIndex = 1;
61         aEndIndex = myParams->Length();
62       }
63       else
64       {
65         aStartIndex = 2;
66         aEndIndex = myParams->Length() - 1;
67       }
68
69       for (Standard_Integer i = aStartIndex; i <= aEndIndex; ++i)
70       {
71         myCurrParam = myParams->Value(i);
72         myIso = new GeomAdaptor_Curve(myIsoU ? mySurface->UIso(myCurrParam) : mySurface->VIso(myCurrParam));
73
74         myPrevControlParam = myControlParams->Value(1);
75         myIso->D1(myPrevControlParam, myPrevControlPnt, myPrevControlVec);
76         for (Standard_Integer j = 2; j <= myControlParams->Length();)
77         {
78           j += checkControlPointAndMoveOn(j);
79         }
80       }
81
82       return myControlParamsToRemove;
83     }
84
85   private:
86
87     //! Checks the given control point for deviation.
88     //! Returns number of steps to be used to move point iterator.
89     Standard_Integer checkControlPointAndMoveOn(const Standard_Integer theIndex)
90     {
91       Standard_Integer aMoveSteps = 0;
92       myCurrControlParam = myControlParams->Value(theIndex);
93       myIso->D1(myCurrControlParam, myCurrControlPnt, myCurrControlVec);
94
95       const Standard_Real aMidParam = 0.5 * (myPrevControlParam + myCurrControlParam);
96       const gp_Pnt aMidPnt = myIso->Value(aMidParam);
97
98       const Standard_Real aSqDist = BRepMesh_GeomTool::SquareDeflectionOfSegment(
99         myPrevControlPnt, myCurrControlPnt, aMidPnt);
100
101       Standard_Real anAngle = 0.0;
102       
103       if ((myPrevControlVec.SquareMagnitude() > Precision::SquareConfusion()) &&
104           (myCurrControlVec.SquareMagnitude() > Precision::SquareConfusion()))
105       {
106         anAngle = myPrevControlVec.Angle(myCurrControlVec);
107       }
108
109       const Standard_Real aSqMaxDeflection = myDFace->GetDeflection() *
110         myDFace->GetDeflection();
111
112       if (((aSqDist > aSqMaxDeflection) || (anAngle > myParameters.AngleInterior)) &&
113           aSqDist > myParameters.MinSize * myParameters.MinSize)
114       {
115         // insertion 
116         myControlParams->InsertBefore(theIndex, aMidParam);
117       }
118       else
119       {
120         // Here we should leave at least 3 parameters as far as
121         // we must have at least one parameter related to surface
122         // internals in order to prevent movement of triangle body
123         // outside the surface in case of highly curved ones, e.g.
124         // BSpline springs.
125         if (((aSqDist < aSqMaxDeflection) || (anAngle < myParameters.AngleInterior)) &&
126             myControlParams->Length() > 3 && theIndex < myControlParams->Length())
127         {
128           // Remove too dense points
129           const Standard_Real aTmpParam = myControlParams->Value(theIndex + 1);
130           if (checkParameterForDeflectionAndUpdateCache(aTmpParam))
131           {
132             ++aMoveSteps;
133           }
134         }
135
136         myPrevControlParam = myCurrControlParam;
137         myPrevControlPnt   = myCurrControlPnt;
138         myPrevControlVec   = myCurrControlVec;
139
140         ++aMoveSteps;
141       }
142
143       return aMoveSteps;
144     }
145
146     //! Checks whether the given param suits specified deflection. Updates cache.
147     Standard_Boolean checkParameterForDeflectionAndUpdateCache(const Standard_Real theParam)
148     {
149       gp_Pnt aTmpPnt;
150       gp_Vec aTmpVec;
151       myIso->D1(theParam, aTmpPnt, aTmpVec);
152
153       const Standard_Real aTmpMidParam = 0.5 * (myPrevControlParam + theParam);
154       const gp_Pnt        aTmpMidPnt = myIso->Value(aTmpMidParam);
155
156       // Lets check next parameter.
157       // If it also fits deflection, we can remove previous parameter.
158       const Standard_Real aSqDist = BRepMesh_GeomTool::SquareDeflectionOfSegment(
159         myPrevControlPnt, aTmpPnt, aTmpMidPnt);
160
161       if (aSqDist < myDFace->GetDeflection() * myDFace->GetDeflection())
162       {
163         // Lets check parameters for angular deflection.
164         if (myPrevControlVec.SquareMagnitude() < gp::Resolution() ||
165             aTmpVec.SquareMagnitude()          < gp::Resolution() ||
166             myPrevControlVec.Angle(aTmpVec)    < myParameters.AngleInterior)
167         {
168           // For current Iso line we can remove this parameter.
169           myControlParamsToRemove->Add(myCurrControlParam);
170           myCurrControlParam = theParam;
171           myCurrControlPnt   = aTmpPnt;
172           myCurrControlVec   = aTmpVec;
173           return Standard_True;
174         }
175         else
176         {
177           // We have found a place on the surface refusing 
178           // removement of this parameter.
179           myParamsForbiddenToRemove       ->Add(myCurrParam);
180           myControlParamsForbiddenToRemove->Add(myCurrControlParam);
181         }
182       }
183
184       return Standard_False;
185     }
186
187   private:
188
189     IMeshData::IFaceHandle                myDFace;
190     Handle(Geom_Surface)                  mySurface;
191     Standard_Boolean                      myIsoU;
192     Handle(IMeshData::SequenceOfReal)     myParams;
193     Handle(IMeshData::SequenceOfReal)     myControlParams;
194
195     Handle(IMeshData::MapOfReal)          myParamsForbiddenToRemove;
196     Handle(IMeshData::MapOfReal)          myControlParamsForbiddenToRemove;
197
198     Handle(NCollection_IncAllocator)      myAllocator;
199     Handle(IMeshData::MapOfReal)          myControlParamsToRemove;
200
201
202     IMeshTools_Parameters                 myParameters;
203     NCollection_Handle<GeomAdaptor_Curve> myIso;
204
205     Standard_Real                         myCurrParam;
206
207     Standard_Real                         myCurrControlParam;
208     gp_Pnt                                myCurrControlPnt;
209     gp_Vec                                myCurrControlVec;
210
211     Standard_Real                         myPrevControlParam;
212     gp_Pnt                                myPrevControlPnt;
213     gp_Vec                                myPrevControlVec;
214   };
215
216   //! Adds param to map if it fits specified range.
217   inline Standard_Boolean addParam(
218     const Standard_Real&                           theParam,
219     const std::pair<Standard_Real, Standard_Real>& theRange,
220     IMeshData::IMapOfReal&                         theParams)
221   {
222     if (theParam < theRange.first ||
223         theParam > theRange.second)
224     {
225       return Standard_False;
226     }
227
228     theParams.Add(theParam);
229     return Standard_True;
230   }
231
232   //! Initializes parameters map using CN intervals.
233   inline Standard_Boolean initParamsFromIntervals(
234     const TColStd_Array1OfReal&                    theIntervals,
235     const std::pair<Standard_Real, Standard_Real>& theRange,
236     const Standard_Boolean                         isSplitIntervals,
237     IMeshData::IMapOfReal&                         theParams)
238   {
239     Standard_Boolean isAdded = Standard_False;
240
241     for (Standard_Integer i = theIntervals.Lower(); i <= theIntervals.Upper(); ++i)
242     {
243       const Standard_Real aStartParam = theIntervals.Value(i);
244       if (addParam(aStartParam, theRange, theParams))
245       {
246         isAdded = Standard_True;
247       }
248
249       if (isSplitIntervals && i < theIntervals.Upper())
250       {
251         const Standard_Real aMidParam = (aStartParam + theIntervals.Value(i + 1)) / 2.;
252         if (addParam(aMidParam, theRange, theParams))
253         {
254           isAdded = Standard_True;
255         }
256       }
257     }
258
259     return isAdded;
260   }
261
262   //! Checks whether intervals should be split.
263   //! Returns true in case if it is impossible to compute normal 
264   //! directly on intervals, false is returned elsewhere.
265   Standard_Boolean toSplitIntervals (const Handle (Geom_Surface)&  theSurf,
266                                      const TColStd_Array1OfReal  (&theIntervals)[2])
267   {
268     Standard_Integer aIntervalU = theIntervals[0].Lower ();
269     for (; aIntervalU <= theIntervals[0].Upper (); ++aIntervalU)
270     {
271       const Standard_Real aParamU = theIntervals[0].Value(aIntervalU);
272       Standard_Integer aIntervalV = theIntervals[1].Lower ();
273       for (; aIntervalV <= theIntervals[1].Upper (); ++aIntervalV)
274       {
275         gp_Dir aNorm;
276         const Standard_Real aParamV = theIntervals[1].Value(aIntervalV);
277         if (GeomLib::NormEstim (theSurf, gp_Pnt2d (aParamU, aParamV), Precision::Confusion (), aNorm) != 0)
278         {
279           return Standard_True;
280         }
281         // TODO: do not split intervals if there is no normal in the middle of interval.
282       }
283     }
284
285     return Standard_False;
286   }
287 }
288
289 //=======================================================================
290 // Function: AdjustRange
291 // Purpose : 
292 //=======================================================================
293 void BRepMesh_NURBSRangeSplitter::AdjustRange()
294 {
295   BRepMesh_DefaultRangeSplitter::AdjustRange();
296   mySurfaceType = GetSurface()->GetType();
297
298   if (mySurfaceType == GeomAbs_BezierSurface)
299   {
300     const std::pair<Standard_Real, Standard_Real>& aRangeU = GetRangeU();
301     const std::pair<Standard_Real, Standard_Real>& aRangeV = GetRangeV();
302
303     myIsValid = !(aRangeU.first  < -0.5 ||
304                   aRangeU.second >  1.5 ||
305                   aRangeV.first  < -0.5 ||
306                   aRangeV.second >  1.5);
307   }
308 }
309
310 //=======================================================================
311 // Function: GenerateSurfaceNodes
312 // Purpose : 
313 //=======================================================================
314 Handle(IMeshData::ListOfPnt2d) BRepMesh_NURBSRangeSplitter::GenerateSurfaceNodes(
315   const IMeshTools_Parameters& theParameters) const
316 {
317   if (!initParameters())
318   {
319     return Handle(IMeshData::ListOfPnt2d)();
320   }
321
322   const std::pair<Standard_Real, Standard_Real>& aRangeU = GetRangeU();
323   const std::pair<Standard_Real, Standard_Real>& aRangeV = GetRangeV();
324   const std::pair<Standard_Real, Standard_Real>& aDelta  = GetDelta ();
325
326   const Standard_Real                 aDefFace = GetDFace()->GetDeflection();
327   const Handle(BRepAdaptor_HSurface)& gFace    = GetSurface();
328   Handle(Geom_Surface)                aSurface = gFace->ChangeSurface().Surface().Surface();
329
330   const Handle(NCollection_IncAllocator) aTmpAlloc =
331     new NCollection_IncAllocator(IMeshData::MEMORY_BLOCK_SIZE_HUGE);
332
333   const Handle(IMeshData::SequenceOfReal) aParams[2] = {
334     computeGrainAndFilterParameters(GetParametersU(), gFace->UResolution(aDefFace),
335       (aRangeU.second - aRangeU.first), aDelta.first,  theParameters, aTmpAlloc),
336
337     computeGrainAndFilterParameters(GetParametersV(), gFace->VResolution(aDefFace),
338       (aRangeV.second - aRangeV.first), aDelta.second, theParameters, aTmpAlloc)
339   };
340
341   // check intermediate isolines
342   Handle(IMeshData::MapOfReal) aFixedParams[2] = {
343     new IMeshData::MapOfReal(1, aTmpAlloc),
344     new IMeshData::MapOfReal(1, aTmpAlloc)
345   };
346
347   const Handle(IMeshData::MapOfReal) aParamsToRemove[2] = {
348     AnalyticalFilter(GetDFace(), GeomAbs_IsoV, aParams[1], aParams[0],
349       aFixedParams[1], aFixedParams[0]).GetControlParametersToRemove(theParameters),
350
351     AnalyticalFilter(GetDFace(), GeomAbs_IsoU, aParams[0], aParams[1],
352       aFixedParams[0], aFixedParams[1]).GetControlParametersToRemove(theParameters),
353   };
354
355   aParamsToRemove[0]->Subtract(*aFixedParams[0]);
356   aParamsToRemove[1]->Subtract(*aFixedParams[1]);
357
358   // insert nodes of the regular grid
359   Handle(IMeshData::ListOfPnt2d) aNodes = new IMeshData::ListOfPnt2d(
360     new NCollection_IncAllocator(IMeshData::MEMORY_BLOCK_SIZE_HUGE));
361
362   // insert nodes of the regular grid
363   for (Standard_Integer i = 1; i <= aParams[0]->Length(); ++i)
364   {
365     const Standard_Real aParam1 = aParams[0]->Value(i);
366     if (aParamsToRemove[0]->Contains(aParam1))
367     {
368       continue;
369     }
370
371     for (Standard_Integer j = 1; j <= aParams[1]->Length(); ++j)
372     {
373       const Standard_Real aParam2 = aParams[1]->Value(j);
374       if (aParamsToRemove[1]->Contains(aParam2))
375       {
376         continue;
377       }
378
379       aNodes->Append(gp_Pnt2d(aParam1, aParam2));
380     }
381   }
382
383   return aNodes;
384 }
385
386 //=======================================================================
387 // Function: initParameters
388 // Purpose : 
389 //=======================================================================
390 Standard_Boolean BRepMesh_NURBSRangeSplitter::initParameters() const
391 {
392   const Handle(BRepAdaptor_HSurface)& aSurface = GetSurface();
393
394   const GeomAbs_Shape aContinuity = GeomAbs_CN;
395   const std::pair<Standard_Integer, Standard_Integer> aIntervalsNb(
396     aSurface->NbUIntervals(aContinuity),
397     aSurface->NbVIntervals(aContinuity)
398   );
399
400   TColStd_Array1OfReal aIntervals[2] = {
401     TColStd_Array1OfReal(1, aIntervalsNb.first  + 1),
402     TColStd_Array1OfReal(1, aIntervalsNb.second + 1)
403   };
404
405   aSurface->UIntervals(aIntervals[0], aContinuity);
406   aSurface->VIntervals(aIntervals[1], aContinuity);
407
408   const Standard_Boolean isSplitIntervals = toSplitIntervals (
409     aSurface->ChangeSurface().Surface().Surface(), aIntervals);
410
411   if (!initParamsFromIntervals(aIntervals[0], GetRangeU(), isSplitIntervals,
412                                const_cast<IMeshData::IMapOfReal&>(GetParametersU())))
413   {
414     //if (!grabParamsOfEdges (Edge_Frontier, Param_U))
415     {
416       return Standard_False;
417     }
418   }
419
420   if (!initParamsFromIntervals(aIntervals[1], GetRangeV(), isSplitIntervals,
421                                const_cast<IMeshData::IMapOfReal&>(GetParametersV())))
422   {
423     //if (!grabParamsOfEdges (Edge_Frontier, Param_V))
424     {
425       return Standard_False;
426     }
427   }
428
429   return grabParamsOfEdges(Edge_Internal, Param_U | Param_V);
430 }
431
432 //=======================================================================
433 //function : grabParamsOfInternalEdges
434 //purpose  : 
435 //=======================================================================
436 Standard_Boolean BRepMesh_NURBSRangeSplitter::grabParamsOfEdges (
437   const EdgeType         theEdgeType,
438   const Standard_Integer theParamDimensionFlag) const
439 {
440   if ((theParamDimensionFlag & (Param_U | Param_V)) == 0)
441   {
442     return Standard_False;
443   }
444
445   const IMeshData::IFaceHandle& aDFace = GetDFace ();
446   for (Standard_Integer aWireIt = 0; aWireIt < aDFace->WiresNb (); ++aWireIt)
447   {
448     const IMeshData::IWireHandle& aDWire = aDFace->GetWire (aWireIt);
449     for (Standard_Integer aEdgeIt = 0; aEdgeIt < aDWire->EdgesNb (); ++aEdgeIt)
450     {
451       const IMeshData::IEdgePtr& aDEdge = aDWire->GetEdge (aEdgeIt);
452       for (Standard_Integer aPCurveIt = 0; aPCurveIt < aDEdge->PCurvesNb (); ++aPCurveIt)
453       {
454         const IMeshData::IPCurveHandle& aDPCurve = aDEdge->GetPCurve (aPCurveIt);
455         if (aDPCurve->GetFace () == aDFace)
456         {
457           if (theEdgeType == Edge_Internal && !aDPCurve->IsInternal ())
458           {
459             continue;
460           }
461
462           for (Standard_Integer aPointIt = 0; aPointIt < aDPCurve->ParametersNb (); ++aPointIt)
463           {
464             const gp_Pnt2d& aPnt2d = aDPCurve->GetPoint (aPointIt);
465             if (theParamDimensionFlag & Param_U)
466             {
467               const_cast<IMeshData::IMapOfReal&>(GetParametersU ()).Add (aPnt2d.X ());
468             }
469
470             if (theParamDimensionFlag & Param_V)
471             {
472               const_cast<IMeshData::IMapOfReal&>(GetParametersV ()).Add (aPnt2d.Y ());
473             }
474           }
475         }
476       }
477     }
478   }
479
480   return Standard_True;
481 }
482
483 //=======================================================================
484 //function : computeGrainAndFilterParameters
485 //purpose  : 
486 //=======================================================================
487 Handle(IMeshData::SequenceOfReal) BRepMesh_NURBSRangeSplitter::computeGrainAndFilterParameters(
488   const IMeshData::IMapOfReal&            theSourceParams,
489   const Standard_Real                     theTol2d,
490   const Standard_Real                     theRangeDiff,
491   const Standard_Real                     theDelta,
492   const IMeshTools_Parameters&            theParameters,
493   const Handle(NCollection_IncAllocator)& theAllocator) const
494 {
495   // Sort and filter sequence of parameters
496   Standard_Real aMinDiff = Precision::PConfusion();
497   if (theDelta < 1.)
498   {
499     aMinDiff /= theDelta;
500   }
501
502   aMinDiff = Max(theParameters.MinSize, aMinDiff);
503
504   const Standard_Real aDiffMaxLim = 0.1 * theRangeDiff;
505   const Standard_Real aDiffMinLim = Max(0.005 * theRangeDiff,
506                                         2. * theTol2d);
507   const Standard_Real aDiff = Max(theParameters.MinSize,
508                                   Min(aDiffMaxLim, aDiffMinLim));
509   return filterParameters(theSourceParams, aMinDiff, aDiff, theAllocator);
510 }
511
512 //=======================================================================
513 //function : filterParameters
514 //purpose  : 
515 //=======================================================================
516 Handle(IMeshData::SequenceOfReal) BRepMesh_NURBSRangeSplitter::filterParameters(
517   const IMeshData::IMapOfReal&            theParams,
518   const Standard_Real                     theMinDist,
519   const Standard_Real                     theFilterDist,
520   const Handle(NCollection_IncAllocator)& theAllocator) const
521 {
522   Handle(IMeshData::SequenceOfReal) aResult = new IMeshData::SequenceOfReal(theAllocator);
523
524   // Sort sequence of parameters
525   const Standard_Integer anInitLen = theParams.Extent();
526
527   if (anInitLen < 1)
528   {
529     return aResult;
530   }
531
532   TColStd_Array1OfReal aParamArray(1, anInitLen);
533   Standard_Integer j;
534   for (j = 1; j <= anInitLen; j++)
535     aParamArray(j) = theParams(j);
536
537   std::sort(aParamArray.begin(), aParamArray.end());
538
539   // mandatory pre-filtering using the first (minimal) filter value
540   Standard_Integer aParamLength = 1;
541   for (j = 2; j <= anInitLen; j++)
542   {
543     if ((aParamArray(j) - aParamArray(aParamLength)) > theMinDist)
544     {
545       if (++aParamLength < j)
546         aParamArray(aParamLength) = aParamArray(j);
547     }
548   }
549
550   //perform filtering on series
551   Standard_Real aLastAdded, aLastCandidate;
552   Standard_Boolean isCandidateDefined = Standard_False;
553   aLastAdded = aParamArray(1);
554   aLastCandidate = aLastAdded;
555   aResult->Append(aLastAdded);
556
557   for (j = 2; j < aParamLength; j++)
558   {
559     Standard_Real aVal = aParamArray(j);
560     if (aVal - aLastAdded > theFilterDist)
561     {
562       //adds the parameter
563       if (isCandidateDefined)
564       {
565         aLastAdded = aLastCandidate;
566         isCandidateDefined = Standard_False;
567         j--;
568       }
569       else
570       {
571         aLastAdded = aVal;
572       }
573       aResult->Append(aLastAdded);
574       continue;
575     }
576
577     aLastCandidate = aVal;
578     isCandidateDefined = Standard_True;
579   }
580   aResult->Append(aParamArray(aParamLength));
581
582   return aResult;
583 }