Logo Search packages:      
Sourcecode: opencascade version File versions  Download package

ChFi3d_FilBuilder_C2.cxx

// File:    ChFi3d_Builder_5.cxx
// Created: Tue Mar 29 16:13:48 1994
// Author:  Isabelle GRIGNON
//          <isg@zerox>


#include <ChFi3d_FilBuilder.jxx>
#include <ChFi3d.hxx>
#include <ChFi3d_Builder_0.hxx>

#include <StdFail_NotDone.hxx>
#include <Standard_NotImplemented.hxx>
#include <Standard_ErrorHandler.hxx>

#include <math_Vector.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Dir.hxx>
#include <gp_Lin.hxx>
#include <gp_Pln.hxx>
#include <gp_Ax3.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Law_Linear.hxx>
#include <BRepBlend_CSCircular.hxx>
#include <BRepBlend_Line.hxx>
#include <Geom2dConvert.hxx>
#include <BSplCLib.hxx>

#include <Adaptor3d_CurveOnSurface.hxx>
#include <Adaptor3d_HCurveOnSurface.hxx>
#include <BRepLProp_CLProps.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepTopAdaptor_TopolTool.hxx> 
#include <GeomFill_ConstrainedFilling.hxx>
#include <GeomFill_SimpleBound.hxx>

#include <IntPatch_ThePWalkingInterOfThePPIntOfIntersection.hxx>
#include <IntSurf_LineOn2S.hxx>
#include <IntSurf_Transition.hxx>
#include <IntSurf_TypeTrans.hxx>
#include <IntCurveSurface_HInter.hxx>
#include <IntCurveSurface_IntersectionPoint.hxx>

#include <TopoDS.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Face.hxx>
#include <TopOpeBRepDS_DataStructure.hxx>
#include <TopOpeBRepDS_ListOfInterference.hxx>
#include <TopAbs.hxx>
#include <TopAbs_Orientation.hxx>
#include <TopExp.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopOpeBRepDS_HDataStructure.hxx>
#include <ChFiDS_Regul.hxx>
#include <ChFiDS_State.hxx>
#include <ChFiDS_SequenceOfSurfData.hxx>
#include <ChFiDS_SurfData.hxx>
#include <ChFiDS_FaceInterference.hxx>
#include <ChFiDS_ListIteratorOfListOfStripe.hxx>
#include <ChFiDS_Stripe.hxx>
#include <ChFiDS_Spine.hxx>
#include <ChFiDS_FilSpine.hxx>
#include <ChFiDS_HData.hxx>
#include <ChFiDS_CommonPoint.hxx>

#include <ChFiKPart_ComputeData.hxx>

#ifdef DRAW
#include <DrawTrSurf.hxx>
#endif
#ifdef DEB
#include <Geom_TrimmedCurve.hxx>
extern Standard_Boolean ChFi3d_GettraceDRAWSPINE();
extern Standard_Boolean ChFi3d_GetcontextFORCEFILLING();
#include <OSD_Chronometer.hxx>

extern Standard_Real  t_t2cornerinit ,t_perf2cornerbyinter,t_chfikpartcompdata,
                     t_cheminement,t_remplissage,t_t2cornerDS;
extern void ChFi3d_InitChron(OSD_Chronometer& ch);
extern void ChFi3d_ResultChron(OSD_Chronometer & ch,Standard_Real& time);
#endif

//=======================================================================
//function : ToricRotule
//purpose  : Teste si on est dans un cas particulier de rotule torique.
//           Il faut trois plans avec deux conges incidents constants
//           de meme rayon et la troisieme face perpendiculaire aux 
//           deux autres.
//=======================================================================

static Standard_Boolean ToricRotule(const BRepAdaptor_Surface& fac,
                            const BRepAdaptor_Surface& s1,
                            const BRepAdaptor_Surface& s2,
                            const Handle(ChFiDS_Stripe)& c1,
                            const Handle(ChFiDS_Stripe)& c2)

{
  Standard_Real tolesp = 1.e-7;

  Handle(ChFiDS_FilSpine) sp1=Handle(ChFiDS_FilSpine)::DownCast(c1->Spine()); 
  Handle(ChFiDS_FilSpine) sp2=Handle(ChFiDS_FilSpine)::DownCast(c2->Spine()); 
  if(sp1.IsNull() || sp2.IsNull()) return Standard_False;
  if (!sp1->IsConstant() || !sp2->IsConstant()) 
    return Standard_False;
  if ((fac.GetType() != GeomAbs_Plane) ||
      (s1.GetType() != GeomAbs_Plane) ||
      (s2.GetType() != GeomAbs_Plane)) return Standard_False;
  gp_Dir df = fac.Plane().Position().Direction();
  gp_Dir ds1 = s1.Plane().Position().Direction();
  gp_Dir ds2 = s2.Plane().Position().Direction();
  if ( Abs(df.Dot(ds1)) >= tolesp || Abs(df.Dot(ds2)) >= tolesp ) 
    return Standard_False;
  Standard_Real r1 = sp1->Radius();
  Standard_Real r2 = sp2->Radius();
  if(Abs(r1 - r2) >= tolesp) return Standard_False;
  return Standard_True;
}

static void RemoveSD(Handle(ChFiDS_Stripe)& Stripe,
                  const Standard_Integer num1,
                      const Standard_Integer num2 )
{
  ChFiDS_SequenceOfSurfData& Seq = 
    Stripe->ChangeSetOfSurfData()->ChangeSequence();
  if(Seq.IsEmpty()) return;
  if (num1==num2) 
    Seq.Remove(num1);
  else
    Seq.Remove(num1,num2);
}


//=======================================================================
//function : PerformTwoCorner
//purpose  : 
//=======================================================================

void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
{
#ifdef DEB 
  OSD_Chronometer ch;
  ChFi3d_InitChron(ch); // init perf initialisation 
#endif 
  
  done = 0;
  const TopoDS_Vertex& Vtx = myVDataMap.FindKey(Index);
  TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
  ChFiDS_ListIteratorOfListOfStripe It;
  It.Initialize(myVDataMap(Index));
  Handle(ChFiDS_Stripe)  st1,st2;
  Standard_Integer Sens1,Sens2;
  Standard_Integer Isd1,Isd2,i1,i2;
  Handle(ChFiDS_SurfData) sd1,sd2;
  ChFiDS_SequenceOfSurfData SeqFil1,SeqFil2;
  Handle(Geom_Surface) surf1,surf2;
  Standard_Boolean  OkinterCC,Okvisavis,SameSide;
  Standard_Integer IFaCo1,IFaCo2;
  Standard_Real UIntPC1,UIntPC2;
  TopoDS_Face FaCo;
  TopoDS_Edge E1,E2,E;
  TopoDS_Vertex V1,V2;
//  gp_Pnt P1,P2;
  Standard_Integer nbsurf1,nbsurf2,deb1,fin1,deb2,fin2;
  Standard_Real parE1,parE2;
  //On extrait les informations necessaires sur les conges 
  //------------------------------------------------------
  
  //le premier
  //----------
 
  st1 = It.Value(); 
  Isd1 = ChFi3d_IndexOfSurfData(Vtx,st1,Sens1);
  
  
  //le deuxieme
  //----------
  It.Next();
  st2 = It.Value();
  if(st2 == st1) {
    Sens2 = -1;
    Isd2 = st2->SetOfSurfData()->Length();
  }
  else{ Isd2 = ChFi3d_IndexOfSurfData(Vtx,st2,Sens2); }
  
  // Si les deux aretes a arrondir  sont tangentes on appelle GeomPlate

  if (Sens1==1)  E1= st1->Spine()->Edges(1);
  else E1= st1->Spine()->Edges( st1->Spine()->NbEdges());
  
  if (Sens2==1)  E2= st2->Spine()->Edges(1);
  else E2= st2->Spine()->Edges( st2->Spine()->NbEdges());
  
  BRepAdaptor_Curve BCurv1(E1);
  BRepAdaptor_Curve BCurv2(E2);
  parE1=BRep_Tool::Parameter(Vtx,E1);
  parE2=BRep_Tool::Parameter(Vtx,E2);
  BRepLProp_CLProps CL1(BCurv1,parE1 , 1, 1.e-4);
  BRepLProp_CLProps CL2(BCurv2,parE2 , 1, 1.e-4);
  gp_Dir dir1,dir2 ;
  CL1.Tangent(dir1);
  CL2.Tangent(dir2);
  if (Sens1==-1)  dir1.Reverse();
  if (Sens2==-1)  dir2.Reverse();
  Standard_Real ang1;
  ang1=Abs(dir1.Angle(dir2));
  if (ang1<PI/180.) {
    PerformMoreThreeCorner(Index,2);
    done=1;
    return;
  }

  OkinterCC = ChFi3d_IsInFront(DStr,st1,st2,Isd1,Isd2,Sens1,Sens2,
                         UIntPC1,UIntPC2,FaCo,SameSide,
                         IFaCo1,IFaCo2,Okvisavis,Vtx,Standard_True);

  Standard_Boolean trouve=Standard_False;  
  if (!Okvisavis) {

  
// on ne se limite plus aux premieres ou aux dernieres surfdata 
// pour rechercher celles qui son en vis a vis
    nbsurf1=st1->SetOfSurfData()->Length();
    nbsurf2=st2->SetOfSurfData()->Length();
    deb1=1; 
    deb2=1;
    fin1=1;
    fin2=1;
    if (nbsurf1!=1) {
      if (Sens1==1) {
      deb1=1;
      fin1=2;
      }
      else  {
      deb1=nbsurf1-1;
      fin1=nbsurf1;
      }
    }
    if (nbsurf2!=1) {
      if (Sens2==1 ) {
      deb2=1;
      fin2=2;
      }
      else {
      deb2=nbsurf2-1;
      fin2=nbsurf2;
      }
    }
  
    for (i1=deb1;i1<=fin1 &&!trouve;i1++) {
      Isd1=i1;
      for (i2=deb2;i2<=fin2 &&!trouve;i2++) {
      Isd2=i2;
 
        OkinterCC = ChFi3d_IsInFront(DStr,st1,st2,Isd1,Isd2,Sens1,Sens2,
                         UIntPC1,UIntPC2,FaCo,SameSide,
                         IFaCo1,IFaCo2,Okvisavis,Vtx,Standard_True);
        trouve=Okvisavis;
      }
    } 
    if (!trouve){
      PerformMoreThreeCorner(Index,2);
      done=1;
      return;
    }
    else {
      if (Sens1==1 && Isd1!=1) RemoveSD(st1,1,1);
      if (Sens1!=1 && Isd1!=nbsurf1) RemoveSD(st1,fin1,fin1);
      if (Sens2==1 && Isd2!=1) RemoveSD(st2,1,1);
      if (Sens2!=1 && Isd2!=nbsurf2) RemoveSD(st2,fin2,fin2);

    }
    Isd1=ChFi3d_IndexOfSurfData(Vtx,st1,Sens1);
    Isd2=ChFi3d_IndexOfSurfData(Vtx,st2,Sens2);
  }
   // StdFail_NotDone::Raise("TwoCorner : pas de face commune");
  Standard_Integer IFaArc1 = 3-IFaCo1, IFaArc2 = 3-IFaCo2;
  SeqFil1 = st1->ChangeSetOfSurfData()->ChangeSequence();
  SeqFil2 = st2->ChangeSetOfSurfData()->ChangeSequence();
  sd1 = SeqFil1.ChangeValue(Isd1);
  surf1 = DStr.Surface(sd1->Surf()).Surface();
  sd2 = SeqFil2.ChangeValue(Isd2);
  surf2 = DStr.Surface(sd2->Surf()).Surface();
  TopAbs_Orientation OFaCo = FaCo.Orientation(); 
  // On analyse les concavites et on recherche la face en vis a vis 
  // et l intersection  eventuelle des 2 pcurves sur cette face.
  
  ChFiDS_State Stat1,Stat2;
  Standard_Boolean isfirst1 = (Sens1 == 1);
  Standard_Boolean isfirst2 = (Sens2 == 1);
  Stat1 = st1->Spine()->Status(isfirst1);
  Stat2 = st2->Spine()->Status(isfirst2);
  Standard_Boolean c1biseau = (Stat1 == ChFiDS_AllSame); 
  Standard_Boolean c1rotule = (Stat1 == ChFiDS_OnSame && Stat2 == ChFiDS_OnSame);
  
  // On verifie que les conges ont bien un commonpoint 
  // sur un arc commun. 
  // Cet edge est le pivot du biseau ou de la rotule.
  
  ChFiDS_CommonPoint& CP1 = sd1->ChangeVertex(isfirst1,IFaArc1);
  ChFiDS_CommonPoint& CP2 = sd2->ChangeVertex(isfirst2,IFaArc2);
  
  Standard_Boolean resetcp1 = 0;
  Standard_Boolean resetcp2 = 0;
  
  TopoDS_Edge pivot;
  Standard_Boolean yapiv = Standard_False;
  if(CP1.IsOnArc()) pivot = CP1.Arc();
  else {
    PerformMoreThreeCorner(Index,2);
    done=1;
    return;
  }
  if(CP1.IsOnArc()&& CP2.IsOnArc()){
    yapiv = (pivot.IsSame(CP2.Arc()));
  }
  Handle(BRepAdaptor_HCurve) Hpivot;
#ifndef DEB
  Standard_Boolean sameparam = Standard_False;
  Standard_Real parCP1 = 0., parCP2 = 0.;
#else
  Standard_Boolean sameparam;
  Standard_Real parCP1, parCP2;
#endif
  if(yapiv) {
    Hpivot = new BRepAdaptor_HCurve(pivot);
    parCP1 = CP1.ParameterOnArc();
    parCP2 = CP2.ParameterOnArc();
    gp_Pnt tst1 = Hpivot->Value(parCP1);
    gp_Pnt tst2 = Hpivot->Value(parCP2);
    sameparam = tst1.Distance(tst2) <= tolesp;
  }
  Handle(BRepAdaptor_HSurface) HFaCo = new BRepAdaptor_HSurface();
  Handle(BRepAdaptor_HSurface) HFaPiv;
  Handle(BRepAdaptor_HSurface) HBRS1 = new BRepAdaptor_HSurface();
  Handle(BRepAdaptor_HSurface) HBRS2 = new BRepAdaptor_HSurface();
  
  BRepAdaptor_Surface& BRS1 = HBRS1->ChangeSurface();
  BRepAdaptor_Surface& BRS2 = HBRS2->ChangeSurface();
  BRepAdaptor_Surface& BRFaCo = HFaCo->ChangeSurface();
  BRFaCo.Initialize(FaCo);
  
  TopoDS_Face FF1,FF2,F,FaPiv;
#ifndef DEB
  TopAbs_Orientation pctrans = TopAbs_FORWARD ;
#else
  TopAbs_Orientation pctrans;
#endif
  Handle(Geom2d_BSplineCurve) PCurveOnPiv;
  FF1 = TopoDS::Face(DStr.Shape(sd1->Index(IFaArc1)));
  FF2 = TopoDS::Face(DStr.Shape(sd2->Index(IFaArc2)));
  if (FF1.IsNull()||FF2.IsNull()) 
  {PerformMoreThreeCorner(Index,2);
   done=1;
   return;
  }
  BRS1.Initialize(FF1);
  BRS2.Initialize(FF2);
  
  if(yapiv ) {
    TopTools_ListIteratorOfListOfShape Kt;
    Standard_Boolean ok1 = Standard_False, ok2 = Standard_False;
    for (Kt.Initialize(myEFMap(pivot)); Kt.More(); Kt.Next()){
      F = TopoDS::Face(Kt.Value());
      if(!ok1 && FF1.IsSame(F)){
      ok1 = Standard_True;
      }
      if(!ok2 && FF2.IsSame(F)){
      ok2 = Standard_True;
      }
    }
    if(!ok1 || !ok2){
      //On est dans un contexte merdique
      PerformMoreThreeCorner(Index,2);
      done=1;
      return;
    }
  }
  
#ifdef DEB  
  ChFi3d_ResultChron(ch ,t_t2cornerinit);//result perf initialisation 
#endif 
  
  //biseau
  //------
  ChFiDS_CommonPoint cp11,cp12,cp21,cp22;
  ChFiDS_FaceInterference intf11,intf12,intf21,intf22;

  if(c1biseau){
#ifdef DEB   
    ChFi3d_InitChron(ch); // init perf PerformTwoCornerbyInter
#endif 
    
    done = PerformTwoCornerbyInter(Index);
    
#ifdef DEB 
    ChFi3d_ResultChron(ch , t_perf2cornerbyinter); // result perf  PerformTwoCornerbyInter
#endif 
   
    if (!done){
      PerformMoreThreeCorner(Index,2);
      done=1;
      return;
    }
  } 
  else if(c1rotule){//on sauve.
    cp11 = sd1->Vertex(isfirst1,1);
    cp12 = sd1->Vertex(isfirst1,2);
    cp21 = sd2->Vertex(isfirst2,1);
    cp22 = sd2->Vertex(isfirst2,2);
    intf11 = sd1->InterferenceOnS1();
    intf12 = sd1->InterferenceOnS2();
    intf21 = sd2->InterferenceOnS1();
    intf22 = sd2->InterferenceOnS2();
#ifdef DEB   
    ChFi3d_InitChron(ch); // init perf PerformTwoCornerbyInter
#endif 
      
    done = PerformTwoCornerbyInter(Index);
      
#ifdef DEB 
      ChFi3d_ResultChron(ch , t_perf2cornerbyinter); // result perf  PerformTwoCornerbyInter
#endif 
    if (!done) {
      //on restore
      sd1->ChangeVertex(isfirst1,1) = cp11;
      sd1->ChangeVertex(isfirst1,2) = cp12;
      sd2->ChangeVertex(isfirst2,1) = cp21;
      sd2->ChangeVertex(isfirst2,2) = cp22;
      sd1->ChangeInterferenceOnS1() = intf11;
      sd1->ChangeInterferenceOnS2() = intf12;
      sd2->ChangeInterferenceOnS1() = intf21;
      sd2->ChangeInterferenceOnS2() = intf22;
      done = 0;
    }
  }
  
  if(!c1biseau && !done){
    //on cree une nouvelle cornerdata
    //-------------------------------
    Handle(ChFiDS_Stripe) corner = new ChFiDS_Stripe();
    Handle(ChFiDS_HData)& cornerset = corner->ChangeSetOfSurfData();
    cornerset = new ChFiDS_HData();
    Handle(ChFiDS_SurfData) coin = new ChFiDS_SurfData();
    cornerset->Append(coin);
    
    if (SameSide) {
      if(ToricRotule(BRFaCo,BRS1,BRS2,st1,st2)){
      // Construction directe.
      // ---------------------
      
      //un petit coup de NextSide, leger....
      //------------------------------------
      Standard_Integer bid;
      TopAbs_Orientation ori = OFaCo;
      TopAbs_Orientation oriS = st1->Orientation(IFaCo1);
      TopAbs_Orientation OFF1 = FF1.Orientation(); 
      TopAbs_Orientation oriSFF1 = st1->Orientation(IFaArc1);
      bid = 1;
      bid = ChFi3d::NextSide(ori,OFF1,oriS,oriSFF1,bid);
      TopAbs_Orientation op1,op2;
      if(yapiv) bid = ChFi3d::ConcaveSide(BRS1,BRS2,pivot,op1,op2);
      op1 = TopAbs::Reverse(op1);
      op2 = TopAbs::Reverse(op2);
#ifdef DEB  
      ChFi3d_InitChron(ch);// init perf ChFiKPart_ComputeData 
#endif 
      Standard_Real radius = 
        Handle(ChFiDS_FilSpine)::DownCast(st1->Spine())->Radius();
      done = ChFiKPart_ComputeData::ComputeCorner(DStr,coin,HFaCo,HBRS1,HBRS2,
                                        OFaCo,ori,op1,op2,radius);
#ifdef DEB 
      ChFi3d_ResultChron(ch , t_chfikpartcompdata);//result perf ChFiKPart_ComputeData 
#endif 
      }
      else {
      // Construction par remplissage
      // ----------------------------
      Standard_Real  uPCArc1,  uPCArc2;
      gp_Pnt2d p2da1,p2df1,p2da2,p2df2,p2dfac1,p2dfac2;
      gp_Vec2d v2dfac1,v2dfac2;
      Handle(GeomFill_Boundary) B1,B2,Bpiv,Bfac;
      uPCArc1 = sd1->Interference(IFaArc1).Parameter(isfirst1);
      p2da1 = sd1->Interference(IFaArc1).PCurveOnSurf()->Value(uPCArc1);
      p2df1 = sd1->Interference(IFaCo1).PCurveOnSurf()->Value(uPCArc1);
      sd1->Interference(IFaCo1).PCurveOnFace()->D1(uPCArc1,p2dfac1,v2dfac1);
      uPCArc2 = sd2->Interference(IFaArc2).Parameter(isfirst2);
      p2da2 = sd2->Interference(IFaArc2).PCurveOnSurf()->Value(uPCArc2);
      p2df2 = sd2->Interference(IFaCo2).PCurveOnSurf()->Value(uPCArc2);
      sd2->Interference(IFaCo2).PCurveOnFace()->D1(uPCArc2,p2dfac2,v2dfac2);
#ifdef DEB 
      ChFi3d_InitChron(ch ); // init perf remplissage 
#endif 
      B1 = ChFi3d_mkbound(surf1,p2df1,p2da1,tolesp,2.e-4);
      B2 = ChFi3d_mkbound(surf2,p2df2,p2da2,tolesp,2.e-4);
      Handle(Geom2d_Curve) PCurveOnFace;
      Bfac = ChFi3d_mkbound(HFaCo,PCurveOnFace,Sens1,p2dfac1,v2dfac1,
                        Sens2,p2dfac2,v2dfac2,tolesp,2.e-4);
      GeomFill_ConstrainedFilling fil(8,20);
      if(sameparam) {
        fil.Init(Bfac,B2,B1,1);
      }
      else {
        Handle(Adaptor3d_HCurve) HPivTrim = Hpivot->ChangeCurve().
          Trim(Min(parCP1,parCP2),Max(parCP1,parCP2),tolesp);
        Bpiv = new GeomFill_SimpleBound(HPivTrim,tolesp,2.e-4);
        fil.Init(Bfac,B2,Bpiv,B1,1);
        BRepAdaptor_Curve2d pcpivot;
        gp_Vec dArc,dcf;
        gp_Pnt bidon;
        Hpivot->D1(parCP1,bidon,dArc);
        Standard_Real fb1,lb1;
        B1->Bounds(fb1,lb1);
        B1->D1(lb1,bidon,dcf);
        Standard_Boolean pivotverslebas = dArc.Dot(dcf) <= 0.; 
        Standard_Boolean pcfalenvers = (parCP1 > parCP2);
        if((pivotverslebas && !pcfalenvers)||
           (!pivotverslebas && pcfalenvers)) {
          FaPiv = FF2;
          HFaPiv = HBRS2;
          resetcp2 = 1;
        }
        else {
          FaPiv = FF1;
          HFaPiv = HBRS1;
          resetcp1 = 1;
        }
        FaPiv.Orientation(TopAbs_FORWARD);
        pcpivot.Initialize(pivot,FaPiv);
        TopExp_Explorer Expl;
        for(Expl.Init(FaPiv,TopAbs_EDGE); Expl.More(); Expl.Next()){
          if(Expl.Current().IsSame(pivot)) {
            pctrans = Expl.Current().Orientation();
            break;
          }
        }
        if(pcpivot.GetType() != GeomAbs_BSplineCurve){
          Handle(Geom2d_TrimmedCurve) 
            trc = new Geom2d_TrimmedCurve(pcpivot.Curve(),
                                  Min(parCP1,parCP2),
                                  Max(parCP1,parCP2));
          PCurveOnPiv = Geom2dConvert::CurveToBSplineCurve(trc);
        }
        else {
          PCurveOnPiv = Geom2dConvert::SplitBSplineCurve
            (Handle(Geom2d_BSplineCurve)::DownCast(pcpivot.Curve()),
             Min(parCP1,parCP2),Max(parCP1,parCP2),tol2d);
        }
        TColStd_Array1OfReal kk(1,PCurveOnPiv->NbKnots());
        PCurveOnPiv->Knots(kk);
        BSplCLib::Reparametrize(0.,1.,kk);
        PCurveOnPiv->SetKnots(kk);
        if(pcfalenvers) {
          PCurveOnPiv->Reverse();
          pctrans = TopAbs::Reverse(pctrans);
        }
      }
      Handle(Geom_Surface) Surfcoin = fil.Surface();
      done = CompleteData(coin,Surfcoin,
                      HFaCo,PCurveOnFace,
                      HFaPiv,PCurveOnPiv,OFaCo,1,
                      0,0,0,0);
#ifdef DEB 
      ChFi3d_ResultChron(ch , t_remplissage);// result perf remplissage 
#endif 
      }
#ifdef DEB   
      ChFi3d_InitChron(ch); // init perf mise a jour DS
#endif 
      if (done){
      // Mise a jour des 3 CornerData et de la DS
      // ----------------------------------------
      if(resetcp1){
        gp_Pnt pjyl = CP1.Point();
        Standard_Real tolsav = CP1.Tolerance();
        CP1.Reset();
        CP1.SetPoint(pjyl);
        CP1.SetTolerance(tolsav);
      }
      else if(resetcp2){
        gp_Pnt pjyl = CP2.Point();
        Standard_Real tolsav = CP2.Tolerance();
        CP2.Reset();
        CP2.SetPoint(pjyl);
        CP2.SetTolerance(tolsav);
      }
      Standard_Real P1deb,P2deb,P1fin,P2fin;
      Standard_Integer If1,If2,Il1,Il2,Icf,Icl;
      const ChFiDS_CommonPoint& Pf1 = coin->VertexFirstOnS1();
      ChFiDS_CommonPoint& Pf2 = coin->ChangeVertexFirstOnS2();
      const ChFiDS_CommonPoint& Pl1 = coin->VertexLastOnS1();
      ChFiDS_CommonPoint& Pl2 = coin->ChangeVertexLastOnS2();
      Pf2 = CP1;
      Pl2 = CP2;
      
      // le coin pour commencer,
      // -----------------------
      ChFiDS_Regul regdeb, regfin;
      If1 = ChFi3d_IndexPointInDS(Pf1,DStr);
      If2 = ChFi3d_IndexPointInDS(Pf2,DStr);
      Il1 = ChFi3d_IndexPointInDS(Pl1,DStr);
      if(sameparam) Il2 = If2;
      else Il2 = ChFi3d_IndexPointInDS(Pl2,DStr);
      
      gp_Pnt2d pp1,pp2;
      pp1 = coin->InterferenceOnS1().PCurveOnSurf()->
        Value(coin->InterferenceOnS1().FirstParameter());
      pp2 = coin->InterferenceOnS2().PCurveOnSurf()->
        Value(coin->InterferenceOnS2().FirstParameter());
      Handle(Geom_Curve) C3d;
      Standard_Real tolreached;
      ChFi3d_ComputeArete(Pf1,pp1,Pf2,pp2,
                      DStr.Surface(coin->Surf()).Surface(),C3d,
                      corner->ChangeFirstPCurve(),P1deb,P2deb,
                      tolesp,tol2d,tolreached,0);
      Standard_Real par1 = sd1->Interference(IFaArc1).Parameter(isfirst1);
      pp1 = sd1->Interference(IFaCo1).PCurveOnSurf()->Value(par1);
      pp2 = sd1->Interference(IFaArc1).PCurveOnSurf()->Value(par1);
      Standard_Real tolr1;
      ChFi3d_ComputePCurv(C3d,pp1,pp2,st1->ChangePCurve(isfirst1),
                      DStr.Surface(sd1->Surf()).Surface(),
                      P1deb,P2deb,tolesp,tolr1);
      tolreached = Max(tolreached,tolr1);
      TopOpeBRepDS_Curve Tcurv1(C3d,tolreached);
      Icf = DStr.AddCurve(Tcurv1);
      regdeb.SetCurve(Icf);
      regdeb.SetS1(coin->Surf(),0);
      regdeb.SetS2(sd1->Surf(),0);
      myRegul.Append(regdeb);
      corner->ChangeFirstCurve(Icf);
      corner->ChangeFirstParameters(P1deb,P2deb);
      corner->ChangeIndexFirstPointOnS1(If1);
      corner->ChangeIndexFirstPointOnS2(If2);
      
      pp1 = coin->InterferenceOnS1().PCurveOnSurf()->
        Value(coin->InterferenceOnS1().LastParameter());
      pp2 = coin->InterferenceOnS2().PCurveOnSurf()->
        Value(coin->InterferenceOnS2().LastParameter());
      ChFi3d_ComputeArete(Pl1,pp1,Pl2,pp2,
                      DStr.Surface(coin->Surf()).Surface(),C3d,
                      corner->ChangeLastPCurve(),P1fin,P2fin,
                      tolesp,tol2d,tolreached,0);
      Standard_Real par2 = sd2->Interference(IFaArc2).Parameter(isfirst2);
      pp1 = sd2->Interference(IFaCo2).PCurveOnSurf()->Value(par2);
      pp2 = sd2->Interference(IFaArc2).PCurveOnSurf()->Value(par2);
      Standard_Real tolr2;
      ChFi3d_ComputePCurv(C3d,pp1,pp2,st2->ChangePCurve(isfirst2),
                      DStr.Surface(sd2->Surf()).Surface(),
                      P1deb,P2deb,tolesp,tolr2);
      tolreached = Max(tolreached,tolr2);
      TopOpeBRepDS_Curve Tcurv2(C3d,tolreached);
      Icl = DStr.AddCurve(Tcurv2);
      regfin.SetCurve(Icl);
      regfin.SetS1(coin->Surf(),0);
      regfin.SetS2(sd2->Surf(),0);
      myRegul.Append(regfin);
      corner->ChangeLastCurve(Icl);
      corner->ChangeLastParameters(P1fin,P2fin);
      corner->ChangeIndexLastPointOnS1(Il1);
      corner->ChangeIndexLastPointOnS2(Il2);
      
      coin->ChangeIndexOfS1(DStr.AddShape(FaCo));
      if(sameparam) coin->ChangeIndexOfS2(0);
      else {
        coin->ChangeIndexOfS2(DStr.AddShape(FaPiv));
        coin->ChangeInterferenceOnS2().SetTransition(pctrans);
      }
      corner->SetSolidIndex(st1->SolidIndex());
      
      // puis la Stripe du debut,
      // ------------------------
      st1->SetCurve(Icf,isfirst1);
      st1->SetIndexPoint(If1,isfirst1,IFaCo1);
      st1->SetIndexPoint(If2,isfirst1,IFaArc1);
      st1->SetParameters(isfirst1,P1deb,P2deb);
      sd1->ChangeVertex(isfirst1,IFaCo1) = Pf1;
      sd1->ChangeVertex(isfirst1,IFaArc1) = Pf2;
      sd1->ChangeInterference(IFaCo1).SetParameter(par1,isfirst1);
      if (IFaCo1 == 2) st1->SetOrientation(TopAbs_REVERSED,isfirst1);
      
      // puis la Stripe de la fin,
      // -------------------------
      st2->SetCurve(Icl,isfirst2);
      st2->SetIndexPoint(Il1,isfirst2,IFaCo2);
      st2->SetIndexPoint(Il2,isfirst2,IFaArc2);
      st2->SetParameters(isfirst2,P1fin,P2fin);
      sd2->ChangeVertex(isfirst2,IFaCo2) = Pl1;
      sd2->ChangeVertex(isfirst2,IFaArc2) = Pl2;
      sd2->ChangeInterference(IFaCo2).SetParameter(par2,isfirst2);
      if (IFaCo2 == 2) st2->SetOrientation(TopAbs_REVERSED,isfirst2);
      }
#ifdef DEB   
      ChFi3d_ResultChron(ch , t_t2cornerDS);// result perf mise a jour DS 
#endif 
    }
    else {
      //ici il faut distinguer celui ondiff
      if(!OkinterCC) {
      Standard_Failure::Raise("TwoCorner : Pas d intersetion pc pc");
      }
      Handle(ChFiDS_Stripe) stsam, stdif;
      Handle(ChFiDS_SurfData) sdsam, sddif;
#ifndef DEB
      Standard_Real uintpcsam = 0., uintpcdif = 0.;
      Standard_Integer ifacosam = 0, ifacodif = 0, ifaopsam = 0, ifaopdif = 0;
      Standard_Boolean isfirstsam = Standard_False, isfirstdif = Standard_False;
#else
      Standard_Real uintpcsam, uintpcdif;
      Standard_Integer ifacosam, ifacodif, ifaopsam, ifaopdif;
      Standard_Boolean isfirstsam, isfirstdif;
#endif
      if(Stat1 == ChFiDS_OnSame && Stat2 == ChFiDS_OnDiff){
      stsam = st1; sdsam = sd1; uintpcsam = UIntPC1; 
      ifacosam = IFaCo1; ifaopsam = IFaArc1; isfirstsam = isfirst1;
      stdif = st2; sddif = sd2; uintpcdif = UIntPC2; 
      ifacodif = IFaCo2; ifaopdif = IFaArc2; isfirstdif = isfirst2;
      }
      else if(Stat1 == ChFiDS_OnDiff && Stat2 == ChFiDS_OnSame){
      stsam = st2; sdsam = sd2; uintpcsam = UIntPC2; 
      ifacosam = IFaCo2; ifaopsam = IFaArc2; isfirstsam = isfirst2;
      stdif = st1; sddif = sd1; uintpcdif = UIntPC1; 
      ifacodif = IFaCo1; ifaopdif = IFaArc1; isfirstdif = isfirst1;
      }
      else {
      Standard_Failure::Raise("TwoCorner : Config inconnue");
      }
      //On verifie que la surface ondiff a un point sur arc du cote oppose
      //a la face commune et que cet arc est connexe a la face d appui 
      //oppose a la face commune de la surface onsame.
      ChFiDS_CommonPoint& cpopdif = sddif->ChangeVertex(isfirstdif,ifaopdif);
      if(!cpopdif.IsOnArc()) {
      Standard_Failure::Raise
        ("TwoCorner : Pas de point sur restriction sur la surface OnDiff");
      }
      const TopoDS_Edge& Arcopdif = cpopdif.Arc();
      const TopoDS_Face& Fopsam = TopoDS::Face(DStr.Shape(sdsam->Index(ifaopsam)));
      TopExp_Explorer ex;
      for(ex.Init(Fopsam,TopAbs_EDGE); ex.More(); ex.Next()){
      if(ex.Current().IsSame(Arcopdif)) {
        break;
      }
      else if(!ex.More()) {
        Standard_Failure::Raise
          ("TwoCorner : Pas de face commune pour boucler le contour");
      }
      }
#ifdef DEB 
      ChFi3d_InitChron(ch ); // init perf remplissage 
#endif 
      Handle(GeomFill_Boundary) Bsam,Bdif,Bfac;
      gp_Pnt2d ppopsam = 
      sdsam->Interference(ifaopsam).PCurveOnSurf()->Value(uintpcsam);
      gp_Pnt2d ppcosam = 
      sdsam->Interference(ifacosam).PCurveOnSurf()->Value(uintpcsam);
      Handle(Geom_Surface) surfsam = DStr.Surface(sdsam->Surf()).Surface();
      Handle(GeomAdaptor_HSurface) Hsurfsam = new GeomAdaptor_HSurface(surfsam);
      Handle(Geom2d_Curve) pcsurfsam;
      Bsam = ChFi3d_mkbound(Hsurfsam,pcsurfsam,ppopsam,ppcosam,tolesp,2.e-4);
      Standard_Real upcopdif = sddif->Interference(ifaopdif).Parameter(isfirstdif);
      gp_Pnt2d ppopdif = 
      sddif->Interference(ifaopdif).PCurveOnSurf()->Value(upcopdif);
      gp_Pnt2d ppcodif = 
      sddif->Interference(ifacodif).PCurveOnSurf()->Value(uintpcdif);
      Handle(Geom_Surface) surfdif = DStr.Surface(sddif->Surf()).Surface();
      Handle(GeomAdaptor_HSurface) Hsurfdif = new GeomAdaptor_HSurface(surfdif);
      Handle(Geom2d_Curve) pcsurfdif;
      Bdif = ChFi3d_mkbound(Hsurfdif,pcsurfdif,ppcodif,ppopdif,tolesp,2.e-4);
      gp_Pnt2d ppfacsam,ppfacdif;
      gp_Pnt PPfacsam,PPfacdif;
      gp_Vec VVfacsam,VVfacdif;
      sdsam->Interference(ifaopsam).PCurveOnFace()->D0(uintpcsam,ppfacsam);
      const Handle(Geom_Curve)& curvopsam = 
      DStr.Curve(sdsam->Interference(ifaopsam).LineIndex()).Curve();
      curvopsam->D1(uintpcsam,PPfacsam,VVfacsam);
      BRepAdaptor_Curve2d PCArcFac(Arcopdif,Fopsam);
      PCArcFac.D0(cpopdif.ParameterOnArc(),ppfacdif);
      BRepAdaptor_Curve CArcFac(Arcopdif);
      CArcFac.D1(cpopdif.ParameterOnArc(),PPfacdif,VVfacdif);
      Handle(BRepAdaptor_HSurface) HBRFopsam = new BRepAdaptor_HSurface();
      BRepAdaptor_Surface& BRFopsam = HBRFopsam->ChangeSurface();
      BRFopsam.Initialize(Fopsam,Standard_False);
      Handle(Geom2d_Curve) pcFopsam = ChFi3d_BuildPCurve(HBRFopsam,
                                           ppfacsam,VVfacsam,
                                           ppfacdif,VVfacdif,1);
      Bfac = ChFi3d_mkbound(HBRFopsam,pcFopsam,tolesp,2.e-4);
      GeomFill_ConstrainedFilling fil(8,20);
      fil.Init(Bsam,Bdif,Bfac,1);
#if 0
      for(Standard_Integer ib = 0; ib < 4; ib++){
      if(ib == 2) continue;
      fil.CheckCoonsAlgPatch(ib);
      fil.CheckTgteField(ib);
      fil.CheckApprox(ib);
      fil.CheckResult(ib);
      }
#endif
      Handle(Geom_Surface) Surfcoin = fil.Surface();
      TopAbs_Orientation Osurfsam = sdsam->Orientation();
      Handle(Geom2d_Curve) pcnul;
      done = CompleteData(coin,Surfcoin,
                    Hsurfsam,pcsurfsam,
                    HBRFopsam,pcnul,Osurfsam,1,
                    0,0,0,0);
#ifdef DEB 
      ChFi3d_ResultChron(ch , t_remplissage);// result perf remplissage 
#endif 
      if(!done) Standard_Failure::Raise("concavites inverses : echec");
#ifdef DEB   
      ChFi3d_InitChron(ch); // init perf mise a jour DS
#endif 
      // Mise a jour des 3 CornerData et de la DS
      // ----------------------------------------
      // le coin pour commencer,
      // -----------------------
      Standard_Real P1deb,P2deb,P1fin,P2fin;
      Standard_Integer If1,If2,Il1,Il2,Icf,Icl;
      const ChFiDS_CommonPoint& Pf1 = coin->VertexFirstOnS1();
      ChFiDS_CommonPoint& Pf2 = coin->ChangeVertexFirstOnS2();
      const ChFiDS_CommonPoint& Pl1 = coin->VertexLastOnS1();
      ChFiDS_CommonPoint& Pl2 = coin->ChangeVertexLastOnS2();
      Pf2 = Pl2 = cpopdif;
      
      ChFiDS_Regul regdeb, regfin;
      If1 = ChFi3d_IndexPointInDS(Pf1,DStr);
      If2 = ChFi3d_IndexPointInDS(Pf2,DStr);
      Il1 = ChFi3d_IndexPointInDS(Pl1,DStr);
      Il2 = If2;
      
      gp_Pnt2d pp1,pp2;
      pp1 = coin->InterferenceOnS1().PCurveOnSurf()->
      Value(coin->InterferenceOnS1().FirstParameter());
      pp2 = coin->InterferenceOnS2().PCurveOnSurf()->
      Value(coin->InterferenceOnS2().FirstParameter());
      Handle(Geom_Curve) C3d;
      Standard_Real tolreached;
      ChFi3d_ComputeArete(Pf1,pp1,Pf2,pp2,
                    DStr.Surface(coin->Surf()).Surface(),C3d,
                    corner->ChangeFirstPCurve(),P1deb,P2deb,
                    tolesp,tol2d,tolreached,0);
      Standard_Real tolr1;
      Handle(GeomAdaptor_HCurve) HC3d = new GeomAdaptor_HCurve(C3d);
      ChFi3d_SameParameter(HC3d,pcFopsam,HBRFopsam,tolesp,tolr1);
      tolreached = Max(tolreached,tolr1);
      TopOpeBRepDS_Curve Tcurv1(C3d,tolreached);
      Icf = DStr.AddCurve(Tcurv1);
      // ici petite veru pour mettre la pcurve on face dans la DS
      TopAbs_Orientation OpcFopsam = sdsam->Interference(ifaopsam).Transition();
      Standard_Integer IFopsam = sdsam->Index(ifaopsam);
      if(isfirstsam) OpcFopsam = TopAbs::Reverse(OpcFopsam);
      Handle(TopOpeBRepDS_SurfaceCurveInterference) 
      interf = ChFi3d_FilCurveInDS(Icf,IFopsam,pcFopsam,OpcFopsam);
      DStr.ChangeShapeInterferences(IFopsam).Append(interf);

      regdeb.SetCurve(Icf);
      regdeb.SetS1(coin->Surf(),0);
      regdeb.SetS2(IFopsam,1);
      myRegul.Append(regdeb);
      corner->ChangeFirstCurve(Icf);
      corner->ChangeFirstParameters(P1deb,P2deb);
      corner->ChangeIndexFirstPointOnS1(If1);
      corner->ChangeIndexFirstPointOnS2(If2);
      
      pp1 = coin->InterferenceOnS1().PCurveOnSurf()->
      Value(coin->InterferenceOnS1().LastParameter());
      pp2 = coin->InterferenceOnS2().PCurveOnSurf()->
      Value(coin->InterferenceOnS2().LastParameter());
      ChFi3d_ComputeArete(Pl1,pp1,Pl2,pp2,
                    DStr.Surface(coin->Surf()).Surface(),C3d,
                    corner->ChangeLastPCurve(),P1fin,P2fin,
                    tolesp,tol2d,tolreached,0);
      Standard_Real tolr2;
      HC3d->ChangeCurve().Load(C3d);
      ChFi3d_SameParameter(HC3d,pcsurfdif,Hsurfdif,tolesp,tolr2);
      tolreached = Max(tolreached,tolr2);
      TopOpeBRepDS_Curve Tcurv2(C3d,tolreached);
      Icl = DStr.AddCurve(Tcurv2);
      regfin.SetCurve(Icl);
      regfin.SetS1(coin->Surf(),0);
      regfin.SetS2(sddif->Surf(),0);
      myRegul.Append(regfin);
      corner->ChangeLastCurve(Icl);
      corner->ChangeLastParameters(P1fin,P2fin);
      corner->ChangeIndexLastPointOnS1(Il1);
      corner->ChangeIndexLastPointOnS2(Il2);
      
      coin->ChangeIndexOfS1(-sdsam->Surf());
      coin->ChangeIndexOfS2(0);

      corner->SetSolidIndex(stsam->SolidIndex());
      
      // puis la Stripe OnSame
      // ---------------------
      const ChFiDS_FaceInterference& intcoin1 = coin->InterferenceOnS1();
      stsam->SetCurve(intcoin1.LineIndex(),isfirstsam);
      stsam->InDS(isfirstsam); // filDS fait deja le boulot depuis le coin.
      stsam->ChangePCurve(isfirstsam) = coin->InterferenceOnS1().PCurveOnFace();
      stsam->SetIndexPoint(If1,isfirstsam,ifaopsam);
      stsam->SetIndexPoint(Il1,isfirstsam,ifacosam);
      stsam->SetParameters(isfirstsam,
                     intcoin1.FirstParameter(),
                     intcoin1.LastParameter());
      sdsam->ChangeVertex(isfirstsam,ifaopsam) = Pf1;
      sdsam->ChangeVertex(isfirstsam,ifacosam) = Pl1;
      sdsam->ChangeInterferenceOnS1().SetParameter(uintpcsam,isfirstsam);
      sdsam->ChangeInterferenceOnS2().SetParameter(uintpcsam,isfirstsam);
      if (ifaopsam == 2) stsam->SetOrientation(TopAbs_REVERSED,isfirstsam);
      
      // puis la Stripe OnDiff
      // ---------------------
      stdif->SetCurve(Icl,isfirstdif);
      stdif->ChangePCurve(isfirstdif) = pcsurfdif;
      stdif->SetIndexPoint(Il2,isfirstdif,ifaopdif);
      stdif->SetIndexPoint(Il1,isfirstdif,ifacodif);
      stdif->SetParameters(isfirstdif,P1fin,P2fin);
      sddif->ChangeVertex(isfirstdif,ifaopdif) = Pl2;
      sddif->ChangeVertex(isfirstdif,ifacodif) = Pl1;
      sddif->ChangeInterference(ifacodif).SetParameter(uintpcdif,isfirstdif);
      if (ifaopdif == 1) stdif->SetOrientation(TopAbs_REVERSED,isfirstdif);
#ifdef DEB   
      ChFi3d_ResultChron(ch , t_t2cornerDS);// result perf mise a jour DS 
#endif 
    }
    if(!myEVIMap.IsBound(Vtx)){
      TColStd_ListOfInteger li;
      myEVIMap.Bind(Vtx,li);
    }
    myEVIMap.ChangeFind(Vtx).Append(coin->Surf());
    myListStripe.Append(corner);
  }
}  


Generated by  Doxygen 1.6.0   Back to index