[occt.git] / src / IGESGeom / IGESGeom_ToolBSplineSurface.cxx

// Created by: CKY / Contract Toubro-Larsen
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

//--------------------------------------------------------------------
//--------------------------------------------------------------------

#include <gp_XYZ.hxx>
#include <IGESData_DirChecker.hxx>
#include <IGESData_Dump.hxx>
#include <IGESData_IGESDumper.hxx>
#include <IGESData_IGESReaderData.hxx>
#include <IGESData_IGESWriter.hxx>
#include <IGESData_ParamCursor.hxx>
#include <IGESData_ParamReader.hxx>
#include <IGESGeom_BSplineSurface.hxx>
#include <IGESGeom_ToolBSplineSurface.hxx>
#include <Interface_Check.hxx>
#include <Interface_CopyTool.hxx>
#include <Interface_EntityIterator.hxx>
#include <Interface_Macros.hxx>
#include <Interface_ShareTool.hxx>
#include <Message_Messenger.hxx>
#include <Message_Msg.hxx>
#include <Standard_DomainError.hxx>
#include <TColgp_HArray2OfXYZ.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray2OfReal.hxx>

// MGE 31/07/98
//=======================================================================
//function : IGESGeom_ToolBSplineSurface
//purpose  : 
//=======================================================================
IGESGeom_ToolBSplineSurface::IGESGeom_ToolBSplineSurface ()
{
}


//=======================================================================
//function : ReadOwnParams
//purpose  : 
//=======================================================================

void IGESGeom_ToolBSplineSurface::ReadOwnParams
  (const Handle(IGESGeom_BSplineSurface)& ent,
   const Handle(IGESData_IGESReaderData)& /* IR */, IGESData_ParamReader& PR) const
{
  // MGE 31/07/98
  // Building of messages
  //========================================
  Message_Msg Msg100("XSTEP_100");
  Message_Msg Msg101("XSTEP_101");
  Message_Msg Msg102("XSTEP_102");
  Message_Msg Msg103("XSTEP_103");
  Message_Msg Msg159("XSTEP_159");
  //========================================

  Standard_Integer I, J;
  Standard_Integer anIndexU, anIndexV, aDegU, aDegV;
  Standard_Boolean aCloseU, aCloseV, aPolynom, aPeriodU, aPeriodV;
  Standard_Real aUmin, aUmax, aVmin = 0., aVmax = 0.;
  Standard_Real tempVal;
  gp_XYZ tempXYZ;
  Handle(TColStd_HArray1OfReal) allKnotsU;
  Handle(TColStd_HArray1OfReal) allKnotsV;
  Handle(TColStd_HArray2OfReal) allWeights;
  Handle(TColgp_HArray2OfXYZ)   allPoles;

  //Standard_Boolean st; //szv#4:S4163:12Mar99 not needed
  Standard_Boolean FlagindexU = PR.ReadInteger(PR.Current(), anIndexU);

  Standard_Boolean FlagindexV = PR.ReadInteger(PR.Current(), anIndexV);

  if (!FlagindexU || !FlagindexV){ 
    Message_Msg Msg97("XSTEP_97");
    PR.SendFail(Msg97);
  }

  Standard_Boolean FlagdegU  =  PR.ReadInteger(PR.Current(), aDegU);

  Standard_Boolean FlagdegV  =  PR.ReadInteger(PR.Current(), aDegV);

  if (!FlagdegU || !FlagdegV){ 
    Message_Msg Msg98("XSTEP_98");
    PR.SendFail(Msg98);
  }
  //szv#4:S4163:12Mar99 `st=` not needed
  PR.ReadBoolean(PR.Current(), Msg100,aCloseU);
  PR.ReadBoolean(PR.Current(), Msg100,aCloseV);
  PR.ReadBoolean(PR.Current(), Msg101, aPolynom);
  PR.ReadBoolean(PR.Current(), Msg102, aPeriodU);
  PR.ReadBoolean(PR.Current(), Msg102, aPeriodV);

/*
  Standard_Boolean FlagindexU =
    PR.ReadInteger(PR.Current(), "Upper Index in U", anIndexU);

  Standard_Boolean FlagindexV =
    PR.ReadInteger(PR.Current(), "Upper Index in V", anIndexV);

  Standard_Boolean FlagdegU  =
    PR.ReadInteger(PR.Current(), "Degree Of First Basis Functions", aDegU);

  Standard_Boolean FlagdegV  =
    PR.ReadInteger(PR.Current(), "Degree Of Second Basis Functions",aDegV);

  st = PR.ReadBoolean(PR.Current(), "Closed/Open flag in U Direction",aCloseU);
  st = PR.ReadBoolean(PR.Current(), "Closed/Open flag in V Direction",aCloseV);
  st = PR.ReadBoolean(PR.Current(), "Polynomial / Rational", aPolynom);
  st = PR.ReadBoolean(PR.Current(), "Periodic flag in U direction", aPeriodU);
  st = PR.ReadBoolean(PR.Current(), "Periodic flag in V direction", aPeriodV);
*/
  if ( FlagdegU && FlagindexU )
    {
//      allKnotsU = new TColStd_HArray1OfReal(-aDegU, anIndexU+1);  done by :
      Standard_Integer tempind = anIndexU+aDegU+2;
      PR.ReadReals(PR.CurrentList(tempind), Msg103, allKnotsU, -aDegU); //szv#4:S4163:12Mar99 `st=` not needed
      //st = PR.ReadReals(PR.CurrentList(tempind), "First knot sequence values", allKnotsU, -aDegU);
    }

  if ( FlagdegV && FlagindexV )
    {
//      allKnotsV = new TColStd_HArray1OfReal(-aDegV, anIndexV+1);  done by :
      Standard_Integer tempind = anIndexV+aDegV+2;
      PR.ReadReals(PR.CurrentList(tempind), Msg103, allKnotsV, -aDegV); //szv#4:S4163:12Mar99 `st=` not needed
      //st = PR.ReadReals(PR.CurrentList(tempind), "Second knot sequence values", allKnotsV, -aDegV);
    }

  if ( FlagindexU && FlagindexV )
    {
      allWeights = new TColStd_HArray2OfReal (0, anIndexU, 0, anIndexV);
      allPoles   = new TColgp_HArray2OfXYZ   (0, anIndexU, 0, anIndexV);

      Standard_Boolean BadWeigth = Standard_False;
      Message_Msg Msg105("XSTEP_105");

      for (J = 0; J <= anIndexV; J ++) {
	for (I = 0; I <= anIndexU; I ++) {
          //st = PR.ReadReal(PR.Current(), Msg104, tempVal); //szv#4:S4163:12Mar99 moved down
          //st = PR.ReadReal(PR.Current(), "Weights", tempVal);
          if (PR.ReadReal(PR.Current(), tempVal)) {
            if(tempVal<Precision::PConfusion()) { // skl for OCC2821 11.06.2003
              BadWeigth = Standard_True;
            }
            allWeights->SetValue(I, J, tempVal);
          }
	  else{
	    Message_Msg Msg104("XSTEP_104");
	    PR.SendFail(Msg104);
	  }
        }
      }
      if(BadWeigth) { // skl for OCC2821 11.06.2003
        for (J = 0; J <= anIndexV; J ++) {
          for (I = 0; I <= anIndexU; I ++) {
            allWeights->SetValue(I, J, 1.);
          }
        }
      }

      for (J = 0; J <= anIndexV; J ++)
	for (I = 0; I <= anIndexU; I ++) {
	  //st = PR.ReadXYZ (PR.CurrentList(1, 3), Msg105, tempXYZ); //szv#4:S4163:12Mar99 moved down
	  //st = PR.ReadXYZ (PR.CurrentList(1, 3), "Control Points", tempXYZ);
	  if (PR.ReadXYZ (PR.CurrentList(1, 3), Msg105, tempXYZ))
	    allPoles->SetValue(I, J, tempXYZ);
	}
    }

  //szv#4:S4163:12Mar99 `st=` not needed
 /* PR.ReadReal(PR.Current(), Msg106, aUmin);
  PR.ReadReal(PR.Current(), Msg107, aUmax);
  PR.ReadReal(PR.Current(), Msg106, aVmin);
  PR.ReadReal(PR.Current(), Msg107, aVmax);
*/
  if (!PR.ReadReal(PR.Current(), aUmin) || !PR.ReadReal(PR.Current(), aVmin)){
    Message_Msg Msg106("XSTEP_106");
    PR.SendFail(Msg106);
  }

  if (!PR.ReadReal(PR.Current(), aUmax) || !PR.ReadReal(PR.Current(), aVmax)){
    Message_Msg Msg107("XSTEP_107");
    PR.SendFail(Msg107);
  }
/*
  st = PR.ReadReal(PR.Current(), "Starting Value For U Direction", aUmin);
  st = PR.ReadReal(PR.Current(), "Ending Value For U Direction", aUmax);
  st = PR.ReadReal(PR.Current(), "Starting Value For V Direction", aVmin);
  st = PR.ReadReal(PR.Current(), "Ending Value For U Direction", aVmax);
*/
//  PROTECTION contre ANSYS 5.3 qui ecrit 3 flottants en plus ...
  Standard_Integer icur = PR.CurrentNumber(), imax = PR.NbParams();
  Standard_Real bid; Standard_Integer pbfin = 0;
  //st = Standard_True; //szv#4:S4163:12Mar99 not needed
  while (imax >= icur) {
    Interface_ParamType pt = PR.ParamType(icur);
    if (pt == Interface_ParamReal) {
      if (!PR.ReadReal (PR.Current(),bid)){
	PR.SendFail(Msg159);
      } //szv#4:S4163:12Mar99 `st=` not needed
      if (pbfin == 0) pbfin = 1;
    }
    else if (pt == Interface_ParamInteger || pt == Interface_ParamVoid) break;
    else pbfin = -1;
    icur ++;
  }
  if (pbfin > 0) PR.SendWarning(Msg159);
  if (pbfin < 0){
    Message_Msg Msg158("XSTEP_158");
    PR.SendFail(Msg158);
  }
  DirChecker(ent).CheckTypeAndForm(PR.CCheck(),ent);
  ent->Init
    (anIndexU, anIndexV, aDegU, aDegV, aCloseU, aCloseV,
     aPolynom, aPeriodU, aPeriodV, allKnotsU, allKnotsV,
     allWeights, allPoles, aUmin, aUmax, aVmin, aVmax);
}


//=======================================================================
//function : WriteOwnParams
//purpose  : 
//=======================================================================

void IGESGeom_ToolBSplineSurface::WriteOwnParams
  (const Handle(IGESGeom_BSplineSurface)& ent, IGESData_IGESWriter& IW)  const
{
  Standard_Integer indU = ent->UpperIndexU();
  Standard_Integer indV = ent->UpperIndexV();
  Standard_Integer degU = ent->DegreeU();
  Standard_Integer degV = ent->DegreeV();
  Standard_Integer I, J;
  IW.Send(indU);
  IW.Send(indV);
  IW.Send(degU);
  IW.Send(degV);
  IW.SendBoolean(ent->IsClosedU());
  IW.SendBoolean(ent->IsClosedV());
  IW.SendBoolean(ent->IsPolynomial());
  IW.SendBoolean(ent->IsPeriodicU());
  IW.SendBoolean(ent->IsPeriodicV());

  for (I = -degU; I <= indU + 1; I ++)
    IW.Send(ent->KnotU(I));

  for (I = -degV; I <= indV + 1; I ++)
    IW.Send(ent->KnotV(I));

  for (J = 0; J <= indV; J ++)
    for (I = 0; I <= indU; I ++)
      IW.Send(ent->Weight(I, J));

  for (J = 0; J <= indV; J ++)
    for (I = 0; I <= indU; I ++)  {
      gp_XYZ tempXYZ = ent->Pole(I, J).XYZ();
      IW.Send(tempXYZ.X());
      IW.Send(tempXYZ.Y());
      IW.Send(tempXYZ.Z());
    }
  IW.Send(ent->UMin());
  IW.Send(ent->UMax());
  IW.Send(ent->VMin());
  IW.Send(ent->VMax());
}


//=======================================================================
//function : OwnShared
//purpose  : 
//=======================================================================

void IGESGeom_ToolBSplineSurface::OwnShared(const Handle(IGESGeom_BSplineSurface)& /* ent */,
                                            Interface_EntityIterator& /* iter */) const
{
}


//=======================================================================
//function : OwnCopy
//purpose  : 
//=======================================================================

void IGESGeom_ToolBSplineSurface::OwnCopy(const Handle(IGESGeom_BSplineSurface)& another,
                                          const Handle(IGESGeom_BSplineSurface)& ent,
                                          Interface_CopyTool& /* TC */) const
{
  Standard_Integer I, J;
  Standard_Integer anIndexU, anIndexV, aDegU, aDegV;
  Standard_Boolean aCloseU, aCloseV, aPolynom;
  Standard_Boolean aPeriodU, aPeriodV;
  Standard_Real aUmin, aUmax, aVmin, aVmax;

  anIndexU = another->UpperIndexU();
  anIndexV = another->UpperIndexV();
  aDegU    = another->DegreeU();
  aDegV    = another->DegreeV();
  aCloseU  = another->IsClosedU();
  aCloseV  = another->IsClosedV();
  aPolynom = another->IsPolynomial();
  aPeriodU = another->IsPeriodicU();
  aPeriodV = another->IsPeriodicV();

  Handle(TColStd_HArray1OfReal) allKnotsU  =
    new TColStd_HArray1OfReal(-aDegU, anIndexU+1);
  Handle(TColStd_HArray1OfReal) allKnotsV  =
    new TColStd_HArray1OfReal(-aDegV, anIndexV+1);

  for (I = -aDegU; I <= anIndexU + 1; I ++)
    allKnotsU->SetValue(I, another->KnotU(I));

  for (I = -aDegV; I <= anIndexV + 1; I ++)
    allKnotsV->SetValue(I, another->KnotV(I));

  Handle(TColStd_HArray2OfReal) allWeights  =
    new TColStd_HArray2OfReal (0, anIndexU, 0, anIndexV);
  Handle(TColgp_HArray2OfXYZ)   allPoles    =
    new TColgp_HArray2OfXYZ   (0, anIndexU, 0, anIndexV);

  for (J = 0; J <= anIndexV; J ++)
    for (I = 0; I <= anIndexU; I ++) 
      allWeights->SetValue(I, J, another->Weight(I,J));

  for (J = 0; J <= anIndexV; J ++)
    for (I = 0; I <= anIndexU; I ++) 
      allPoles->SetValue(I, J, another->Pole(I, J).XYZ());

  aUmin = another->UMin();
  aUmax = another->UMax();
  aVmin = another->VMin();
  aVmax = another->VMax();

  ent->Init (anIndexU, anIndexV, aDegU, aDegV, aCloseU, aCloseV,
	     aPolynom, aPeriodU, aPeriodV, allKnotsU, allKnotsV,
	     allWeights, allPoles, aUmin, aUmax, aVmin, aVmax);
  ent->SetFormNumber(another->FormNumber());
}


//=======================================================================
//function : DirChecker
//purpose  : 
//=======================================================================

IGESData_DirChecker IGESGeom_ToolBSplineSurface::DirChecker
  (const Handle(IGESGeom_BSplineSurface)& /* ent */ )   const
{
  IGESData_DirChecker DC(128, 0, 9);
  DC.Structure(IGESData_DefVoid);
  DC.LineFont(IGESData_DefAny);
//  DC.LineWeight(IGESData_DefValue);
  DC.Color(IGESData_DefAny);
  DC.HierarchyStatusIgnored();
  return DC;
}


//=======================================================================
//function : OwnCheck
//purpose  : 
//=======================================================================

void IGESGeom_ToolBSplineSurface::OwnCheck(const Handle(IGESGeom_BSplineSurface)& ent,
                                           const Interface_ShareTool&,
                                           Handle(Interface_Check)& ach)  const
{
  // MGE 31/07/98
  // Building of messages
  //========================================
  //Message_Msg Msg104("XSTEP_104");
  //Message_Msg Msg160("XSTEP_160");
  //Message_Msg Msg161("XSTEP_161");
  //========================================


  //Standard_Real eps = 1.E-04;    // Tolerance des tests ?? //szv#4:S4163:12Mar99 not needed

  //modified by rln 18/12/97 check of flag PROP2 according to IGES Standard
  //The same as in IGESGeom_ToolBSplineCurve::OwnCheck()
  //It is possible to compare U(0) and U(1) only if UStartingParameter = UFirstKnot
  //and UEndingParameter = ULastKnot and the same for V(0),V(1) 
  //(else we must build real geometrical curve)
  //The fail is replaced with warning because it is not a serious problem
/*
  if (ent->UMin() == ent->KnotU(-ent->DegreeU()        ) &&
      ent->UMax() == ent->KnotU( ent->UpperIndexU() + 1)   ) {
    Standard_Real udif = Max (ent->Pole(0, 0).SquareDistance (ent->Pole(ent->UpperIndexU(), 0)),
                              ent->Pole(0, ent->UpperIndexV()).SquareDistance (ent->Pole(ent->UpperIndexU(), ent->UpperIndexV())));
//  if ((ent->UMin() == ent->UMax()) && !ent->IsClosedU())
//    if (udif < eps * eps && !ent->IsClosedU())
//      ach.AddWarning("U(0) == U(1) & PROP1 != 1");
//  if ((ent->UMin() != ent->UMax()) &&  ent->IsClosedU())
//    if (udif >= eps * eps && ent->IsClosedU())
//       ach.AddWarning("U(0) != U(1) & PROP1 != 0");
  }

  if (ent->VMin() == ent->KnotV(-ent->DegreeV()        ) &&
      ent->VMax() == ent->KnotV( ent->UpperIndexV() + 1)   ) {
    Standard_Real vdif = Max (ent->Pole(0, 0).SquareDistance (ent->Pole(0, ent->UpperIndexV())),
                              ent->Pole(ent->UpperIndexU(), 0).SquareDistance (ent->Pole(ent->UpperIndexU(), ent->UpperIndexV())));
//  if ((ent->VMin() == ent->VMax()) && !ent->IsClosedV())
//    if (vdif < eps * eps && !ent->IsClosedV())
//      ach.AddWarning("V(0) == V(1) & PROP2 != 1");
//  if ((ent->VMin() != ent->VMax()) && ent->IsClosedV())
//    if (vdif >= eps * eps && ent->IsClosedV())
//      ach.AddWarning("V(0) != V(1) & PROP2 != 0");
  }
*/

  Standard_Boolean Flag = Standard_True;
  Standard_Integer indU = ent->UpperIndexU();
  Standard_Integer indV = ent->UpperIndexV();
  Standard_Integer I,J;

  if (ent->NbKnotsU() != (indU + ent->DegreeU() +2)) {
    Message_Msg Msg160("XSTEP_160");
    Msg160.Arg(indU + ent->DegreeU() +2);
    ach->SendFail(Msg160);
  }
  if (ent->NbKnotsV() != (indV + ent->DegreeV() +2)) {
    Message_Msg Msg161("XSTEP_161");
    Msg161.Arg(indV + ent->DegreeV() +2);
    ach->SendFail(Msg161);
  }

  for ( J = 0; ((J < indV) && (Flag)); J ++)
    for ( I = 0; ((I < indU) && (Flag)); I ++)
      Flag &= (ent->Weight(I,J) > 0);

  if (!Flag) {
    Message_Msg Msg104("XSTEP_104");
    ach->SendFail(Msg104);
  }

  Flag = Standard_True;
  Standard_Real tempVal = ent->Weight(0,0);

  for ( J = 0; ((J < indV) && (Flag)); J ++)
    for ( I = 0; ((I < indU) && (Flag)); I ++)
      Flag &= (ent->Weight(I,J) == tempVal);

//  Standard_Boolean Flap = ent->IsPolynomial(Standard_True);
//  if (Flag && !Flap)
//    ach.AddWarning("All weights equal & PROP3 != 1. (Surface not Polynomial)");
//  if (!Flag && Flap)
//    ach.AddWarning("All weights not equal & PROP3 != 0 (Surface not Rational)");
}


//=======================================================================
//function : OwnDump
//purpose  : 
//=======================================================================

void IGESGeom_ToolBSplineSurface::OwnDump(const Handle(IGESGeom_BSplineSurface)& ent,
                                          const IGESData_IGESDumper& /* dumper */,
                                          Standard_OStream& S,
                                          const Standard_Integer level)  const
{
  S << "BSplineSurface from IGESGeom\n\n";

  Standard_Integer indU = ent->UpperIndexU();
  Standard_Integer indV = ent->UpperIndexV();
  Standard_Integer degU = ent->DegreeU();
  Standard_Integer degV = ent->DegreeV();

  S << "In U : Upper Knot Index : " << indU
    << "   Degree : " << degU << "  "
    << (ent->IsClosedU() ? "Closed" : "Open") << "  "
    << (ent->IsPeriodicU() ? "Periodic" : "Non Periodic")
    << "\n"
    << "In V : Upper Knot Index : " << indV
    << "   Degree : " << degV << "  "
    << (ent->IsClosedV() ? "Closed" : "Open") << "  "
    << (ent->IsPeriodicV() ? "Periodic" : "Non Periodic") << "  "
    << (ent->IsPolynomial(Standard_True) ? "Polynomial" : "Rational") << "\n";

  S << "Starting Parameter for U direction : " << ent->UMin() << "\n"
    << "Ending   Parameter for U direction : " << ent->UMax() << "\n"
    << "Starting Parameter for V direction : " << ent->VMin() << "\n"
    << "Ending   Parameter for V direction : " << ent->VMax() << "\n";

  S << " Knots in  U : ";
  IGESData_DumpVals(S,level,-degU, indU+1,ent->KnotU);
  S << "\n"
    << " Knots in  V : ";
  IGESData_DumpVals(S,level,-degV, indV+1,ent->KnotV);
  S << "\n"
    << "Weights : (Row -> IndexU, Col -> IndexV)";
  IGESData_DumpRectVals(S,level,0, indU,0,indV,ent->Weight);
  S << "\n"
    << "Control Points (Poles) : ";
//IGESData_DumpRectXYZL(S,level,1, ent->NbPoles(),ent->Pole, ent->Location());
  if (level < 5) {  S << " [ content : ask level > 4 ]" << std::endl; return;  }
  gp_GTrsf loca = ent->Location();
  for (Standard_Integer JP = 0; JP <= indV; JP ++)
    for (Standard_Integer IP = 0; IP <= indU; IP ++) {
      if (IP == 0) S << "\n";
      S <<"  -  ["<<IP<<","<<JP<<"]: ";
      IGESData_DumpXYZL(S,level,ent->Pole(IP,JP),loca);
    }
  S << std::endl;
}
Commit	Line	Data
b311480e	1	// Created by: CKY / Contract Toubro-Larsen
b311480e	2	// Copyright (c) 1993-1999 Matra Datavision
973c2be1	3	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	4	//
973c2be1	5	// This file is part of Open CASCADE Technology software library.
7fd59977	6	//
d5f74e42	7	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	8	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	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.
7fd59977	12	//
973c2be1	13	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	14	// commercial license or contractual agreement.
b311480e	15
b311480e	16	//--------------------------------------------------------------------
7fd59977	17	//--------------------------------------------------------------------
7fd59977	18
7fd59977	19	#include <gp_XYZ.hxx>
42cf5bc1	20	#include <IGESData_DirChecker.hxx>
7fd59977	21	#include <IGESData_Dump.hxx>
42cf5bc1	22	#include <IGESData_IGESDumper.hxx>
	23	#include <IGESData_IGESReaderData.hxx>
	24	#include <IGESData_IGESWriter.hxx>
	25	#include <IGESData_ParamCursor.hxx>
	26	#include <IGESData_ParamReader.hxx>
	27	#include <IGESGeom_BSplineSurface.hxx>
	28	#include <IGESGeom_ToolBSplineSurface.hxx>
	29	#include <Interface_Check.hxx>
	30	#include <Interface_CopyTool.hxx>
	31	#include <Interface_EntityIterator.hxx>
7fd59977	32	#include <Interface_Macros.hxx>
42cf5bc1	33	#include <Interface_ShareTool.hxx>
42cf5bc1	34	#include <Message_Messenger.hxx>
7fd59977	35	#include <Message_Msg.hxx>
42cf5bc1	36	#include <Standard_DomainError.hxx>
	37	#include <TColgp_HArray2OfXYZ.hxx>
	38	#include <TColStd_HArray1OfReal.hxx>
	39	#include <TColStd_HArray2OfReal.hxx>
7fd59977	40
42cf5bc1	41	// MGE 31/07/98
7fd59977	42	//=======================================================================
	43	//function : IGESGeom_ToolBSplineSurface
	44	//purpose :
	45	//=======================================================================
7fd59977	46	IGESGeom_ToolBSplineSurface::IGESGeom_ToolBSplineSurface ()
	47	{
	48	}
	49
	50
	51	//=======================================================================
	52	//function : ReadOwnParams
	53	//purpose :
	54	//=======================================================================
	55
	56	void IGESGeom_ToolBSplineSurface::ReadOwnParams
	57	(const Handle(IGESGeom_BSplineSurface)& ent,
	58	const Handle(IGESData_IGESReaderData)& /* IR */, IGESData_ParamReader& PR) const
	59	{
	60	// MGE 31/07/98
	61	// Building of messages
	62	//========================================
	63	Message_Msg Msg100("XSTEP_100");
	64	Message_Msg Msg101("XSTEP_101");
	65	Message_Msg Msg102("XSTEP_102");
	66	Message_Msg Msg103("XSTEP_103");
	67	Message_Msg Msg159("XSTEP_159");
	68	//========================================
	69
	70	Standard_Integer I, J;
	71	Standard_Integer anIndexU, anIndexV, aDegU, aDegV;
	72	Standard_Boolean aCloseU, aCloseV, aPolynom, aPeriodU, aPeriodV;
1d47d8d0	73	Standard_Real aUmin, aUmax, aVmin = 0., aVmax = 0.;
7fd59977	74	Standard_Real tempVal;
	75	gp_XYZ tempXYZ;
	76	Handle(TColStd_HArray1OfReal) allKnotsU;
	77	Handle(TColStd_HArray1OfReal) allKnotsV;
	78	Handle(TColStd_HArray2OfReal) allWeights;
	79	Handle(TColgp_HArray2OfXYZ) allPoles;
	80
	81	//Standard_Boolean st; //szv#4:S4163:12Mar99 not needed
	82	Standard_Boolean FlagindexU = PR.ReadInteger(PR.Current(), anIndexU);
	83
	84	Standard_Boolean FlagindexV = PR.ReadInteger(PR.Current(), anIndexV);
	85
	86	if (!FlagindexU \|\| !FlagindexV){
	87	Message_Msg Msg97("XSTEP_97");
	88	PR.SendFail(Msg97);
	89	}
	90
	91	Standard_Boolean FlagdegU = PR.ReadInteger(PR.Current(), aDegU);
	92
	93	Standard_Boolean FlagdegV = PR.ReadInteger(PR.Current(), aDegV);
	94
	95	if (!FlagdegU \|\| !FlagdegV){
	96	Message_Msg Msg98("XSTEP_98");
	97	PR.SendFail(Msg98);
	98	}
	99	//szv#4:S4163:12Mar99 `st=` not needed
	100	PR.ReadBoolean(PR.Current(), Msg100,aCloseU);
	101	PR.ReadBoolean(PR.Current(), Msg100,aCloseV);
	102	PR.ReadBoolean(PR.Current(), Msg101, aPolynom);
	103	PR.ReadBoolean(PR.Current(), Msg102, aPeriodU);
	104	PR.ReadBoolean(PR.Current(), Msg102, aPeriodV);
	105
	106	/*
	107	Standard_Boolean FlagindexU =
	108	PR.ReadInteger(PR.Current(), "Upper Index in U", anIndexU);
	109
	110	Standard_Boolean FlagindexV =
	111	PR.ReadInteger(PR.Current(), "Upper Index in V", anIndexV);
	112
	113	Standard_Boolean FlagdegU =
	114	PR.ReadInteger(PR.Current(), "Degree Of First Basis Functions", aDegU);
	115
	116	Standard_Boolean FlagdegV =
	117	PR.ReadInteger(PR.Current(), "Degree Of Second Basis Functions",aDegV);
	118
	119	st = PR.ReadBoolean(PR.Current(), "Closed/Open flag in U Direction",aCloseU);
	120	st = PR.ReadBoolean(PR.Current(), "Closed/Open flag in V Direction",aCloseV);
	121	st = PR.ReadBoolean(PR.Current(), "Polynomial / Rational", aPolynom);
	122	st = PR.ReadBoolean(PR.Current(), "Periodic flag in U direction", aPeriodU);
	123	st = PR.ReadBoolean(PR.Current(), "Periodic flag in V direction", aPeriodV);
	124	*/
	125	if ( FlagdegU && FlagindexU )
	126	{
	127	// allKnotsU = new TColStd_HArray1OfReal(-aDegU, anIndexU+1); done by :
	128	Standard_Integer tempind = anIndexU+aDegU+2;
	129	PR.ReadReals(PR.CurrentList(tempind), Msg103, allKnotsU, -aDegU); //szv#4:S4163:12Mar99 `st=` not needed
	130	//st = PR.ReadReals(PR.CurrentList(tempind), "First knot sequence values", allKnotsU, -aDegU);
	131	}
	132
	133	if ( FlagdegV && FlagindexV )
	134	{
	135	// allKnotsV = new TColStd_HArray1OfReal(-aDegV, anIndexV+1); done by :
	136	Standard_Integer tempind = anIndexV+aDegV+2;
	137	PR.ReadReals(PR.CurrentList(tempind), Msg103, allKnotsV, -aDegV); //szv#4:S4163:12Mar99 `st=` not needed
138	//st = PR.ReadReals(PR.CurrentList(tempind), "Second knot sequence values", allKnotsV, -aDegV);
139	}
140
141	if ( FlagindexU && FlagindexV )
142	{
143	allWeights = new TColStd_HArray2OfReal (0, anIndexU, 0, anIndexV);
144	allPoles = new TColgp_HArray2OfXYZ (0, anIndexU, 0, anIndexV);
145
146	Standard_Boolean BadWeigth = Standard_False;
147	Message_Msg Msg105("XSTEP_105");
148
149	for (J = 0; J <= anIndexV; J ++) {
150	for (I = 0; I <= anIndexU; I ++) {
151	//st = PR.ReadReal(PR.Current(), Msg104, tempVal); //szv#4:S4163:12Mar99 moved down
152	//st = PR.ReadReal(PR.Current(), "Weights", tempVal);
153	if (PR.ReadReal(PR.Current(), tempVal)) {
154	if(tempVal<Precision::PConfusion()) { // skl for OCC2821 11.06.2003
155	BadWeigth = Standard_True;
156	}
157	allWeights->SetValue(I, J, tempVal);
158	}
159	else{
160	Message_Msg Msg104("XSTEP_104");
161	PR.SendFail(Msg104);
162	}
163	}
164	}
165	if(BadWeigth) { // skl for OCC2821 11.06.2003
166	for (J = 0; J <= anIndexV; J ++) {
167	for (I = 0; I <= anIndexU; I ++) {
168	allWeights->SetValue(I, J, 1.);
169	}
170	}
171	}
172
173	for (J = 0; J <= anIndexV; J ++)
174	for (I = 0; I <= anIndexU; I ++) {
175	//st = PR.ReadXYZ (PR.CurrentList(1, 3), Msg105, tempXYZ); //szv#4:S4163:12Mar99 moved down
176	//st = PR.ReadXYZ (PR.CurrentList(1, 3), "Control Points", tempXYZ);
177	if (PR.ReadXYZ (PR.CurrentList(1, 3), Msg105, tempXYZ))
178	allPoles->SetValue(I, J, tempXYZ);
179	}
180	}
181
182	//szv#4:S4163:12Mar99 `st=` not needed
183	/* PR.ReadReal(PR.Current(), Msg106, aUmin);
184	PR.ReadReal(PR.Current(), Msg107, aUmax);
185	PR.ReadReal(PR.Current(), Msg106, aVmin);
186	PR.ReadReal(PR.Current(), Msg107, aVmax);
187	*/
188	if (!PR.ReadReal(PR.Current(), aUmin) \|\| !PR.ReadReal(PR.Current(), aVmin)){
189	Message_Msg Msg106("XSTEP_106");
190	PR.SendFail(Msg106);
191	}
192
193	if (!PR.ReadReal(PR.Current(), aUmax) \|\| !PR.ReadReal(PR.Current(), aVmax)){
194	Message_Msg Msg107("XSTEP_107");
195	PR.SendFail(Msg107);
196	}
197	/*
198	st = PR.ReadReal(PR.Current(), "Starting Value For U Direction", aUmin);
199	st = PR.ReadReal(PR.Current(), "Ending Value For U Direction", aUmax);
200	st = PR.ReadReal(PR.Current(), "Starting Value For V Direction", aVmin);
201	st = PR.ReadReal(PR.Current(), "Ending Value For U Direction", aVmax);
202	*/
203	// PROTECTION contre ANSYS 5.3 qui ecrit 3 flottants en plus ...
204	Standard_Integer icur = PR.CurrentNumber(), imax = PR.NbParams();
205	Standard_Real bid; Standard_Integer pbfin = 0;
206	//st = Standard_True; //szv#4:S4163:12Mar99 not needed
207	while (imax >= icur) {
208	Interface_ParamType pt = PR.ParamType(icur);
209	if (pt == Interface_ParamReal) {
210	if (!PR.ReadReal (PR.Current(),bid)){
211	PR.SendFail(Msg159);
212	} //szv#4:S4163:12Mar99 `st=` not needed
213	if (pbfin == 0) pbfin = 1;
214	}
215	else if (pt == Interface_ParamInteger \|\| pt == Interface_ParamVoid) break;
216	else pbfin = -1;
217	icur ++;
218	}
219	if (pbfin > 0) PR.SendWarning(Msg159);
220	if (pbfin < 0){
221	Message_Msg Msg158("XSTEP_158");
222	PR.SendFail(Msg158);
223	}
224	DirChecker(ent).CheckTypeAndForm(PR.CCheck(),ent);
225	ent->Init
226	(anIndexU, anIndexV, aDegU, aDegV, aCloseU, aCloseV,
227	aPolynom, aPeriodU, aPeriodV, allKnotsU, allKnotsV,
228	allWeights, allPoles, aUmin, aUmax, aVmin, aVmax);
229	}
230
231
232	//=======================================================================
233	//function : WriteOwnParams
234	//purpose :
235	//=======================================================================
236
237	void IGESGeom_ToolBSplineSurface::WriteOwnParams
238	(const Handle(IGESGeom_BSplineSurface)& ent, IGESData_IGESWriter& IW) const
239	{
240	Standard_Integer indU = ent->UpperIndexU();
241	Standard_Integer indV = ent->UpperIndexV();
242	Standard_Integer degU = ent->DegreeU();
243	Standard_Integer degV = ent->DegreeV();
244	Standard_Integer I, J;
245	IW.Send(indU);
246	IW.Send(indV);
247	IW.Send(degU);
248	IW.Send(degV);
249	IW.SendBoolean(ent->IsClosedU());
250	IW.SendBoolean(ent->IsClosedV());
251	IW.SendBoolean(ent->IsPolynomial());
252	IW.SendBoolean(ent->IsPeriodicU());
253	IW.SendBoolean(ent->IsPeriodicV());
254
255	for (I = -degU; I <= indU + 1; I ++)
256	IW.Send(ent->KnotU(I));
257
258	for (I = -degV; I <= indV + 1; I ++)
259	IW.Send(ent->KnotV(I));
260
261	for (J = 0; J <= indV; J ++)
262	for (I = 0; I <= indU; I ++)
263	IW.Send(ent->Weight(I, J));
264
265	for (J = 0; J <= indV; J ++)
266	for (I = 0; I <= indU; I ++) {
267	gp_XYZ tempXYZ = ent->Pole(I, J).XYZ();
268	IW.Send(tempXYZ.X());
269	IW.Send(tempXYZ.Y());
270	IW.Send(tempXYZ.Z());
271	}
272	IW.Send(ent->UMin());
273	IW.Send(ent->UMax());
274	IW.Send(ent->VMin());
275	IW.Send(ent->VMax());
276	}
277
278
279	//=======================================================================
280	//function : OwnShared
281	//purpose :
282	//=======================================================================
283
284	void IGESGeom_ToolBSplineSurface::OwnShared(const Handle(IGESGeom_BSplineSurface)& /* ent */,
285	Interface_EntityIterator& /* iter */) const
286	{
287	}
288
289
290	//=======================================================================
291	//function : OwnCopy
292	//purpose :
293	//=======================================================================
294
295	void IGESGeom_ToolBSplineSurface::OwnCopy(const Handle(IGESGeom_BSplineSurface)& another,
296	const Handle(IGESGeom_BSplineSurface)& ent,
297	Interface_CopyTool& /* TC */) const
298	{
299	Standard_Integer I, J;
300	Standard_Integer anIndexU, anIndexV, aDegU, aDegV;
301	Standard_Boolean aCloseU, aCloseV, aPolynom;
302	Standard_Boolean aPeriodU, aPeriodV;
303	Standard_Real aUmin, aUmax, aVmin, aVmax;
304
305	anIndexU = another->UpperIndexU();
306	anIndexV = another->UpperIndexV();
307	aDegU = another->DegreeU();
308	aDegV = another->DegreeV();
309	aCloseU = another->IsClosedU();
310	aCloseV = another->IsClosedV();
311	aPolynom = another->IsPolynomial();
312	aPeriodU = another->IsPeriodicU();
313	aPeriodV = another->IsPeriodicV();
314
315	Handle(TColStd_HArray1OfReal) allKnotsU =
316	new TColStd_HArray1OfReal(-aDegU, anIndexU+1);
317	Handle(TColStd_HArray1OfReal) allKnotsV =
318	new TColStd_HArray1OfReal(-aDegV, anIndexV+1);
319
320	for (I = -aDegU; I <= anIndexU + 1; I ++)
321	allKnotsU->SetValue(I, another->KnotU(I));
322
323	for (I = -aDegV; I <= anIndexV + 1; I ++)
324	allKnotsV->SetValue(I, another->KnotV(I));
325
326	Handle(TColStd_HArray2OfReal) allWeights =
327	new TColStd_HArray2OfReal (0, anIndexU, 0, anIndexV);
328	Handle(TColgp_HArray2OfXYZ) allPoles =
329	new TColgp_HArray2OfXYZ (0, anIndexU, 0, anIndexV);
330
331	for (J = 0; J <= anIndexV; J ++)
332	for (I = 0; I <= anIndexU; I ++)
333	allWeights->SetValue(I, J, another->Weight(I,J));
334
335	for (J = 0; J <= anIndexV; J ++)
336	for (I = 0; I <= anIndexU; I ++)
337	allPoles->SetValue(I, J, another->Pole(I, J).XYZ());
338
339	aUmin = another->UMin();
340	aUmax = another->UMax();
341	aVmin = another->VMin();
342	aVmax = another->VMax();
343
344	ent->Init (anIndexU, anIndexV, aDegU, aDegV, aCloseU, aCloseV,
345	aPolynom, aPeriodU, aPeriodV, allKnotsU, allKnotsV,
346	allWeights, allPoles, aUmin, aUmax, aVmin, aVmax);
347	ent->SetFormNumber(another->FormNumber());
348	}
349
350
351	//=======================================================================
352	//function : DirChecker
353	//purpose :
354	//=======================================================================
355
356	IGESData_DirChecker IGESGeom_ToolBSplineSurface::DirChecker
357	(const Handle(IGESGeom_BSplineSurface)& /* ent */ ) const
358	{
359	IGESData_DirChecker DC(128, 0, 9);
360	DC.Structure(IGESData_DefVoid);
361	DC.LineFont(IGESData_DefAny);
362	// DC.LineWeight(IGESData_DefValue);
363	DC.Color(IGESData_DefAny);
364	DC.HierarchyStatusIgnored();
365	return DC;
366	}
367
368
369	//=======================================================================
370	//function : OwnCheck
371	//purpose :
372	//=======================================================================
373
374	void IGESGeom_ToolBSplineSurface::OwnCheck(const Handle(IGESGeom_BSplineSurface)& ent,
375	const Interface_ShareTool&,
376	Handle(Interface_Check)& ach) const
377	{
378	// MGE 31/07/98
379	// Building of messages
380	//========================================
381	//Message_Msg Msg104("XSTEP_104");
382	//Message_Msg Msg160("XSTEP_160");
383	//Message_Msg Msg161("XSTEP_161");
384	//========================================
385
386
387
388	//Standard_Real eps = 1.E-04; // Tolerance des tests ?? //szv#4:S4163:12Mar99 not needed
389
390	//modified by rln 18/12/97 check of flag PROP2 according to IGES Standard
391	//The same as in IGESGeom_ToolBSplineCurve::OwnCheck()
392	//It is possible to compare U(0) and U(1) only if UStartingParameter = UFirstKnot
393	//and UEndingParameter = ULastKnot and the same for V(0),V(1)
394	//(else we must build real geometrical curve)
395	//The fail is replaced with warning because it is not a serious problem
396	/*
397	if (ent->UMin() == ent->KnotU(-ent->DegreeU() ) &&
398	ent->UMax() == ent->KnotU( ent->UpperIndexU() + 1) ) {
399	Standard_Real udif = Max (ent->Pole(0, 0).SquareDistance (ent->Pole(ent->UpperIndexU(), 0)),
400	ent->Pole(0, ent->UpperIndexV()).SquareDistance (ent->Pole(ent->UpperIndexU(), ent->UpperIndexV())));
401	// if ((ent->UMin() == ent->UMax()) && !ent->IsClosedU())
402	// if (udif < eps * eps && !ent->IsClosedU())
403	// ach.AddWarning("U(0) == U(1) & PROP1 != 1");
404	// if ((ent->UMin() != ent->UMax()) && ent->IsClosedU())
405	// if (udif >= eps * eps && ent->IsClosedU())
406	// ach.AddWarning("U(0) != U(1) & PROP1 != 0");
407	}
408
409	if (ent->VMin() == ent->KnotV(-ent->DegreeV() ) &&
410	ent->VMax() == ent->KnotV( ent->UpperIndexV() + 1) ) {
411	Standard_Real vdif = Max (ent->Pole(0, 0).SquareDistance (ent->Pole(0, ent->UpperIndexV())),
412	ent->Pole(ent->UpperIndexU(), 0).SquareDistance (ent->Pole(ent->UpperIndexU(), ent->UpperIndexV())));
413	// if ((ent->VMin() == ent->VMax()) && !ent->IsClosedV())
414	// if (vdif < eps * eps && !ent->IsClosedV())
415	// ach.AddWarning("V(0) == V(1) & PROP2 != 1");
416	// if ((ent->VMin() != ent->VMax()) && ent->IsClosedV())
417	// if (vdif >= eps * eps && ent->IsClosedV())
418	// ach.AddWarning("V(0) != V(1) & PROP2 != 0");
419	}
420	*/
421
422	Standard_Boolean Flag = Standard_True;
423	Standard_Integer indU = ent->UpperIndexU();
424	Standard_Integer indV = ent->UpperIndexV();
425	Standard_Integer I,J;
426
427	if (ent->NbKnotsU() != (indU + ent->DegreeU() +2)) {
428	Message_Msg Msg160("XSTEP_160");
429	Msg160.Arg(indU + ent->DegreeU() +2);
430	ach->SendFail(Msg160);
431	}
432	if (ent->NbKnotsV() != (indV + ent->DegreeV() +2)) {
433	Message_Msg Msg161("XSTEP_161");
434	Msg161.Arg(indV + ent->DegreeV() +2);
435	ach->SendFail(Msg161);
436	}
437
438	for ( J = 0; ((J < indV) && (Flag)); J ++)
439	for ( I = 0; ((I < indU) && (Flag)); I ++)
440	Flag &= (ent->Weight(I,J) > 0);
441
442	if (!Flag) {
443	Message_Msg Msg104("XSTEP_104");
444	ach->SendFail(Msg104);
445	}
446
447	Flag = Standard_True;
448	Standard_Real tempVal = ent->Weight(0,0);
449
450	for ( J = 0; ((J < indV) && (Flag)); J ++)
451	for ( I = 0; ((I < indU) && (Flag)); I ++)
452	Flag &= (ent->Weight(I,J) == tempVal);
453
454	// Standard_Boolean Flap = ent->IsPolynomial(Standard_True);
455	// if (Flag && !Flap)
456	// ach.AddWarning("All weights equal & PROP3 != 1. (Surface not Polynomial)");
457	// if (!Flag && Flap)
458	// ach.AddWarning("All weights not equal & PROP3 != 0 (Surface not Rational)");
459	}
460
461
462	//=======================================================================
463	//function : OwnDump
464	//purpose :
465	//=======================================================================
466
467	void IGESGeom_ToolBSplineSurface::OwnDump(const Handle(IGESGeom_BSplineSurface)& ent,
468	const IGESData_IGESDumper& /* dumper */,
0ebe5b0a	469	Standard_OStream& S,
7fd59977	470	const Standard_Integer level) const
7fd59977	471	{
0ebe5b0a	472	S << "BSplineSurface from IGESGeom\n\n";
7fd59977	473
	474	Standard_Integer indU = ent->UpperIndexU();
	475	Standard_Integer indV = ent->UpperIndexV();
	476	Standard_Integer degU = ent->DegreeU();
	477	Standard_Integer degV = ent->DegreeV();
	478
0ebe5b0a	479	S << "In U : Upper Knot Index : " << indU
	480	<< " Degree : " << degU << " "
	481	<< (ent->IsClosedU() ? "Closed" : "Open") << " "
	482	<< (ent->IsPeriodicU() ? "Periodic" : "Non Periodic")
	483	<< "\n"
	484	<< "In V : Upper Knot Index : " << indV
	485	<< " Degree : " << degV << " "
	486	<< (ent->IsClosedV() ? "Closed" : "Open") << " "
	487	<< (ent->IsPeriodicV() ? "Periodic" : "Non Periodic") << " "
	488	<< (ent->IsPolynomial(Standard_True) ? "Polynomial" : "Rational") << "\n";
	489
	490	S << "Starting Parameter for U direction : " << ent->UMin() << "\n"
	491	<< "Ending Parameter for U direction : " << ent->UMax() << "\n"
	492	<< "Starting Parameter for V direction : " << ent->VMin() << "\n"
	493	<< "Ending Parameter for V direction : " << ent->VMax() << "\n";
7fd59977	494
7fd59977	495	S << " Knots in U : ";
0ebe5b0a	496	IGESData_DumpVals(S,level,-degU, indU+1,ent->KnotU);
	497	S << "\n"
	498	<< " Knots in V : ";
	499	IGESData_DumpVals(S,level,-degV, indV+1,ent->KnotV);
	500	S << "\n"
	501	<< "Weights : (Row -> IndexU, Col -> IndexV)";
	502	IGESData_DumpRectVals(S,level,0, indU,0,indV,ent->Weight);
	503	S << "\n"
	504	<< "Control Points (Poles) : ";
7fd59977	505	//IGESData_DumpRectXYZL(S,level,1, ent->NbPoles(),ent->Pole, ent->Location());
0ebe5b0a	506	if (level < 5) { S << " [ content : ask level > 4 ]" << std::endl; return; }
7fd59977	507	gp_GTrsf loca = ent->Location();
	508	for (Standard_Integer JP = 0; JP <= indV; JP ++)
	509	for (Standard_Integer IP = 0; IP <= indU; IP ++) {
0ebe5b0a	510	if (IP == 0) S << "\n";
7fd59977	511	S <<" - ["<<IP<<","<<JP<<"]: ";
	512	IGESData_DumpXYZL(S,level,ent->Pole(IP,JP),loca);
	513	}
0ebe5b0a	514	S << std::endl;
7fd59977	515	}