1 // Copyright (c) 1999-2012 OPEN CASCADE SAS
3 // The content of this file is subject to the Open CASCADE Technology Public
4 // License Version 6.5 (the "License"). You may not use the content of this file
5 // except in compliance with the License. Please obtain a copy of the License
6 // at http://www.opencascade.org and read it completely before using this file.
8 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
9 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
11 // The Original Code and all software distributed under the License is
12 // distributed on an "AS IS" basis, without warranty of any kind, and the
13 // Initial Developer hereby disclaims all such warranties, including without
14 // limitation, any warranties of merchantability, fitness for a particular
15 // purpose or non-infringement. Please see the License for the specific terms
16 // and conditions governing the rights and limitations under the License.
18 #include <Geom_OsculatingSurface.ixx>
19 #include <Geom_BezierSurface.hxx>
20 #include <TColgp_Array2OfPnt.hxx>
21 #include <TColgp_HArray2OfPnt.hxx>
22 #include <TColStd_Array1OfReal.hxx>
23 #include <TColStd_Array1OfInteger.hxx>
24 #include <TColStd_HArray2OfInteger.hxx>
25 #include <TColStd_HArray1OfReal.hxx>
26 #include <TColStd_HArray1OfInteger.hxx>
27 #include <TColgp_Array1OfPnt.hxx>
28 #include <TColgp_Array2OfVec.hxx>
29 #include <BSplSLib.hxx>
30 #include <Convert_GridPolynomialToPoles.hxx>
31 #include <Precision.hxx>
34 //=======================================================================
35 //function : Geom_OffsetOsculatingSurface
37 //=======================================================================
39 Geom_OsculatingSurface::Geom_OsculatingSurface()
43 //=======================================================================
44 //function : Geom_OffsetOsculatingSurface
46 //=======================================================================
48 Geom_OsculatingSurface::Geom_OsculatingSurface(const Handle(Geom_Surface)& BS,
49 const Standard_Real Tol)
55 //=======================================================================
58 //=======================================================================
60 void Geom_OsculatingSurface::Init(const Handle(Geom_Surface)& BS,
61 const Standard_Real Tol)
65 Standard_Real TolMin=0.;//consider all singularities below Tol, not just above 1.e-12 (id23943)
66 Standard_Boolean OsculSurf = Standard_True;
67 myBasisSurf = Handle(Geom_Surface)::DownCast(BS->Copy());
68 myOsculSurf1 = new Geom_HSequenceOfBSplineSurface();
69 myOsculSurf2 = new Geom_HSequenceOfBSplineSurface();
70 if ((BS->IsKind(STANDARD_TYPE(Geom_BSplineSurface))) ||
71 (BS->IsKind(STANDARD_TYPE(Geom_BezierSurface))))
73 Standard_Real U1=0,U2=0,V1=0,V2=0;
75 Standard_Integer i = 1;
76 BS->Bounds(U1,U2,V1,V2);
77 myAlong.SetValue(1,IsQPunctual(BS,V1,GeomAbs_IsoV,TolMin,Tol));
78 myAlong.SetValue(2,IsQPunctual(BS,V2,GeomAbs_IsoV,TolMin,Tol));
79 myAlong.SetValue(3,IsQPunctual(BS,U1,GeomAbs_IsoU,TolMin,Tol));
80 myAlong.SetValue(4,IsQPunctual(BS,U2,GeomAbs_IsoU,TolMin,Tol));
81 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
82 cout<<myAlong(1)<<endl<<myAlong(2)<<endl<<myAlong(3)<<endl<<myAlong(4)<<endl;
84 if (myAlong(1) || myAlong(2) || myAlong(3) || myAlong(4))
86 Handle(Geom_BSplineSurface) InitSurf, L,S;
87 if (BS->IsKind(STANDARD_TYPE(Geom_BezierSurface)))
89 Handle(Geom_BezierSurface) BzS = Handle(Geom_BezierSurface)::DownCast(BS);
90 TColgp_Array2OfPnt P(1,BzS->NbUPoles(),1,BzS->NbVPoles());
91 TColStd_Array1OfReal UKnots(1,2);
92 TColStd_Array1OfReal VKnots(1,2);
93 TColStd_Array1OfInteger UMults(1,2);
94 TColStd_Array1OfInteger VMults(1,2);
97 UKnots.SetValue(i,(i-1));
98 VKnots.SetValue(i,(i-1));
99 UMults.SetValue(i,BzS->UDegree()+1);
100 VMults.SetValue(i,BzS->VDegree()+1);
103 InitSurf = new Geom_BSplineSurface(P,UKnots,VKnots,
112 InitSurf = Handle(Geom_BSplineSurface)::DownCast(myBasisSurf);
114 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
115 cout<<"UDEG: "<<InitSurf->UDegree()<<endl;
116 cout<<"VDEG: "<<InitSurf->VDegree()<<endl;
119 if(IsAlongU() && IsAlongV()) ClearOsculFlags();
120 // Standard_ConstructionError_Raise_if((IsAlongU() && IsAlongV()),"Geom_OsculatingSurface");
121 if ((IsAlongU() && InitSurf->VDegree()>1) ||
122 (IsAlongV() && InitSurf->UDegree()>1))
124 myKdeg = new TColStd_HSequenceOfInteger();
125 Standard_Integer k=0;
126 Standard_Boolean IsQPunc;
127 Standard_Integer UKnot,VKnot;
128 if (myAlong(1) || myAlong(2))
130 for (i=1;i<InitSurf->NbUKnots();i++)
134 S = InitSurf; k=0; IsQPunc=Standard_True;
139 OsculSurf = BuildOsculatingSurface(V1,UKnot,VKnot,S,L);
140 if(!OsculSurf) break;
142 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
143 cout<<"1.k = "<<k<<endl;
145 IsQPunc=IsQPunctual(L,V1,GeomAbs_IsoV,0.,Tol);
152 myOsculSurf1->Append(L);
154 ClearOsculFlags(); //myAlong.SetValue(1,Standard_False);
155 if (myAlong(2) && OsculSurf)
157 S = InitSurf; k=0; IsQPunc=Standard_True;
159 VKnot=InitSurf->NbVKnots()-1;
163 OsculSurf = BuildOsculatingSurface(V2,UKnot,VKnot,S,L);
164 if(!OsculSurf) break;
166 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
167 cout<<"2.k = "<<k<<endl;
169 IsQPunc=IsQPunctual(L,V2,GeomAbs_IsoV,0.,Tol);
176 myOsculSurf2->Append(L);
184 S = InitSurf; k=0; IsQPunc=Standard_True;
186 VKnot=InitSurf->NbVKnots()-1;
189 OsculSurf = BuildOsculatingSurface(V2,UKnot,VKnot,S,L);
190 if(!OsculSurf) break;
192 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
193 cout<<"2.k = "<<k<<endl;
195 IsQPunc=IsQPunctual(L,V2,GeomAbs_IsoV,0.,Tol);
203 myOsculSurf2->Append(L);
207 ClearOsculFlags(); //myAlong.SetValue(2,Standard_False);
211 if (myAlong(3) || myAlong(4))
213 for (i=1;i<InitSurf->NbVKnots();i++)
217 S = InitSurf; k=0; IsQPunc=Standard_True;
222 OsculSurf = BuildOsculatingSurface(U1,UKnot,VKnot,S,L);
223 if(!OsculSurf) break;
225 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
226 cout<<"1.k = "<<k<<endl;
228 IsQPunc=IsQPunctual(L,U1,GeomAbs_IsoU,0.,Tol);
234 myOsculSurf1->Append(L);
236 ClearOsculFlags(); //myAlong.SetValue(3,Standard_False);
237 if (myAlong(4) && OsculSurf )
239 S = InitSurf; k=0; IsQPunc=Standard_True;
240 UKnot=InitSurf->NbUKnots()-1;
244 OsculSurf = BuildOsculatingSurface(U2,UKnot,VKnot,S,L);
245 if(!OsculSurf) break;
247 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
248 cout<<"2.k = "<<k<<endl;
250 IsQPunc=IsQPunctual(L,U2,GeomAbs_IsoU,0.,Tol);
257 myOsculSurf2->Append(L);
264 S = InitSurf; k=0; IsQPunc=Standard_True;
265 UKnot=InitSurf->NbUKnots()-1;
269 OsculSurf = BuildOsculatingSurface(U2,UKnot,VKnot,S,L);
270 if(!OsculSurf) break;
272 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
273 cout<<"2.k = "<<k<<endl;
275 IsQPunc=IsQPunctual(L,U2,GeomAbs_IsoU,0.,Tol);
282 myOsculSurf2->Append(L);
286 ClearOsculFlags(); //myAlong.SetValue(4,Standard_False);
301 //=======================================================================
302 //function : BasisSurface
304 //=======================================================================
306 Handle(Geom_Surface) Geom_OsculatingSurface::BasisSurface() const
311 //=======================================================================
312 //function : Tolerance
314 //=======================================================================
316 Standard_Real Geom_OsculatingSurface::Tolerance() const
321 //=======================================================================
322 //function : UOscSurf
324 //=======================================================================
326 Standard_Boolean Geom_OsculatingSurface::UOscSurf
327 (const Standard_Real U,
328 const Standard_Real V,
330 Handle(Geom_BSplineSurface)& L) const
332 Standard_Boolean along = Standard_False;
333 if (myAlong(1) || myAlong(2))
335 Standard_Integer NU = 1, NV = 1;
336 Standard_Real u1,u2,v1,v2;
338 myBasisSurf->Bounds(u1,u2,v1,v2);
339 Standard_Integer NbUK,NbVK;
340 Standard_Boolean isToSkipSecond = Standard_False;
341 if (myBasisSurf->IsKind(STANDARD_TYPE(Geom_BSplineSurface)))
343 Handle(Geom_BSplineSurface) BSur =
344 *((Handle(Geom_BSplineSurface)*)& myBasisSurf);
345 NbUK = BSur->NbUKnots();
346 NbVK = BSur->NbVKnots();
347 TColStd_Array1OfReal UKnots(1,NbUK);
348 TColStd_Array1OfReal VKnots(1,NbVK);
349 BSur->UKnots(UKnots);
350 BSur->VKnots(VKnots);
351 BSplCLib::Hunt(UKnots,U,NU);
352 BSplCLib::Hunt(VKnots,V,NV);
354 if (NU >= NbUK) NU=NbUK-1;
355 if (NbVK==2 && NV==1)
356 // Need to find the closest end
357 if (VKnots(NbVK)-V > V-VKnots(1))
358 isToSkipSecond = Standard_True;
360 else {NU = 1; NV = 1 ; NbVK = 2 ;}
362 if (myAlong(1) && NV == 1)
364 L = *((Handle(Geom_BSplineSurface)*)& myOsculSurf1->Value(NU));
365 along = Standard_True;
367 if (myAlong(2) && (NV == NbVK-1) && !isToSkipSecond)
369 // t means that derivative vector of osculating surface is opposite
370 // to the original. This happens when (v-t)^k is negative, i.e.
371 // difference between degrees (k) is odd and t is the last parameter
372 if (myKdeg->Value(NU)%2) t = Standard_True;
373 L = *((Handle(Geom_BSplineSurface)*)& myOsculSurf2->Value(NU));
374 along = Standard_True;
380 //=======================================================================
381 //function : VOscSurf
383 //=======================================================================
385 Standard_Boolean Geom_OsculatingSurface::VOscSurf
386 (const Standard_Real U,
387 const Standard_Real V,
389 Handle(Geom_BSplineSurface)& L) const
391 Standard_Boolean along = Standard_False;
392 if (myAlong(3) || myAlong(4))
394 Standard_Integer NU = 1, NV = 1;
395 Standard_Real u1,u2,v1,v2;
397 myBasisSurf->Bounds(u1,u2,v1,v2);
398 Standard_Integer NbUK,NbVK;
399 Standard_Boolean isToSkipSecond = Standard_False;
400 if (myBasisSurf->IsKind(STANDARD_TYPE(Geom_BSplineSurface)))
402 Handle(Geom_BSplineSurface) BSur =
403 *((Handle(Geom_BSplineSurface)*)& myBasisSurf);
404 NbUK = BSur->NbUKnots();
405 NbVK = BSur->NbVKnots();
406 TColStd_Array1OfReal UKnots(1,NbUK);
407 TColStd_Array1OfReal VKnots(1,NbVK);
408 BSur->UKnots(UKnots);
409 BSur->VKnots(VKnots);
410 BSplCLib::Hunt(UKnots,U,NU);
411 BSplCLib::Hunt(VKnots,V,NV);
413 if (NV >= NbVK) NV=NbVK-1;
414 if (NbUK==2 && NU==1)
415 // Need to find the closest end
416 if (UKnots(NbUK)-U > U-UKnots(1))
417 isToSkipSecond = Standard_True;
419 else {NU = 1; NV = 1 ; NbUK = 2;}
421 if (myAlong(3) && NU == 1)
423 L = *((Handle(Geom_BSplineSurface)*)& myOsculSurf1->Value(NV));
424 along = Standard_True;
426 if (myAlong(4) && (NU == NbUK-1) && !isToSkipSecond)
428 if (myKdeg->Value(NV)%2) t = Standard_True;
429 L = *((Handle(Geom_BSplineSurface)*)& myOsculSurf2->Value(NV));
430 along = Standard_True;
436 //=======================================================================
437 //function : BuildOsculatingSurface
439 //=======================================================================
441 Standard_Boolean Geom_OsculatingSurface::BuildOsculatingSurface
442 (const Standard_Real Param,
443 const Standard_Integer SUKnot,
444 const Standard_Integer SVKnot,
445 const Handle(Geom_BSplineSurface)& BS,
446 Handle(Geom_BSplineSurface)& BSpl) const
448 Standard_Integer i, j;
449 Standard_Boolean OsculSurf=Standard_True;
450 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
451 cout<<"t = "<<Param<<endl;
452 cout<<"======================================"<<endl<<endl;
456 Standard_Integer MinDegree,
458 Standard_Real udeg, vdeg;
459 udeg = BS->UDegree();
460 vdeg = BS->VDegree();
461 if( (IsAlongU() && vdeg <=1) || (IsAlongV() && udeg <=1))
463 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
464 cout<<" surface osculatrice nulle "<<endl;
466 //Standard_ConstructionError::Raise("Geom_OsculatingSurface");
467 OsculSurf=Standard_False;
471 MinDegree = (Standard_Integer ) Min(udeg,vdeg) ;
472 MaxDegree = (Standard_Integer ) Max(udeg,vdeg) ;
474 TColgp_Array2OfPnt cachepoles(1, MaxDegree + 1, 1, MinDegree + 1);
477 // for polynomial grid
478 Standard_Integer MaxUDegree, MaxVDegree;
479 Standard_Integer UContinuity, VContinuity;
481 Handle(TColStd_HArray2OfInteger) NumCoeffPerSurface =
482 new TColStd_HArray2OfInteger(1, 1, 1, 2);
483 Handle(TColStd_HArray1OfReal) PolynomialUIntervals =
484 new TColStd_HArray1OfReal(1, 2);
485 Handle(TColStd_HArray1OfReal) PolynomialVIntervals =
486 new TColStd_HArray1OfReal(1, 2);
487 Handle(TColStd_HArray1OfReal) TrueUIntervals =
488 new TColStd_HArray1OfReal(1, 2);
489 Handle(TColStd_HArray1OfReal) TrueVIntervals =
490 new TColStd_HArray1OfReal(1, 2);
491 MaxUDegree = (Standard_Integer ) udeg;
492 MaxVDegree = (Standard_Integer ) vdeg;
496 PolynomialUIntervals->ChangeValue(i) = i-1;
497 PolynomialVIntervals->ChangeValue(i) = i-1;
498 TrueUIntervals->ChangeValue(i) = BS->UKnot(SUKnot+i-1);
499 TrueVIntervals->ChangeValue(i) = BS->VKnot(SVKnot+i-1);
503 Standard_Integer OscUNumCoeff=0, OscVNumCoeff=0;
506 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
507 cout<<">>>>>>>>>>> AlongU"<<endl;
509 OscUNumCoeff = (Standard_Integer ) udeg + 1;
510 OscVNumCoeff = (Standard_Integer ) vdeg;
514 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
515 cout<<">>>>>>>>>>> AlongV"<<endl;
517 OscUNumCoeff = (Standard_Integer ) udeg;
518 OscVNumCoeff = (Standard_Integer ) vdeg + 1;
520 NumCoeffPerSurface->ChangeValue(1,1) = OscUNumCoeff;
521 NumCoeffPerSurface->ChangeValue(1,2) = OscVNumCoeff;
523 Handle(TColStd_HArray1OfReal) Coefficients = new TColStd_HArray1OfReal(1,
524 NumCoeffPerSurface->Value(1,1)*NumCoeffPerSurface->Value(1,2)*3);
525 // end for polynomial grid
527 // building the cache
528 Standard_Integer ULocalIndex, VLocalIndex;
529 Standard_Real ucacheparameter, vcacheparameter,uspanlength, vspanlength;
530 TColgp_Array2OfPnt NewPoles(1, BS->NbUPoles(), 1, BS->NbVPoles());
531 TColStd_Array1OfReal UFlatKnots(1, BS->NbUPoles() + BS->UDegree() + 1);
532 TColStd_Array1OfReal VFlatKnots(1, BS->NbVPoles() + BS->VDegree() + 1);
534 BS->UKnotSequence(UFlatKnots);
535 BS->VKnotSequence(VFlatKnots);
539 for(j = 1; j <= SVKnot; j++) VLocalIndex += BS->VMultiplicity(j);
540 for(i = 1; i <= SUKnot; i++) ULocalIndex += BS->UMultiplicity(i);
541 ucacheparameter = BS->UKnot(SUKnot);
542 vcacheparameter = BS->VKnot(SVKnot);
543 vspanlength = BS->VKnot(SVKnot + 1) - BS->VKnot(SVKnot);
544 uspanlength = BS->UKnot(SUKnot + 1) - BS->UKnot(SUKnot);
546 // On se ramene toujours a un parametrage tel que localement ce soit l'iso
547 // u=0 ou v=0 qui soit degeneree
549 Standard_Boolean IsVNegative = Param > vcacheparameter + vspanlength/2;
550 Standard_Boolean IsUNegative = Param > ucacheparameter + uspanlength/2;
552 if (IsAlongU() && (Param > vcacheparameter + vspanlength/2))
553 vcacheparameter = vcacheparameter + vspanlength;
554 if (IsAlongV() && (Param > ucacheparameter + uspanlength/2))
555 ucacheparameter = ucacheparameter + uspanlength;
557 BSplSLib::BuildCache(ucacheparameter,
570 BSplSLib::NoWeights(),
572 BSplSLib::NoWeights());
573 Standard_Integer m, n, index;
574 TColgp_Array2OfPnt OscCoeff(1,OscUNumCoeff , 1, OscVNumCoeff);
580 for(n = 1; n <= udeg + 1; n++)
581 for(m = 1; m <= vdeg; m++)
582 OscCoeff(n,m) = cachepoles(n,m+1) ;
586 for(n = 1; n <= udeg + 1; n++)
587 for(m = 1; m <= vdeg; m++)
588 OscCoeff(n,m) = cachepoles(m+1,n) ;
590 if (IsVNegative) PLib::VTrimming(-1,0,OscCoeff,PLib::NoWeights2());
593 for(n = 1; n <= udeg + 1; n++)
594 for(m = 1; m <= vdeg; m++)
596 Coefficients->ChangeValue(index++) = OscCoeff(n,m).X();
597 Coefficients->ChangeValue(index++) = OscCoeff(n,m).Y();
598 Coefficients->ChangeValue(index++) = OscCoeff(n,m).Z();
606 for(n = 1; n <= udeg; n++)
607 for(m = 1; m <= vdeg + 1; m++)
608 OscCoeff(n,m) = cachepoles(n+1,m);
612 for(n = 1; n <= udeg; n++)
613 for(m = 1; m <= vdeg + 1; m++)
614 OscCoeff(n,m) = cachepoles(m,n+1);
616 if (IsUNegative) PLib::UTrimming(-1,0,OscCoeff,PLib::NoWeights2());
618 for(n = 1; n <= udeg; n++)
619 for(m = 1; m <= vdeg + 1; m++)
621 Coefficients->ChangeValue(index++) = OscCoeff(n,m).X();
622 Coefficients->ChangeValue(index++) = OscCoeff(n,m).Y();
623 Coefficients->ChangeValue(index++) = OscCoeff(n,m).Z();
627 if (IsAlongU()) MaxVDegree--;
628 if (IsAlongV()) MaxUDegree--;
632 Convert_GridPolynomialToPoles Data(1,1,
639 PolynomialUIntervals,
640 PolynomialVIntervals,
644 // Handle(Geom_BSplineSurface) BSpl =
645 BSpl =new Geom_BSplineSurface(Data.Poles()->Array2(),
646 Data.UKnots()->Array1(),
647 Data.VKnots()->Array1(),
648 Data.UMultiplicities()->Array1(),
649 Data.VMultiplicities()->Array1(),
653 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
654 cout<<"^====================================^"<<endl<<endl;
662 //=======================================================================
663 //function : IsQPunctual
665 //=======================================================================
667 Standard_Boolean Geom_OsculatingSurface::IsQPunctual
668 (const Handle(Geom_Surface)& S,
669 const Standard_Real Param,
670 const GeomAbs_IsoType IT,
671 const Standard_Real TolMin,
672 const Standard_Real TolMax) const
674 Standard_Real U1=0,U2=0,V1=0,V2=0,T;
675 Standard_Boolean Along = Standard_True;
676 S->Bounds(U1,U2,V1,V2);
679 Standard_Real Step,D1NormMax;
680 if (IT == GeomAbs_IsoV)
684 for (T=U1;T<=U2;T=T+Step)
686 S->D1(T,Param,P,D1U,D1V);
687 D1NormMax=Max(D1NormMax,D1U.Magnitude());
690 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
691 cout << " D1NormMax = " << D1NormMax << endl;
693 if (D1NormMax >TolMax || D1NormMax < TolMin )
694 Along = Standard_False;
700 for (T=V1;T<=V2;T=T+Step)
702 S->D1(Param,T,P,D1U,D1V);
703 D1NormMax=Max(D1NormMax,D1V.Magnitude());
705 #if defined(DEB) && defined(OCCT_DEVELOPMENT)
706 cout << " D1NormMax = " << D1NormMax << endl;
708 if (D1NormMax >TolMax || D1NormMax < TolMin )
709 Along = Standard_False;
716 //=======================================================================
717 //function : HasOscSurf
719 //=======================================================================
721 Standard_Boolean Geom_OsculatingSurface::HasOscSurf() const
723 return (myAlong(1) || myAlong(2) || myAlong(3) || myAlong(4));
726 //=======================================================================
727 //function : IsAlongU
729 //=======================================================================
731 Standard_Boolean Geom_OsculatingSurface::IsAlongU() const
733 return (myAlong(1) || myAlong(2));
735 //=======================================================================
736 //function : IsAlongV
738 //=======================================================================
740 Standard_Boolean Geom_OsculatingSurface::IsAlongV() const
742 return (myAlong(3) || myAlong(4));
746 //=======================================================================
747 //function : IsGetSeqOfL1
749 //=======================================================================
751 const Geom_SequenceOfBSplineSurface& Geom_OsculatingSurface::GetSeqOfL1() const
753 return myOsculSurf1->Sequence();
755 //=======================================================================
756 //function : IsGetSeqOfL2
758 //=======================================================================
760 const Geom_SequenceOfBSplineSurface& Geom_OsculatingSurface::GetSeqOfL2() const
762 return myOsculSurf2->Sequence();
764 //=======================================================================
765 //function : ClearOsculFlags
767 //=======================================================================
769 void Geom_OsculatingSurface::ClearOsculFlags()
771 myAlong.SetValue(1,Standard_False);
772 myAlong.SetValue(2,Standard_False);
773 myAlong.SetValue(3,Standard_False);
774 myAlong.SetValue(4,Standard_False);