[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_ParamReader.hxx>
#include <IGESGeom_SplineCurve.hxx>
#include <IGESGeom_ToolSplineCurve.hxx>
#include <Interface_Check.hxx>
#include <Interface_CopyTool.hxx>
#include <Interface_EntityIterator.hxx>
#include <Interface_ShareTool.hxx>
#include <Message_Msg.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 */,
   Standard_OStream& S, const Standard_Integer level)  const
{
  S << "IGESGeom_SplineCurve\n";

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