0023301: Comparing variable to itself in ShapeUpgrade_WireDivide.cxx
[occt.git] / src / ShapeUpgrade / ShapeUpgrade_WireDivide.cxx
1 // Created on: 1999-04-15
2 // Created by: Roman LYGIN
3 // Copyright (c) 1999-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 //    gka 23.06.99 S4208: using tool SU_TransferParameter 
22 //    pdn 13.07.99 synchronizing splitting values on 3d curve and pcurve
23 //    abv 14.07.99 dealing with edges without 3d curve
24 //    svv 10.01.00 porting on DEC
25
26 #include <ShapeUpgrade_WireDivide.ixx>
27 #include <ShapeUpgrade.hxx>
28 #include <BRep_Tool.hxx>
29 #include <BRep_Builder.hxx>
30 #include <BRepLib_MakeFace.hxx>
31 #include <BRepLib_MakeWire.hxx>
32 #include <TopoDS.hxx>
33 #include <TopoDS_Vertex.hxx>
34 #include <TopoDS_Edge.hxx>
35 #include <TopoDS_Iterator.hxx>
36 #include <ShapeBuild_Edge.hxx>
37 #include <ShapeAnalysis_Edge.hxx>
38 #include <Precision.hxx>
39 #include <TopExp.hxx>
40 #include <TopExp_Explorer.hxx>
41 #include <TColStd_HSequenceOfReal.hxx>
42 #include <TColGeom_HArray1OfCurve.hxx>
43 #include <TColGeom2d_HArray1OfCurve.hxx>
44 #include <gp_Pnt.hxx>
45 #include <Geom_Curve.hxx>
46 #include <Geom2d_Curve.hxx>
47 #include <ShapeExtend.hxx>
48 #include <TColStd_Array1OfBoolean.hxx>
49 #include <ShapeBuild_ReShape.hxx>
50 #include <ShapeAnalysis_TransferParametersProj.hxx>
51 #include <ShapeUpgrade_FixSmallCurves.hxx>
52 #include <TopTools_SequenceOfShape.hxx>
53 #include <TColStd_SequenceOfReal.hxx>
54 #include <GeomAdaptor_HSurface.hxx>
55 #include <Geom2dAdaptor_HCurve.hxx>
56 #include <ShapeAnalysis_Curve.hxx>
57 #include <Adaptor3d_CurveOnSurface.hxx>
58
59 //=======================================================================
60 //function : ShapeUpgrade_WireDivide
61 //purpose  : 
62 //=======================================================================
63
64 ShapeUpgrade_WireDivide::ShapeUpgrade_WireDivide():
65        ShapeUpgrade_Tool(), myStatus(0)
66 {
67 //  if (ShapeUpgrade::Debug()) cout <<"ShapeUpgrade_WireDivide"<<endl;
68   mySplitCurve3dTool = new ShapeUpgrade_SplitCurve3d;
69   mySplitCurve2dTool = new ShapeUpgrade_SplitCurve2d;
70   myTransferParamTool = new ShapeAnalysis_TransferParametersProj;
71   myEdgeMode = 2;
72   myFixSmallCurveTool = new ShapeUpgrade_FixSmallCurves; 
73   myEdgeDivide = new ShapeUpgrade_EdgeDivide;
74 }
75
76 //=======================================================================
77 //function : Init
78 //purpose  : 
79 //=======================================================================
80
81 void ShapeUpgrade_WireDivide::Init(const TopoDS_Wire& W,
82                                    const TopoDS_Face& F) 
83 {
84 //  if (ShapeUpgrade::Debug()) cout <<"ShapeUpgrade_WireDivide::Init with Wire, Face"<<endl;
85   myWire = W;
86   myFace = F;
87   myStatus = ShapeExtend::EncodeStatus ( ShapeExtend_OK );
88 }
89
90 //=======================================================================
91 //function : Init
92 //purpose  : 
93 //=======================================================================
94
95 void ShapeUpgrade_WireDivide::Init(const TopoDS_Wire& W,
96                                    const Handle(Geom_Surface)& S) 
97 {
98 //  if (ShapeUpgrade::Debug()) cout <<"ShapeUpgrade_WireDivide::Init with Wire, Surface "<<endl;
99   myWire = W;
100   BRepLib_MakeFace mkf(S, Precision::Confusion());
101   myFace = mkf.Face();
102   myStatus = ShapeExtend::EncodeStatus ( ShapeExtend_OK );
103 }
104
105 //=======================================================================
106 //function : Load
107 //purpose  : 
108 //=======================================================================
109
110 void ShapeUpgrade_WireDivide::Load(const TopoDS_Wire& W)
111 {
112   myWire = W;
113 }
114
115 //=======================================================================
116 //function : Load
117 //purpose  : 
118 //=======================================================================
119
120 void ShapeUpgrade_WireDivide::Load(const TopoDS_Edge& E)
121 {
122   BRepLib_MakeWire MakeWire (E);
123   if (MakeWire.IsDone())
124     Load (MakeWire.Wire());
125 }
126
127 //=======================================================================
128 //function : SetFace
129 //purpose  : 
130 //=======================================================================
131
132 void ShapeUpgrade_WireDivide::SetFace(const TopoDS_Face& F)
133 {
134   myFace = F;
135 }
136
137 //=======================================================================
138 //function : SetSurface
139 //purpose  : 
140 //=======================================================================
141
142 void ShapeUpgrade_WireDivide::SetSurface(const Handle(Geom_Surface)& S)
143 {
144   BRepLib_MakeFace mkf(S, Precision::Confusion());
145   myFace = mkf.Face();
146 }
147
148 //=======================================================================
149 //function : SetSurface
150 //purpose  : 
151 //=======================================================================
152
153 void ShapeUpgrade_WireDivide::SetSurface(const Handle(Geom_Surface)& S,
154                                          const TopLoc_Location& L)
155 {
156   BRep_Builder B;
157   B.MakeFace(myFace,S,L,Precision::Confusion());
158 }
159
160 //=======================================================================
161 //function : Perform
162 //purpose  : 
163 //=======================================================================
164
165 static void CorrectSplitValues(const Handle(TColStd_HSequenceOfReal) orig3d,
166                                const Handle(TColStd_HSequenceOfReal) orig2d,
167                                Handle(TColStd_HSequenceOfReal) new2d,
168                                Handle(TColStd_HSequenceOfReal) new3d)
169 {
170   Standard_Real preci = Precision::PConfusion();
171   Standard_Integer len3d = orig3d->Length();
172   Standard_Integer len2d = orig2d->Length();
173   TColStd_Array1OfBoolean fixNew2d (1, len3d);
174   fixNew2d.Init (Standard_False);
175   TColStd_Array1OfBoolean fixNew3d (1, len2d);
176   fixNew3d.Init (Standard_False);
177   Standard_Real Last3d = orig3d->Value(len3d);
178   Standard_Real Last2d = orig2d->Value(len2d);
179
180   Standard_Integer i;// svv #1
181   for( i = 1; i <= len3d ; i++) {
182     Standard_Real par = new2d->Value(i);
183     Standard_Integer index = 0;
184     for(Standard_Integer j = 1; j <= len2d && !index; j++)
185       if(Abs(par-orig2d->Value(j)) < preci)
186         index = j;
187     if(index&&!fixNew3d(index)) {
188       Standard_Real newPar = orig2d->Value(index);
189       new2d->SetValue(i,newPar);
190       fixNew2d(i) = Standard_True;
191       Standard_Real newPar3d = orig3d->Value(i);
192       new3d->SetValue(index,newPar3d);
193       fixNew3d(index) = Standard_True;
194     }
195   }
196   
197   for(i = 1; i <= len2d ; i++) {
198     Standard_Real par = new3d->Value(i);
199     Standard_Integer index = 0;
200     for(Standard_Integer j = 1; j <= len3d && !index; j++)
201       if(Abs(par-orig3d->Value(j)) < preci)
202         index = j;
203     if(index&&!fixNew2d(index)) {
204       Standard_Real newPar = orig3d->Value(index);
205       new3d->SetValue(i,newPar);
206       fixNew3d(i) = Standard_True;
207       Standard_Real newPar2d = orig2d->Value(i);
208       new2d->SetValue(index,newPar2d);
209       fixNew2d(index) = Standard_True;
210     }
211   }
212   
213   Standard_Real dpreci = 2* preci;
214   for(i = 1; i < len3d; i++) {
215     Standard_Real dist = new2d->Value(i+1) - new2d->Value(i);
216     if(dist < preci) {
217       if(fixNew2d(i+1)) {
218         //changing
219         Standard_Real tmp = new2d->Value(i+1);
220         new2d->SetValue(i+1,new2d->Value(i)+dpreci);
221         new2d->SetValue(i,tmp);
222         fixNew2d(i) = Standard_True;
223         fixNew2d(i+1) = Standard_False;
224       } 
225       else
226         new2d->SetValue(i+1,new2d->Value(i)+dpreci);
227     }
228   }
229   if(new2d->Value(len3d) > Last3d) {
230     Standard_Integer ind; // svv #1
231     for( ind = len3d; ind > 1 && !fixNew2d(ind); ind--);
232     Standard_Real lastFix = new2d->Value(ind);
233     for(i = len3d; i >= ind; i--) { 
234       new2d->SetValue(i,lastFix);
235       lastFix-=dpreci;
236     }
237   }
238   
239   for(i = 1; i < len2d; i++) {
240     Standard_Real dist = new3d->Value(i+1) - new3d->Value(i);
241     if(dist < preci) {
242       if(fixNew3d(i+1)) {
243         //changing
244         Standard_Real tmp = new3d->Value(i+1);
245         new3d->SetValue(i+1,new3d->Value(i)+dpreci);
246         new3d->SetValue(i,tmp);
247         fixNew3d(i) = Standard_True;
248         fixNew3d(i+1) = Standard_False;
249       }
250       else 
251         new3d->SetValue(i+1,new3d->Value(i)+dpreci);
252     }
253   }
254   if(new3d->Value(len2d) > Last2d) {
255     Standard_Integer ind; // svv #1
256     for(ind = len2d; ind > 1 && !fixNew3d(ind); ind--);
257     Standard_Real lastFix = new3d->Value(ind);
258     for(i = len2d; i >= ind; i--) { 
259       new3d->SetValue(i,lastFix);
260       lastFix-=dpreci;
261     }
262   }
263 }      
264
265 void ShapeUpgrade_WireDivide::Perform ()
266 {
267   
268   myStatus = ShapeExtend::EncodeStatus ( ShapeExtend_OK );
269   
270 //  if (ShapeUpgrade::Debug()) cout << "ShapeUpgrade_WireDivide::Perform" << endl;
271   
272   BRep_Builder B;
273   ShapeAnalysis_Edge sae;
274     
275   TopoDS_Wire newWire;
276   B.MakeWire (newWire);
277   TopLoc_Location Loc;
278   Handle(Geom_Surface) Surf;
279   if(!myFace.IsNull())
280     Surf = BRep_Tool::Surface(myFace, Loc);
281   
282   Standard_Boolean isSplit3d = Standard_True;
283   switch(myEdgeMode) {
284      case 0: if(!myFace.IsNull()) isSplit3d = Standard_False; break;
285      case 1: if(myFace.IsNull()) isSplit3d = Standard_False; break;
286      default : break;  
287   }
288   myEdgeDivide->SetFace(myFace);
289   if(isSplit3d)
290     myEdgeDivide->SetSplitCurve3dTool(GetSplitCurve3dTool());
291   myEdgeDivide->SetSplitCurve2dTool(GetSplitCurve2dTool());
292   for (TopoDS_Iterator ItW (myWire,Standard_False); ItW.More(); ItW.Next()) {
293     // for each Edge:
294     TopoDS_Shape sh = Context()->Apply(ItW.Value(),TopAbs_SHAPE);
295     for(TopExp_Explorer exp(sh,TopAbs_EDGE); exp.More(); exp.Next()) {
296       TopoDS_Edge E = TopoDS::Edge(exp.Current());
297 //      if (ShapeUpgrade::Debug()) cout << ".. Edge " << (void*) &(*E.TShape()) << endl;
298       
299       // skip degenerated edges (and also INTERNAL/EXTERNAL, to avoid failures)
300       if ( E.Orientation() == TopAbs_INTERNAL || E.Orientation() == TopAbs_EXTERNAL ) {
301         B.Add ( newWire, E );
302         continue;
303       }
304       
305       if(!myEdgeDivide->Compute(E)) {
306         B.Add ( newWire, E );
307         continue;
308       }   
309       // first iteration: getting split knots
310       // on 3D curve: preliminary
311       
312       Handle(ShapeAnalysis_TransferParameters) theTransferParamTool =  GetTransferParamTool();
313       theTransferParamTool->SetMaxTolerance(MaxTolerance());
314       theTransferParamTool->Init(E,myFace);
315       Standard_Boolean wasSR = theTransferParamTool->IsSameRange();
316       
317       // on pcurve(s): all knots
318       // assume that if seam-edge, its pcurve1 and pcurve2 has the same split knots !!!
319       Handle(TColStd_HSequenceOfReal) theKnots3d = myEdgeDivide->Knots3d();
320       Handle(TColStd_HSequenceOfReal) theKnots2d = myEdgeDivide->Knots2d();
321       
322       // second iteration: transfer parameters and build segments
323       Handle(TColStd_HSequenceOfReal) SplitValues2d;
324       Handle(TColStd_HSequenceOfReal) SplitValues3d;
325       if(myEdgeDivide->HasCurve2d() && myEdgeDivide->HasCurve3d() ) {
326         SplitValues2d = theTransferParamTool->Perform(theKnots3d,Standard_True);
327         SplitValues3d = theTransferParamTool->Perform(theKnots2d,Standard_False);
328         CorrectSplitValues(theKnots3d,theKnots2d,SplitValues2d,SplitValues3d);
329       }
330       Handle(ShapeUpgrade_SplitCurve3d) theSplit3dTool = myEdgeDivide->GetSplitCurve3dTool();
331       Handle(ShapeUpgrade_SplitCurve2d) theSplit2dTool = myEdgeDivide->GetSplitCurve2dTool();
332       
333       if ( myEdgeDivide->HasCurve2d() ) {
334         if(! theKnots3d.IsNull() ) {
335           SplitValues2d->Remove(1);
336           SplitValues2d->Remove(SplitValues2d->Length());
337           theSplit2dTool->SetSplitValues (SplitValues2d);
338         }
339         theSplit2dTool->Build(Standard_True);
340       }
341       if ( myEdgeDivide->HasCurve3d() ) {
342         if( ! theKnots2d.IsNull() ) {
343           SplitValues3d->Remove(1);
344           SplitValues3d->Remove(SplitValues3d->Length());
345           theSplit3dTool->SetSplitValues (SplitValues3d);
346         }
347         theSplit3dTool->Build (Standard_True);
348       }
349       // get 2d and 3d split values which should be the same
350       if ( myEdgeDivide->HasCurve2d() ) theKnots2d = theSplit2dTool->SplitValues(); 
351       if ( myEdgeDivide->HasCurve3d() ) theKnots3d = theSplit3dTool->SplitValues();
352       
353       Standard_Boolean isSeam = Standard_False;
354       if (! myFace.IsNull() )
355         isSeam = BRep_Tool::IsClosed ( E, myFace );
356       Handle(TColGeom2d_HArray1OfCurve) theSegments2d;
357       if(myEdgeDivide->HasCurve2d())
358         theSegments2d = theSplit2dTool->GetCurves();
359       Handle(TColGeom2d_HArray1OfCurve) theSegments2dR;
360       if ( isSeam ) {
361         Handle(Geom2d_Curve) c2;
362         Standard_Real f2, l2;    
363 //smh#8
364         TopoDS_Shape tmpE = E.Reversed();
365         TopoDS_Edge erev = TopoDS::Edge (tmpE );
366         if ( sae.PCurve ( erev, myFace, c2, f2, l2, Standard_False) ) {
367           theSplit2dTool->Init (c2, f2, l2);
368           if(!theKnots2d.IsNull())
369             theSplit2dTool->SetSplitValues (theKnots2d);
370           theSplit2dTool->Perform (Standard_True);
371           Handle(TColStd_HSequenceOfReal) revKnots2d = theSplit2dTool->SplitValues();
372           if(revKnots2d->Length()!=theKnots2d->Length()) {
373             isSeam = Standard_False;
374 #ifdef DEB
375             cout << "Error: ShapeUpgrade_WireDivide: seam has different splitting values on pcurvesd" << endl;
376 #endif
377           }
378           else
379             theSegments2dR = theSplit2dTool->GetCurves();
380         }
381         else isSeam = Standard_False;
382       }
383       
384       // Exploring theEdge
385       TopoDS_Vertex V1o = TopExp::FirstVertex (E, Standard_False);
386       TopoDS_Vertex V2o = TopExp::LastVertex  (E, Standard_False);
387       Standard_Boolean isForward = ( E.Orientation() == TopAbs_FORWARD );
388       Standard_Real TolEdge = BRep_Tool::Tolerance (E);
389       Standard_Boolean isDeg = BRep_Tool::Degenerated ( E );
390
391       // Copy vertices to protect original shape against SameParamseter
392 //smh#8
393       TopoDS_Shape emptyCopiedV1 = V1o.EmptyCopied();
394       TopoDS_Vertex V1 = TopoDS::Vertex ( emptyCopiedV1 );
395       Context()->Replace ( V1o, V1 );
396       TopoDS_Vertex V2;
397       if ( V1o.IsSame ( V2o ) ) {
398 //smh#8
399         TopoDS_Shape tmpV = V1.Oriented(V2o.Orientation() );
400         V2 = TopoDS::Vertex ( tmpV ); 
401       }
402       else {
403 //smh#8
404         TopoDS_Shape emptyCopied = V2o.EmptyCopied();
405         V2 = TopoDS::Vertex ( emptyCopied );
406         Context()->Replace ( V2o, V2 );
407       }
408
409       //collect NM vertices
410      
411       Standard_Real af,al;
412       Handle(Geom_Curve) c3d;
413       Adaptor3d_CurveOnSurface AdCS;
414       if(myEdgeDivide->HasCurve3d()) 
415         sae.Curve3d(E,c3d,af,al,Standard_False);
416       else if(myEdgeDivide->HasCurve2d() && !Surf.IsNull()) {
417         Handle(Geom2d_Curve) c2d;
418         sae.PCurve ( E, myFace, c2d, af, al, Standard_False); 
419         Handle(GeomAdaptor_HSurface) AdS = new GeomAdaptor_HSurface(Surf);
420         Handle(Geom2dAdaptor_HCurve) AC2d  = new Geom2dAdaptor_HCurve(c2d,af,al);
421         AdCS.Load(AC2d);
422         AdCS.Load(AdS);
423       }
424       TopTools_SequenceOfShape aSeqNMVertices;
425       TColStd_SequenceOfReal aSeqParNM;
426       TopoDS_Iterator aItv(E,Standard_False);
427       ShapeAnalysis_Curve sac;
428       for ( ; aItv.More() ; aItv.Next()) {
429         if(aItv.Value().Orientation() == TopAbs_INTERNAL ||
430            aItv.Value().Orientation() == TopAbs_EXTERNAL) {
431           TopoDS_Vertex aVold = TopoDS::Vertex(aItv.Value());
432           aSeqNMVertices.Append(aVold);
433           gp_Pnt aP = BRep_Tool::Pnt(TopoDS::Vertex(aVold));
434           Standard_Real ppar;
435           gp_Pnt pproj;
436           if(!c3d.IsNull())
437             sac.Project(c3d,aP,Precision(),pproj,ppar,af,al,Standard_False);
438           else  
439             sac.Project(AdCS,aP,Precision(),pproj,ppar);
440           aSeqParNM.Append(ppar);
441         }
442       }
443       
444       // creating new edge(s)
445       Handle(TColGeom_HArray1OfCurve) theSegments3d;
446       if(myEdgeDivide->HasCurve3d()) theSegments3d = theSplit3dTool->GetCurves();
447       
448       Standard_Integer nbc = 0;
449       if (!theSegments3d.IsNull()) {
450         nbc = theSegments3d->Length();
451         if ( !theSegments2d.IsNull() ) {
452           Standard_Integer nbc2d = theSegments2d->Length();
453           if (nbc!=nbc2d) {
454 #ifdef DEB
455             cout<<"Error: Number of intervals are not equal for 2d 3d. Ignored."<<endl;
456 #endif
457             nbc = Min( nbc,nbc2d);
458           }
459         }
460       }
461       else
462         if(!theSegments2d.IsNull())// if theSegments have different length ???
463           nbc = theSegments2d->Length(); 
464       
465       if ( nbc <= 1 && ! theSplit3dTool->Status ( ShapeExtend_DONE ) && 
466                        ! theSplit2dTool->Status ( ShapeExtend_DONE ) ) {
467         B.Add ( newWire, E );
468         continue;
469       }
470       
471      myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_DONE1 );
472       
473       TopoDS_Wire resWire;
474       B.MakeWire (resWire);
475 //      TopoDS_Vertex firstVertex, lastVertex;
476       Standard_Integer numE =0;
477       gp_Pnt pntV1 = BRep_Tool::Pnt(V1);
478       //gp_Pnt pntV2 = BRep_Tool::Pnt(V2); // pntV2 not used - see below (skl)
479       Standard_Real V1Tol = LimitTolerance( BRep_Tool::Tolerance(V1) );
480       //Standard_Real V2Tol = LimitTolerance( BRep_Tool::Tolerance(V2) ); // V2Tol not used - see below (skl)
481       
482       Handle(ShapeUpgrade_FixSmallCurves) FixSmallCurveTool = GetFixSmallCurveTool(); //gka Precision
483       FixSmallCurveTool->SetMinTolerance(MinTolerance());
484       FixSmallCurveTool->Init(E, myFace);
485       FixSmallCurveTool->SetSplitCurve3dTool(theSplit3dTool);
486       FixSmallCurveTool->SetSplitCurve2dTool(theSplit2dTool);
487       FixSmallCurveTool->SetPrecision(MinTolerance());
488       Standard_Integer Savnum =0;
489       Standard_Real SavParf;
490       Standard_Integer Small = 0;
491       for ( Standard_Integer icurv = 1; icurv <= nbc; icurv++ ) {
492       
493         Handle(Geom_Curve) theNewCurve3d;
494         if(!theSegments3d.IsNull()) theNewCurve3d = theSegments3d->Value(icurv);
495         
496         Handle(Geom2d_Curve) theNewPCurve1;
497         if(!theSegments2d.IsNull()) theNewPCurve1 = theSegments2d->Value(icurv);
498         Handle(Geom2d_Curve) revPCurve;
499         if(isSeam) 
500           revPCurve = theSegments2dR->Value(icurv);
501         // construction of the intermediate Vertex
502         TopoDS_Vertex V;
503         if ( icurv <= nbc && nbc != 1 && ! isDeg ) {
504           Standard_Real par,parf /*,SavParl*/;
505           //Standard_Real SaveParf; // SaveParf not used - see below (skl)
506           gp_Pnt P,P1,PM;
507           // if edge has 3d curve, take point from it
508           if ( ! theNewCurve3d.IsNull() ) { 
509             if(theNewCurve3d->IsKind(STANDARD_TYPE(Geom_BoundedCurve))) {
510               par = theNewCurve3d->LastParameter();
511               parf = theNewCurve3d->FirstParameter();
512             }
513             else {
514               par = theKnots3d->Value (icurv + 1);
515               parf = theKnots3d->Value (icurv);
516             }
517             P = theNewCurve3d->Value (par);
518             P1 = theNewCurve3d->Value (parf);
519             PM = theNewCurve3d->Value ((parf+par)/2);
520           }
521           // else use pcurve and surface (suppose that both exist)
522           else {
523             if ( Surf.IsNull() ) Surf = BRep_Tool::Surface ( myFace, Loc );
524             if ( theNewPCurve1->IsKind(STANDARD_TYPE(Geom2d_BoundedCurve)) ) {
525               par = theNewPCurve1->LastParameter();
526               parf = theNewPCurve1->FirstParameter();
527             }
528             else {
529               par = theKnots2d->Value (icurv + 1);
530               parf = theKnots2d->Value (icurv);
531             }
532             gp_Pnt2d p2d = theNewPCurve1->Value (par);
533             gp_Pnt2d p2df = theNewPCurve1->Value (parf);
534             gp_Pnt2d p2dM = theNewPCurve1->Value ((parf+par)/2);
535             P = Surf->Value ( p2d.X(), p2d.Y() );
536             P1 = Surf->Value ( p2df.X(), p2df.Y() );
537             PM = Surf->Value ( p2dM.X(), p2dM.Y() );
538             P.Transform ( Loc.Transformation() );
539             P1.Transform ( Loc.Transformation() );
540             PM.Transform ( Loc.Transformation() );
541           }
542           if(P.Distance(pntV1) < MinTolerance() && P.Distance(PM) < MinTolerance() && !myFace.IsNull()) {
543             if(!Small) {
544               SavParf = parf;
545               Savnum = icurv;
546             }
547             //SavParl = par;
548             Small++;
549             if(icurv == nbc) {
550               TopoDS_Vertex VVV = V1;
551               VVV.Orientation ( V2.Orientation() );
552               Context()->Replace(V2,VVV);
553             }
554             continue;
555           }
556           if(Small) {
557             if(P.Distance(P1) > MinTolerance() || P.Distance(PM) > MinTolerance()) {
558               //FixSmallCurveTool->Perform(prevEdge,theNewCurve3d,theNewPCurve1,revPCurve,SavParf,SavParl);
559               gp_Pnt pmid = 0.5 * ( pntV1.XYZ() + P1.XYZ() );
560               B.UpdateVertex(V1,pmid,0);
561             }
562             else {
563               Handle(Geom_Curve) atmpCurve;
564               Handle(Geom2d_Curve) atmpCurve2d1,atmprepcurve;
565               if(FixSmallCurveTool->Approx( atmpCurve,atmpCurve2d1,atmprepcurve,SavParf,par)) { //BRepTools
566                 theNewCurve3d = atmpCurve;
567                 theNewPCurve1 = atmpCurve2d1;
568                 revPCurve = atmprepcurve;
569               }
570               else {
571                 gp_Pnt pmid = 0.5 * ( pntV1.XYZ() + P1.XYZ() );
572                 B.UpdateVertex(V1,pmid,0);
573               }
574             }
575             Small =0;
576           }
577           //pdn
578          /* if(P.Distance (pntV1) < V1Tol) 
579             V = V1;
580           else if (P.Distance (pntV2) < V2Tol) {
581             V = V2;
582             V1Tol = V2Tol;
583             pntV1 = pntV2;
584           }
585           else {*/
586           if(icurv != nbc)  {
587             B.MakeVertex (V, P, TolEdge); //tolerance of the edge
588             pntV1 = P;
589             V1Tol = LimitTolerance( TolEdge );
590           }
591           else V = V2;
592          // else  V2;
593          // }
594 //        if (ShapeUpgrade::Debug()) cout <<"... New intermediate Vertex (" 
595 //          <<P.X()<<","<<P.Y()<<","<<P.Z()<<") :"<<(void*) &(*V.TShape())
596 //            <<" with Tolerance "<<TolEdge <<endl;
597         }
598         //else V = V2;
599         
600         TopoDS_Edge newEdge;
601         ShapeBuild_Edge sbe;
602         if ( isForward ) {
603           V1.Orientation ( TopAbs_FORWARD );
604           V.Orientation ( TopAbs_REVERSED );
605           newEdge = sbe.CopyReplaceVertices ( E, V1, V );
606         }
607         else {
608           V1.Orientation ( TopAbs_REVERSED );
609           V.Orientation ( TopAbs_FORWARD );
610           newEdge = sbe.CopyReplaceVertices ( E, V, V1 );
611         }
612         sbe.CopyPCurves ( newEdge, E );
613         if(!theNewCurve3d.IsNull())
614           B.UpdateEdge ( newEdge, theNewCurve3d, 0. );
615         else if ( isDeg )
616           B.Degenerated( newEdge, Standard_True);
617         //if(isSeam) {
618          // Handle(Geom2d_Curve) revPCurve = theSegments2dR->Value(icurv);
619           //if(newEdge.Orientation()==TopAbs_FORWARD)
620             //B.UpdateEdge ( newEdge, theNewPCurve1, revPCurve, myFace, 0. );
621           //else
622             //B.UpdateEdge ( newEdge, revPCurve, theNewPCurve1, myFace, 0. );
623         //}
624         //else if ( ! myFace.IsNull() ) 
625           //B.UpdateEdge ( newEdge, theNewPCurve1, myFace, 0. );
626         
627         Standard_Real f3d = 0., l3d =0.;
628         if(!Savnum) Savnum = icurv;
629         Standard_Boolean srNew;
630         if(!theNewCurve3d.IsNull()) {
631           if(theNewCurve3d->IsKind(STANDARD_TYPE(Geom_BoundedCurve))) {
632             f3d = theNewCurve3d->FirstParameter();
633             l3d = theNewCurve3d->LastParameter();
634             srNew = ((f3d == theKnots3d->Value (Savnum)) && (l3d == theKnots3d->Value (icurv + 1)));
635           }
636           else  {
637             f3d = theKnots3d->Value (Savnum);
638             l3d = theKnots3d->Value (icurv + 1);
639             srNew = Standard_True;
640           }
641         }
642         else
643           srNew = Standard_True;
644       
645         Standard_Real f2d=0, l2d=0;
646         if(!theNewPCurve1.IsNull()){
647           if(theNewPCurve1->IsKind(STANDARD_TYPE(Geom2d_BoundedCurve))) {
648             f2d = theNewPCurve1->FirstParameter();
649             l2d = theNewPCurve1->LastParameter();
650             srNew &= ((f2d == theKnots2d->Value (Savnum)) && (l2d == theKnots2d->Value (icurv + 1)));
651           }
652           else {
653             f2d = theKnots2d->Value (Savnum);
654             l2d = theKnots2d->Value (icurv + 1);
655           }
656         }
657         //if(!Savnum) Savnum = icurv; 
658         if(!theNewCurve3d.IsNull())
659           theTransferParamTool->TransferRange(newEdge,theKnots3d->Value (Savnum),theKnots3d->Value (icurv + 1),Standard_False);
660         else
661           theTransferParamTool->TransferRange(newEdge,theKnots2d->Value (Savnum),theKnots2d->Value (icurv + 1),Standard_True);
662         /*
663         Standard_Real alpha = (theKnots3d->Value (icurv) - f)/(l - f);
664         Standard_Real beta  = (theKnots3d->Value (icurv + 1) - f)/(l - f);
665         sbe.CopyRanges(newEdge,E, alpha, beta);*/
666         Savnum =0;
667         Handle(Geom2d_Curve) c2dTmp;
668         Standard_Real setF, setL;
669         if( ! myFace.IsNull() && sae.PCurve (newEdge, myFace, c2dTmp, setF, setL, Standard_False))
670           srNew &= ( (setF==f2d) && (setL==l2d) );
671
672         if(isSeam) {
673           // Handle(Geom2d_Curve  revPCurve = theSegments2dR->Value(icurv);
674           if(newEdge.Orientation()==TopAbs_FORWARD)
675             B.UpdateEdge ( newEdge, theNewPCurve1, revPCurve, myFace, 0. );
676           else
677             B.UpdateEdge ( newEdge, revPCurve, theNewPCurve1, myFace, 0. );
678         }
679         else if ( ! myFace.IsNull() ) {
680           B.UpdateEdge ( newEdge, theNewPCurve1, myFace, 0. );
681         }
682           
683         if(!theNewCurve3d.IsNull())
684           sbe.SetRange3d(newEdge,f3d,l3d);
685         if(!theNewPCurve1.IsNull())
686           B.Range ( newEdge, myFace, f2d, l2d);
687         if((!wasSR || !srNew)&&!BRep_Tool::Degenerated(newEdge) )
688           B.SameRange(newEdge, Standard_False);
689
690           //addition NM vertices to new edges
691           Standard_Real afpar = (myEdgeDivide->HasCurve3d() ? f3d : f2d);
692                                 
693           Standard_Real alpar = (myEdgeDivide->HasCurve3d() ? l3d: l2d);
694           Standard_Integer n =1;
695           for( ; n <= aSeqParNM.Length(); n++) {
696             Standard_Real apar = aSeqParNM.Value(n);
697             TopoDS_Vertex aVold = TopoDS::Vertex(aSeqNMVertices.Value(n));
698             TopoDS_Vertex aNMVer =ShapeAnalysis_TransferParametersProj::CopyNMVertex(aVold,newEdge,E);
699             Context()->Replace(aVold,aNMVer);
700             if(fabs(apar - afpar) <= Precision::PConfusion()) 
701               Context()->Replace(aNMVer,V1);
702             else if(fabs(apar - alpar) <= Precision::PConfusion()) 
703               Context()->Replace(aNMVer,V);
704             else if( apar > afpar && apar <alpar) 
705               B.Add (newEdge,aNMVer);
706             else continue;  
707             aSeqNMVertices.Remove(n);
708             aSeqParNM.Remove(n);
709             n--;
710           }
711           
712           
713 //      if (ShapeUpgrade::Debug()) cout <<"... New Edge " 
714 //        <<(void*) &(*newEdge.TShape())<<" on vertices "
715 //          <<(void*) &(*V1.TShape())<<", " <<(void*) &(*V.TShape())
716 //            <<" with Tolerance "<<TolEdge <<endl;
717         B.Add ( resWire, newEdge );
718         B.Add ( newWire, newEdge );
719         numE++;
720         V1 = V;
721       }
722       if(numE)
723         Context()->Replace(E,resWire);
724       else
725         Context()->Remove(E);
726     }
727   }
728   if ( Status ( ShapeExtend_DONE ) ) {
729 //smh#8
730     TopoDS_Shape tmpW = Context()->Apply ( newWire ).Oriented(myWire.Orientation());
731     myWire = TopoDS::Wire (tmpW );
732   }
733 }
734
735 //=======================================================================
736 //function : Face
737 //purpose  : 
738 //=======================================================================
739
740 const TopoDS_Wire& ShapeUpgrade_WireDivide::Wire() const
741 {
742   return myWire;
743 }
744
745 //=======================================================================
746 //function : Status
747 //purpose  : 
748 //=======================================================================
749
750 Standard_Boolean ShapeUpgrade_WireDivide::Status (const ShapeExtend_Status status) const
751 {
752   return ShapeExtend::DecodeStatus ( myStatus, status );
753 }
754
755 //=======================================================================
756 //function : SetSplitCurve3dTool
757 //purpose  : 
758 //=======================================================================
759
760 void ShapeUpgrade_WireDivide::SetSplitCurve3dTool(const Handle(ShapeUpgrade_SplitCurve3d)& splitCurve3dTool)
761 {
762   mySplitCurve3dTool = splitCurve3dTool;
763 }
764
765 //=======================================================================
766 //function : SetSplitCurve2dTool
767 //purpose  : 
768 //=======================================================================
769
770 void ShapeUpgrade_WireDivide::SetSplitCurve2dTool(const Handle(ShapeUpgrade_SplitCurve2d)& splitCurve2dTool)
771 {
772   mySplitCurve2dTool = splitCurve2dTool;
773 }
774
775 //=======================================================================
776 //function : GetSplitCurve3dTool
777 //purpose  : 
778 //=======================================================================
779
780 Handle(ShapeUpgrade_SplitCurve3d) ShapeUpgrade_WireDivide::GetSplitCurve3dTool() const
781 {
782   return mySplitCurve3dTool;
783 }
784
785 //=======================================================================
786 //function : GetSplitCurve2dTool
787 //purpose  : 
788 //=======================================================================
789
790 Handle(ShapeUpgrade_SplitCurve2d) ShapeUpgrade_WireDivide::GetSplitCurve2dTool() const
791 {
792   return mySplitCurve2dTool;
793 }
794
795 //=======================================================================
796 //function : SetEdgeDivideTool
797 //purpose  : 
798 //=======================================================================
799
800 void ShapeUpgrade_WireDivide::SetEdgeDivideTool(const Handle (ShapeUpgrade_EdgeDivide)& edgeDivideTool)
801 {
802   myEdgeDivide = edgeDivideTool;
803 }
804
805 //=======================================================================
806 //function : GetEdgeDivideTool
807 //purpose  : 
808 //=======================================================================
809
810 Handle (ShapeUpgrade_EdgeDivide) ShapeUpgrade_WireDivide::GetEdgeDivideTool() const
811 {
812   return myEdgeDivide;
813 }
814
815 //=======================================================================
816 //function : SetTransferParamTool
817 //purpose  : 
818 //=======================================================================
819
820 void ShapeUpgrade_WireDivide::SetTransferParamTool(const Handle(ShapeAnalysis_TransferParameters)& TransferParam)
821 {
822   myTransferParamTool = TransferParam;
823 }
824
825 //=======================================================================
826 //function : GetTransferParamTool
827 //purpose  : 
828 //=======================================================================
829
830 Handle(ShapeAnalysis_TransferParameters) ShapeUpgrade_WireDivide::GetTransferParamTool()
831 {
832   return myTransferParamTool;
833 }
834
835 //=======================================================================
836 //function : SetEdgeMode
837 //purpose  : 
838 //=======================================================================
839
840  void ShapeUpgrade_WireDivide::SetEdgeMode(const Standard_Integer EdgeMode) 
841 {
842   myEdgeMode = EdgeMode;
843 }
844
845 //=======================================================================
846 //function : SetFixSmallCurveTool
847 //purpose  : 
848 //=======================================================================
849
850  void ShapeUpgrade_WireDivide::SetFixSmallCurveTool(const Handle(ShapeUpgrade_FixSmallCurves)& FixSmallCurvesTool) 
851 {
852   myFixSmallCurveTool = FixSmallCurvesTool; 
853 }
854
855 //=======================================================================
856 //function : GetFixSmallCurveTool
857 //purpose  : 
858 //=======================================================================
859
860  Handle(ShapeUpgrade_FixSmallCurves) ShapeUpgrade_WireDivide::GetFixSmallCurveTool() const
861 {
862   return  myFixSmallCurveTool;
863 }