[occt.git] / src / IGESGeom / IGESGeom_ToolSplineCurve.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 <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_SplineCurve.hxx>
#include <IGESGeom_ToolSplineCurve.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 <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray2OfReal.hxx>

#include <stdio.h>
// MGE 29/07/98
IGESGeom_ToolSplineCurve::IGESGeom_ToolSplineCurve ()    {  }


void IGESGeom_ToolSplineCurve::ReadOwnParams
  (const Handle(IGESGeom_SplineCurve)& ent,
   const Handle(IGESData_IGESReaderData)& /* IR */, IGESData_ParamReader& PR) const
{
  // MGE 29/07/98
  // Building of messages

  //Standard_Boolean st; //szv#4:S4163:12Mar99 not needed
  Standard_Integer nbSegments;
  Standard_Integer aType, aDegree, nbDimensions;
  Handle(TColStd_HArray1OfReal) allBreakPoints;
  Handle(TColStd_HArray2OfReal) allXPolynomials;
  Handle(TColStd_HArray2OfReal) allYPolynomials;
  Handle(TColStd_HArray2OfReal) allZPolynomials;
  Handle(TColStd_HArray1OfReal) allXvalues = new TColStd_HArray1OfReal(1, 4);
  Handle(TColStd_HArray1OfReal) allYvalues = new TColStd_HArray1OfReal(1, 4);
  Handle(TColStd_HArray1OfReal) allZvalues = new TColStd_HArray1OfReal(1, 4);

  //szv#4:S4163:12Mar99 `st=` not needed
  if (!PR.ReadInteger(PR.Current(), aType)){
    Message_Msg Msg91("XSTEP_91");
    PR.SendFail(Msg91);
  }
  if (!PR.ReadInteger(PR.Current(), aDegree)){
    Message_Msg Msg92("XSTEP_92");
    PR.SendFail(Msg92);
  }
  if (!PR.ReadInteger(PR.Current(), nbDimensions)){
    Message_Msg Msg93("XSTEP_93");
    PR.SendFail(Msg93);
  }
  //st = PR.ReadInteger(PR.Current(), Msg94, nbSegments); //szv#4:S4163:12Mar99 moved in if

/*
  st = PR.ReadInteger(PR.Current(), "Spline Type", aType);
  st = PR.ReadInteger(PR.Current(), "Degree Continuity", aDegree);
  st = PR.ReadInteger(PR.Current(), "Number Of Dimensions", nbDimensions);
  st = PR.ReadInteger(PR.Current(), "Number Of Segments", nbSegments);
*/ 
  if (PR.ReadInteger(PR.Current(), nbSegments)) {
    if (nbSegments <= 0){
      Message_Msg Msg94("XSTEP_94");
      PR.SendFail(Msg94);
    }
    else {
      allXPolynomials = new TColStd_HArray2OfReal (1, nbSegments, 1, 4);
      allYPolynomials = new TColStd_HArray2OfReal (1, nbSegments, 1, 4);
      allZPolynomials = new TColStd_HArray2OfReal (1, nbSegments, 1, 4);
      allBreakPoints  = new TColStd_HArray1OfReal (1, (nbSegments + 1));
    }
    Message_Msg Msg95("XSTEP_95");
    PR.ReadReals(PR.CurrentList(nbSegments + 1), Msg95, allBreakPoints); //szv#4:S4163:12Mar99 `st=` not needed
/*
    st = PR.ReadReals(PR.CurrentList(nbSegments + 1), "Break Points",
		      allBreakPoints);
*/
  }
  else{
    Message_Msg Msg94("XSTEP_94");
    PR.SendFail(Msg94);
  }

  Handle(TColStd_HArray1OfReal) temp;
  temp = new TColStd_HArray1OfReal(1,4);

  if (! allXPolynomials.IsNull()) {
    Standard_Integer I;
    for (I = 1; I <= nbSegments; I++)
      {
	//st = PR.ReadReals(PR.CurrentList(4),"X-Coordinate Polynomial",temp); //szv#4:S4163:12Mar99 moved in if
	if (PR.ReadReals(PR.CurrentList(4),"X-Coordinate Polynomial",temp)) {
	  Standard_Integer J;
	  for (J = 1; J <= 4; J++)
	    allXPolynomials->SetValue(I, J, temp->Value(J));
	}

	//st = PR.ReadReals(PR.CurrentList(4),"Y-Coordinate Polynomial",temp); //szv#4:S4163:12Mar99 moved in if
	if (PR.ReadReals(PR.CurrentList(4),"Y-Coordinate Polynomial",temp)) {
	  Standard_Integer J;
	  for (J = 1; J <= 4; J++)
	    allYPolynomials->SetValue(I, J, temp->Value(J));
	}

	//st = PR.ReadReals(PR.CurrentList(4),"Z-Coordinate Polynomial",temp); //szv#4:S4163:12Mar99 moved in if
	if (PR.ReadReals(PR.CurrentList(4),"Z-Coordinate Polynomial",temp)) {
	  Standard_Integer J;
	  for (J = 1; J <= 4; J++)
	    allZPolynomials->SetValue(I, J, temp->Value(J));
	}
      }
  }

  //st = PR.ReadReals(PR.CurrentList(4), "TerminatePoint X-Values", temp); //szv#4:S4163:12Mar99 moved in if
  if (PR.ReadReals(PR.CurrentList(4), "TerminatePoint X-Values", temp)) {
    Standard_Integer J;
    for (J = 1; J <= 4; J++)
      allXvalues->SetValue(J, temp->Value(J));
  }

  //st = PR.ReadReals(PR.CurrentList(4), "TerminatePoint Y-Values", temp); //szv#4:S4163:12Mar99 moved in if
  if (PR.ReadReals(PR.CurrentList(4), "TerminatePoint Y-Values", temp)) {
    Standard_Integer J;
    for (J = 1; J <= 4; J++)
      allYvalues->SetValue(J, temp->Value(J));
  }

  //st = PR.ReadReals(PR.CurrentList(4), "TerminatePoint Z-Values", temp); //szv#4:S4163:12Mar99 moved in if
  if (PR.ReadReals(PR.CurrentList(4), "TerminatePoint Z-Values", temp)) {
    Standard_Integer J;
    for (J = 1; J <= 4; J++)
      allZvalues->SetValue(J, temp->Value(J));
  }

  //sln 28.09.2001, BUC61004, If the condition is true function ent->Init is not called in order to avoid exception
  if(allBreakPoints.IsNull() ||  allXPolynomials.IsNull() || allYPolynomials.IsNull() || allZPolynomials.IsNull())
    return;
  else
    {
      DirChecker(ent).CheckTypeAndForm(PR.CCheck(),ent);
      ent->Init
        (aType, aDegree, nbDimensions, allBreakPoints,
         allXPolynomials, allYPolynomials, allZPolynomials,
         allXvalues, allYvalues, allZvalues);
    }
}

void IGESGeom_ToolSplineCurve::WriteOwnParams
  (const Handle(IGESGeom_SplineCurve)& ent, IGESData_IGESWriter& IW)  const
{
  IW.Send(ent->SplineType());
  IW.Send(ent->Degree());
  IW.Send(ent->NbDimensions());
  Standard_Integer nbSegments = ent->NbSegments();
  IW.Send(nbSegments);

  Standard_Integer I;
  for (I = 1; I <= nbSegments + 1; I++)
    IW.Send(ent->BreakPoint(I));
  Standard_Real AX,BX,CX,DX, AY,BY,CY,DY, AZ,BZ,CZ,DZ;
  for (I = 1; I <= nbSegments; I++) {
//no need to declare (hides the same name in an outer scope)
//     Standard_Real AX,BX,CX,DX, AY,BY,CY,DY, AZ,BZ,CZ,DZ;
    ent->XCoordPolynomial(I,AX,BX,CX,DX);
    ent->YCoordPolynomial(I,AY,BY,CY,DY);
    ent->ZCoordPolynomial(I,AZ,BZ,CZ,DZ);
    IW.Send(AX);  IW.Send(BX);  IW.Send(CX);  IW.Send(DX);
    IW.Send(AY);  IW.Send(BY);  IW.Send(CY);  IW.Send(DY);
    IW.Send(AZ);  IW.Send(BZ);  IW.Send(CZ);  IW.Send(DZ);
  }
  ent->XValues(AX,BX,CX,DX);
  ent->YValues(AY,BY,CY,DY);
  ent->ZValues(AZ,BZ,CZ,DZ);
  IW.Send(AX);  IW.Send(BX);  IW.Send(CX);  IW.Send(DX);
  IW.Send(AY);  IW.Send(BY);  IW.Send(CY);  IW.Send(DY);
  IW.Send(AZ);  IW.Send(BZ);  IW.Send(CZ);  IW.Send(DZ);
}

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

void IGESGeom_ToolSplineCurve::OwnCopy
  (const Handle(IGESGeom_SplineCurve)& another,
   const Handle(IGESGeom_SplineCurve)& ent, Interface_CopyTool& /* TC */) const
{
  Standard_Integer I;
  Standard_Real A, B, C, D;
  Standard_Integer aType   = another->SplineType();
  Standard_Integer aDegree = another->Degree();
  Standard_Integer nbDimensions = another->NbDimensions();
  Standard_Integer nbSegments   = another->NbSegments();

  Handle(TColStd_HArray1OfReal) allBreakPoints =
    new TColStd_HArray1OfReal(1, nbSegments+1);
  for (I = 1; I <= (nbSegments + 1); I++)
    allBreakPoints->SetValue(I, another->BreakPoint(I));

  Handle(TColStd_HArray2OfReal) allXPolynomials =
    new TColStd_HArray2OfReal(1, nbSegments, 1, 4);
  Handle(TColStd_HArray2OfReal) allYPolynomials =
    new TColStd_HArray2OfReal(1, nbSegments, 1, 4);
  Handle(TColStd_HArray2OfReal) allZPolynomials =
    new TColStd_HArray2OfReal(1, nbSegments, 1, 4);

  for (I = 1; I <= nbSegments; I++) {
    another->XCoordPolynomial(I, A, B, C, D);
    allXPolynomials->SetValue(I, 1, A);
    allXPolynomials->SetValue(I, 2, B);
    allXPolynomials->SetValue(I, 3, C);
    allXPolynomials->SetValue(I, 4, D);

    another->YCoordPolynomial(I, A, B, C, D);
    allYPolynomials->SetValue(I, 1, A);
    allYPolynomials->SetValue(I, 2, B);
    allYPolynomials->SetValue(I, 3, C);
    allYPolynomials->SetValue(I, 4, D);

    another->ZCoordPolynomial(I, A, B, C, D);
    allZPolynomials->SetValue(I, 1, A);
    allZPolynomials->SetValue(I, 2, B);
    allZPolynomials->SetValue(I, 3, C);
    allZPolynomials->SetValue(I, 4, D);
  }

  Handle(TColStd_HArray1OfReal) allXvalues =
    new TColStd_HArray1OfReal(1, 4);
  Handle(TColStd_HArray1OfReal) allYvalues =
    new TColStd_HArray1OfReal(1, 4);
  Handle(TColStd_HArray1OfReal) allZvalues =
    new TColStd_HArray1OfReal(1, 4);

  another->XValues(A, B, C, D);
  allXvalues->SetValue(1, A);
  allXvalues->SetValue(2, B);
  allXvalues->SetValue(3, C);
  allXvalues->SetValue(4, D);

  another->YValues(A, B, C, D);
  allYvalues->SetValue(1, A);
  allYvalues->SetValue(2, B);
  allYvalues->SetValue(3, C);
  allYvalues->SetValue(4, D);

  another->ZValues(A, B, C, D);
  allZvalues->SetValue(1, A);
  allZvalues->SetValue(2, B);
  allZvalues->SetValue(3, C);
  allZvalues->SetValue(4, D);

  ent->Init(aType, aDegree, nbDimensions, allBreakPoints,
	    allXPolynomials, allYPolynomials, allZPolynomials,
	    allXvalues, allYvalues, allZvalues);
}


IGESData_DirChecker IGESGeom_ToolSplineCurve::DirChecker
  (const Handle(IGESGeom_SplineCurve)& /* ent */ )   const
{
  IGESData_DirChecker DC(112, 0);
  DC.Structure(IGESData_DefVoid);
  DC.LineFont(IGESData_DefAny);
//  DC.LineWeight(IGESData_DefValue);
  DC.Color(IGESData_DefAny);
  DC.HierarchyStatusIgnored();

  return DC;
}

void IGESGeom_ToolSplineCurve::OwnCheck
  (const Handle(IGESGeom_SplineCurve)& ent,
   const Interface_ShareTool& , Handle(Interface_Check)& ach)  const
{
  // MGE 29/07/98
  // Building of messages

  if (ent->SplineType() < 1 || ent->SplineType() > 6){
    Message_Msg Msg91("XSTEP_91");
    ach->SendFail(Msg91);
  }
  if (ent->NbDimensions() == 2) {
    Standard_Integer nbSegments = ent->NbSegments();
    Standard_Real AZ,BZ,CZ,DZ;
    Message_Msg Msg96("XSTEP_96");
    for (Standard_Integer I = 1; I <= nbSegments; I ++) {
      ent->ZCoordPolynomial(I,AZ,BZ,CZ,DZ);
      if (BZ != 0 || CZ != 0 || DZ != 0) {
	ach->SendFail(Msg96);
      }
    }
  }
  else if (ent->NbDimensions() != 3){
    Message_Msg Msg93("XSTEP_93");
    ach->SendFail(Msg93);
  }
}

void IGESGeom_ToolSplineCurve::OwnDump
  (const Handle(IGESGeom_SplineCurve)& ent, const IGESData_IGESDumper& /* dumper */,
   const Handle(Message_Messenger)& S, const Standard_Integer level)  const
{
  S << "IGESGeom_SplineCurve" << Message_EndLine;

  Standard_Integer nbSegments = ent->NbSegments();
  S << "Spline Type          : " << ent->SplineType()    << "  ";
  switch (ent->SplineType())
    {
    case 1 : S << "(Linear)"; break;
    case 2 : S << "(Quadratic)"; break;
    case 3 : S << "(Cubic)"; break;
    case 4 : S << "(Wilson-Fowler)"; break;
    case 5 : S << "(Modified Wison-Fowler)"; break;
    case 6 : S << "(B-Spline)"; break;
      default : S << "(Invalid value)"; break;
    }
  S << Message_EndLine;
  S << "Degree Of Continuity : " << ent->Degree()       << Message_EndLine;
  S << "Number Of Dimensions : " << ent->NbDimensions() << Message_EndLine;
  S << "Number Of Segments   : " << ent->NbSegments()   << Message_EndLine;
  S << "Segment Break Points : ";
  IGESData_DumpVals(S ,level,1, nbSegments+1,ent->BreakPoint);
  if (level <= 4) {
    S << " [ also ask level > 4 for X-Y-Z Polynomials ]" << Message_EndLine;
    return;
  }
  S << "  --  Polynomial  Values  --" << Message_EndLine;
  Standard_Real AX,BX,CX,DX, AY,BY,CY,DY, AZ,BZ,CZ,DZ;
  for (Standard_Integer I = 1; I <= nbSegments; I++) {
//no need to declare (hides the same name in an outer scope)
//  Standard_Real AX,BX,CX,DX, AY,BY,CY,DY, AZ,BZ,CZ,DZ;
    ent->XCoordPolynomial(I,AX,BX,CX,DX);
    ent->YCoordPolynomial(I,AY,BY,CY,DY);
    ent->ZCoordPolynomial(I,AZ,BZ,CZ,DZ);
    S << "Segment "<<I<<" :	    X		   Y		Z"<<Message_EndLine;
    S << " A ...	"<<AX<<"	"<<AY<<"	"<<AZ<<Message_EndLine;
    S << " B ...	"<<BX<<"	"<<BY<<"	"<<BZ<<Message_EndLine;
    S << " C ...	"<<CX<<"	"<<CY<<"	"<<CZ<<Message_EndLine;
    S << " D ...	"<<DX<<"	"<<DY<<"	"<<DZ<<Message_EndLine;
  }
  ent->XValues(AX,BX,CX,DX);
  ent->YValues(AY,BY,CY,DY);
  ent->ZValues(AZ,BZ,CZ,DZ);
  S << "Terminate Point :	    X		   Y		Z"<<Message_EndLine;
  S << " Value        	"<<AX<<"	"<<AY<<"	"<<AZ<<Message_EndLine;
  S << " 1st Derivative	"<<BX<<"	"<<BY<<"	"<<BZ<<Message_EndLine;
  S << " 2nd Der./2!   	"<<CX<<"	"<<CY<<"	"<<CZ<<Message_EndLine;
  S << " 3rd Der./3!   	"<<DX<<"	"<<DY<<"	"<<DZ<<Message_EndLine;
}
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
42cf5bc1	19	#include <IGESData_DirChecker.hxx>
7fd59977	20	#include <IGESData_Dump.hxx>
42cf5bc1	21	#include <IGESData_IGESDumper.hxx>
	22	#include <IGESData_IGESReaderData.hxx>
	23	#include <IGESData_IGESWriter.hxx>
	24	#include <IGESData_ParamCursor.hxx>
	25	#include <IGESData_ParamReader.hxx>
	26	#include <IGESGeom_SplineCurve.hxx>
	27	#include <IGESGeom_ToolSplineCurve.hxx>
	28	#include <Interface_Check.hxx>
	29	#include <Interface_CopyTool.hxx>
	30	#include <Interface_EntityIterator.hxx>
7fd59977	31	#include <Interface_Macros.hxx>
42cf5bc1	32	#include <Interface_ShareTool.hxx>
42cf5bc1	33	#include <Message_Messenger.hxx>
7fd59977	34	#include <Message_Msg.hxx>
42cf5bc1	35	#include <Standard_DomainError.hxx>
	36	#include <TColStd_HArray1OfReal.hxx>
	37	#include <TColStd_HArray2OfReal.hxx>
7fd59977	38
42cf5bc1	39	#include <stdio.h>
42cf5bc1	40	// MGE 29/07/98
7fd59977	41	IGESGeom_ToolSplineCurve::IGESGeom_ToolSplineCurve () { }
	42
	43
	44	void IGESGeom_ToolSplineCurve::ReadOwnParams
	45	(const Handle(IGESGeom_SplineCurve)& ent,
	46	const Handle(IGESData_IGESReaderData)& /* IR */, IGESData_ParamReader& PR) const
	47	{
	48	// MGE 29/07/98
	49	// Building of messages
	50
	51	//Standard_Boolean st; //szv#4:S4163:12Mar99 not needed
	52	Standard_Integer nbSegments;
8c2d3314	53	Standard_Integer aType, aDegree, nbDimensions;
7fd59977	54	Handle(TColStd_HArray1OfReal) allBreakPoints;
	55	Handle(TColStd_HArray2OfReal) allXPolynomials;
	56	Handle(TColStd_HArray2OfReal) allYPolynomials;
	57	Handle(TColStd_HArray2OfReal) allZPolynomials;
	58	Handle(TColStd_HArray1OfReal) allXvalues = new TColStd_HArray1OfReal(1, 4);
	59	Handle(TColStd_HArray1OfReal) allYvalues = new TColStd_HArray1OfReal(1, 4);
	60	Handle(TColStd_HArray1OfReal) allZvalues = new TColStd_HArray1OfReal(1, 4);
	61
	62	//szv#4:S4163:12Mar99 `st=` not needed
	63	if (!PR.ReadInteger(PR.Current(), aType)){
	64	Message_Msg Msg91("XSTEP_91");
	65	PR.SendFail(Msg91);
	66	}
	67	if (!PR.ReadInteger(PR.Current(), aDegree)){
	68	Message_Msg Msg92("XSTEP_92");
	69	PR.SendFail(Msg92);
	70	}
	71	if (!PR.ReadInteger(PR.Current(), nbDimensions)){
	72	Message_Msg Msg93("XSTEP_93");
	73	PR.SendFail(Msg93);
	74	}
	75	//st = PR.ReadInteger(PR.Current(), Msg94, nbSegments); //szv#4:S4163:12Mar99 moved in if
	76
	77	/*
	78	st = PR.ReadInteger(PR.Current(), "Spline Type", aType);
	79	st = PR.ReadInteger(PR.Current(), "Degree Continuity", aDegree);
	80	st = PR.ReadInteger(PR.Current(), "Number Of Dimensions", nbDimensions);
	81	st = PR.ReadInteger(PR.Current(), "Number Of Segments", nbSegments);
	82	*/
	83	if (PR.ReadInteger(PR.Current(), nbSegments)) {
	84	if (nbSegments <= 0){
	85	Message_Msg Msg94("XSTEP_94");
	86	PR.SendFail(Msg94);
	87	}
	88	else {
	89	allXPolynomials = new TColStd_HArray2OfReal (1, nbSegments, 1, 4);
	90	allYPolynomials = new TColStd_HArray2OfReal (1, nbSegments, 1, 4);
	91	allZPolynomials = new TColStd_HArray2OfReal (1, nbSegments, 1, 4);
	92	allBreakPoints = new TColStd_HArray1OfReal (1, (nbSegments + 1));
	93	}
	94	Message_Msg Msg95("XSTEP_95");
	95	PR.ReadReals(PR.CurrentList(nbSegments + 1), Msg95, allBreakPoints); //szv#4:S4163:12Mar99 `st=` not needed
	96	/*
	97	st = PR.ReadReals(PR.CurrentList(nbSegments + 1), "Break Points",
	98	allBreakPoints);
	99	*/
	100	}
	101	else{
	102	Message_Msg Msg94("XSTEP_94");
	103	PR.SendFail(Msg94);
	104	}
	105
	106	Handle(TColStd_HArray1OfReal) temp;
	107	temp = new TColStd_HArray1OfReal(1,4);
	108
	109	if (! allXPolynomials.IsNull()) {
	110	Standard_Integer I;
	111	for (I = 1; I <= nbSegments; I++)
	112	{
	113	//st = PR.ReadReals(PR.CurrentList(4),"X-Coordinate Polynomial",temp); //szv#4:S4163:12Mar99 moved in if
	114	if (PR.ReadReals(PR.CurrentList(4),"X-Coordinate Polynomial",temp)) {
	115	Standard_Integer J;
	116	for (J = 1; J <= 4; J++)
	117	allXPolynomials->SetValue(I, J, temp->Value(J));
118	}
119
120	//st = PR.ReadReals(PR.CurrentList(4),"Y-Coordinate Polynomial",temp); //szv#4:S4163:12Mar99 moved in if
121	if (PR.ReadReals(PR.CurrentList(4),"Y-Coordinate Polynomial",temp)) {
122	Standard_Integer J;
123	for (J = 1; J <= 4; J++)
124	allYPolynomials->SetValue(I, J, temp->Value(J));
125	}
126
127	//st = PR.ReadReals(PR.CurrentList(4),"Z-Coordinate Polynomial",temp); //szv#4:S4163:12Mar99 moved in if
128	if (PR.ReadReals(PR.CurrentList(4),"Z-Coordinate Polynomial",temp)) {
129	Standard_Integer J;
130	for (J = 1; J <= 4; J++)
131	allZPolynomials->SetValue(I, J, temp->Value(J));
132	}
133	}
134	}
135
136	//st = PR.ReadReals(PR.CurrentList(4), "TerminatePoint X-Values", temp); //szv#4:S4163:12Mar99 moved in if
137	if (PR.ReadReals(PR.CurrentList(4), "TerminatePoint X-Values", temp)) {
138	Standard_Integer J;
139	for (J = 1; J <= 4; J++)
140	allXvalues->SetValue(J, temp->Value(J));
141	}
142
143	//st = PR.ReadReals(PR.CurrentList(4), "TerminatePoint Y-Values", temp); //szv#4:S4163:12Mar99 moved in if
144	if (PR.ReadReals(PR.CurrentList(4), "TerminatePoint Y-Values", temp)) {
145	Standard_Integer J;
146	for (J = 1; J <= 4; J++)
147	allYvalues->SetValue(J, temp->Value(J));
148	}
149
150	//st = PR.ReadReals(PR.CurrentList(4), "TerminatePoint Z-Values", temp); //szv#4:S4163:12Mar99 moved in if
151	if (PR.ReadReals(PR.CurrentList(4), "TerminatePoint Z-Values", temp)) {
152	Standard_Integer J;
153	for (J = 1; J <= 4; J++)
154	allZvalues->SetValue(J, temp->Value(J));
155	}
156
157	//sln 28.09.2001, BUC61004, If the condition is true function ent->Init is not called in order to avoid exception
158	if(allBreakPoints.IsNull() \|\| allXPolynomials.IsNull() \|\| allYPolynomials.IsNull() \|\| allZPolynomials.IsNull())
159	return;
160	else
161	{
162	DirChecker(ent).CheckTypeAndForm(PR.CCheck(),ent);
163	ent->Init
164	(aType, aDegree, nbDimensions, allBreakPoints,
165	allXPolynomials, allYPolynomials, allZPolynomials,
166	allXvalues, allYvalues, allZvalues);
167	}
168	}
169
170	void IGESGeom_ToolSplineCurve::WriteOwnParams
171	(const Handle(IGESGeom_SplineCurve)& ent, IGESData_IGESWriter& IW) const
172	{
173	IW.Send(ent->SplineType());
174	IW.Send(ent->Degree());
175	IW.Send(ent->NbDimensions());
176	Standard_Integer nbSegments = ent->NbSegments();
177	IW.Send(nbSegments);
178
179	Standard_Integer I;
180	for (I = 1; I <= nbSegments + 1; I++)
181	IW.Send(ent->BreakPoint(I));
182	Standard_Real AX,BX,CX,DX, AY,BY,CY,DY, AZ,BZ,CZ,DZ;
183	for (I = 1; I <= nbSegments; I++) {
184	//no need to declare (hides the same name in an outer scope)
185	// Standard_Real AX,BX,CX,DX, AY,BY,CY,DY, AZ,BZ,CZ,DZ;
186	ent->XCoordPolynomial(I,AX,BX,CX,DX);
187	ent->YCoordPolynomial(I,AY,BY,CY,DY);
188	ent->ZCoordPolynomial(I,AZ,BZ,CZ,DZ);
189	IW.Send(AX); IW.Send(BX); IW.Send(CX); IW.Send(DX);
190	IW.Send(AY); IW.Send(BY); IW.Send(CY); IW.Send(DY);
191	IW.Send(AZ); IW.Send(BZ); IW.Send(CZ); IW.Send(DZ);
192	}
193	ent->XValues(AX,BX,CX,DX);
194	ent->YValues(AY,BY,CY,DY);
195	ent->ZValues(AZ,BZ,CZ,DZ);
196	IW.Send(AX); IW.Send(BX); IW.Send(CX); IW.Send(DX);
197	IW.Send(AY); IW.Send(BY); IW.Send(CY); IW.Send(DY);
198	IW.Send(AZ); IW.Send(BZ); IW.Send(CZ); IW.Send(DZ);
199	}
200
201	void IGESGeom_ToolSplineCurve::OwnShared
202	(const Handle(IGESGeom_SplineCurve)& /* ent /, Interface_EntityIterator& / iter */) const
203	{
204	}
205
206	void IGESGeom_ToolSplineCurve::OwnCopy
207	(const Handle(IGESGeom_SplineCurve)& another,
208	const Handle(IGESGeom_SplineCurve)& ent, Interface_CopyTool& /* TC */) const
209	{
210	Standard_Integer I;
211	Standard_Real A, B, C, D;
212	Standard_Integer aType = another->SplineType();
213	Standard_Integer aDegree = another->Degree();
214	Standard_Integer nbDimensions = another->NbDimensions();
215	Standard_Integer nbSegments = another->NbSegments();
216
217	Handle(TColStd_HArray1OfReal) allBreakPoints =
218	new TColStd_HArray1OfReal(1, nbSegments+1);
219	for (I = 1; I <= (nbSegments + 1); I++)
220	allBreakPoints->SetValue(I, another->BreakPoint(I));
221
222	Handle(TColStd_HArray2OfReal) allXPolynomials =
223	new TColStd_HArray2OfReal(1, nbSegments, 1, 4);
224	Handle(TColStd_HArray2OfReal) allYPolynomials =
225	new TColStd_HArray2OfReal(1, nbSegments, 1, 4);
226	Handle(TColStd_HArray2OfReal) allZPolynomials =
227	new TColStd_HArray2OfReal(1, nbSegments, 1, 4);
228
229	for (I = 1; I <= nbSegments; I++) {
230	another->XCoordPolynomial(I, A, B, C, D);
231	allXPolynomials->SetValue(I, 1, A);
232	allXPolynomials->SetValue(I, 2, B);
233	allXPolynomials->SetValue(I, 3, C);
234	allXPolynomials->SetValue(I, 4, D);
235
236	another->YCoordPolynomial(I, A, B, C, D);
237	allYPolynomials->SetValue(I, 1, A);
238	allYPolynomials->SetValue(I, 2, B);
239	allYPolynomials->SetValue(I, 3, C);
240	allYPolynomials->SetValue(I, 4, D);
241
242	another->ZCoordPolynomial(I, A, B, C, D);
243	allZPolynomials->SetValue(I, 1, A);
244	allZPolynomials->SetValue(I, 2, B);
245	allZPolynomials->SetValue(I, 3, C);
246	allZPolynomials->SetValue(I, 4, D);
247	}
248
249	Handle(TColStd_HArray1OfReal) allXvalues =
250	new TColStd_HArray1OfReal(1, 4);
251	Handle(TColStd_HArray1OfReal) allYvalues =
252	new TColStd_HArray1OfReal(1, 4);
253	Handle(TColStd_HArray1OfReal) allZvalues =
254	new TColStd_HArray1OfReal(1, 4);
255
256	another->XValues(A, B, C, D);
257	allXvalues->SetValue(1, A);
258	allXvalues->SetValue(2, B);
259	allXvalues->SetValue(3, C);
260	allXvalues->SetValue(4, D);
261
262	another->YValues(A, B, C, D);
263	allYvalues->SetValue(1, A);
264	allYvalues->SetValue(2, B);
265	allYvalues->SetValue(3, C);
266	allYvalues->SetValue(4, D);
267
268	another->ZValues(A, B, C, D);
269	allZvalues->SetValue(1, A);
270	allZvalues->SetValue(2, B);
271	allZvalues->SetValue(3, C);
272	allZvalues->SetValue(4, D);
273
274	ent->Init(aType, aDegree, nbDimensions, allBreakPoints,
275	allXPolynomials, allYPolynomials, allZPolynomials,
276	allXvalues, allYvalues, allZvalues);
277	}
278
279
280	IGESData_DirChecker IGESGeom_ToolSplineCurve::DirChecker
281	(const Handle(IGESGeom_SplineCurve)& /* ent */ ) const
282	{
283	IGESData_DirChecker DC(112, 0);
284	DC.Structure(IGESData_DefVoid);
285	DC.LineFont(IGESData_DefAny);
286	// DC.LineWeight(IGESData_DefValue);
287	DC.Color(IGESData_DefAny);
288	DC.HierarchyStatusIgnored();
289
290	return DC;
291	}
292
293	void IGESGeom_ToolSplineCurve::OwnCheck
294	(const Handle(IGESGeom_SplineCurve)& ent,
295	const Interface_ShareTool& , Handle(Interface_Check)& ach) const
296	{
297	// MGE 29/07/98
298	// Building of messages
299
300	if (ent->SplineType() < 1 \|\| ent->SplineType() > 6){
301	Message_Msg Msg91("XSTEP_91");
302	ach->SendFail(Msg91);
303	}
304	if (ent->NbDimensions() == 2) {
305	Standard_Integer nbSegments = ent->NbSegments();
306	Standard_Real AZ,BZ,CZ,DZ;
307	Message_Msg Msg96("XSTEP_96");
308	for (Standard_Integer I = 1; I <= nbSegments; I ++) {
309	ent->ZCoordPolynomial(I,AZ,BZ,CZ,DZ);
310	if (BZ != 0 \|\| CZ != 0 \|\| DZ != 0) {
311	ach->SendFail(Msg96);
312	}
313	}
314	}
315	else if (ent->NbDimensions() != 3){
316	Message_Msg Msg93("XSTEP_93");
317	ach->SendFail(Msg93);
318	}
319	}
320
321	void IGESGeom_ToolSplineCurve::OwnDump
322	(const Handle(IGESGeom_SplineCurve)& ent, const IGESData_IGESDumper& /* dumper */,
323	const Handle(Message_Messenger)& S, const Standard_Integer level) const
324	{
04232180	325	S << "IGESGeom_SplineCurve" << Message_EndLine;
7fd59977	326
	327	Standard_Integer nbSegments = ent->NbSegments();
	328	S << "Spline Type : " << ent->SplineType() << " ";
	329	switch (ent->SplineType())
	330	{
	331	case 1 : S << "(Linear)"; break;
	332	case 2 : S << "(Quadratic)"; break;
	333	case 3 : S << "(Cubic)"; break;
	334	case 4 : S << "(Wilson-Fowler)"; break;
	335	case 5 : S << "(Modified Wison-Fowler)"; break;
	336	case 6 : S << "(B-Spline)"; break;
	337	default : S << "(Invalid value)"; break;
	338	}
04232180	339	S << Message_EndLine;
	340	S << "Degree Of Continuity : " << ent->Degree() << Message_EndLine;
	341	S << "Number Of Dimensions : " << ent->NbDimensions() << Message_EndLine;
	342	S << "Number Of Segments : " << ent->NbSegments() << Message_EndLine;
7fd59977	343	S << "Segment Break Points : ";
	344	IGESData_DumpVals(S ,level,1, nbSegments+1,ent->BreakPoint);
	345	if (level <= 4) {
04232180	346	S << " [ also ask level > 4 for X-Y-Z Polynomials ]" << Message_EndLine;
7fd59977	347	return;
7fd59977	348	}
04232180	349	S << " -- Polynomial Values --" << Message_EndLine;
7fd59977	350	Standard_Real AX,BX,CX,DX, AY,BY,CY,DY, AZ,BZ,CZ,DZ;
	351	for (Standard_Integer I = 1; I <= nbSegments; I++) {
	352	//no need to declare (hides the same name in an outer scope)
	353	// Standard_Real AX,BX,CX,DX, AY,BY,CY,DY, AZ,BZ,CZ,DZ;
	354	ent->XCoordPolynomial(I,AX,BX,CX,DX);
	355	ent->YCoordPolynomial(I,AY,BY,CY,DY);
	356	ent->ZCoordPolynomial(I,AZ,BZ,CZ,DZ);
04232180	357	S << "Segment "<<I<<" : X Y Z"<<Message_EndLine;
	358	S << " A ... "<<AX<<" "<<AY<<" "<<AZ<<Message_EndLine;
	359	S << " B ... "<<BX<<" "<<BY<<" "<<BZ<<Message_EndLine;
	360	S << " C ... "<<CX<<" "<<CY<<" "<<CZ<<Message_EndLine;
	361	S << " D ... "<<DX<<" "<<DY<<" "<<DZ<<Message_EndLine;
7fd59977	362	}
	363	ent->XValues(AX,BX,CX,DX);
	364	ent->YValues(AY,BY,CY,DY);
	365	ent->ZValues(AZ,BZ,CZ,DZ);
04232180	366	S << "Terminate Point : X Y Z"<<Message_EndLine;
	367	S << " Value "<<AX<<" "<<AY<<" "<<AZ<<Message_EndLine;
	368	S << " 1st Derivative "<<BX<<" "<<BY<<" "<<BZ<<Message_EndLine;
	369	S << " 2nd Der./2! "<<CX<<" "<<CY<<" "<<CZ<<Message_EndLine;
	370	S << " 3rd Der./3! "<<DX<<" "<<DY<<" "<<DZ<<Message_EndLine;
7fd59977	371	}