[occt.git] / src / ShapeUpgrade / ShapeUpgrade_ConvertCurve3dToBezier.cxx

// Created on: 1999-05-13
// Created by: data exchange team
// Copyright (c) 1999-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 <ShapeUpgrade_ConvertCurve3dToBezier.ixx>
#include <Precision.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_BezierCurve.hxx>
#include <ShapeExtend.hxx>
#include <Geom_Line.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_Conic.hxx>
#include <GeomConvert_ApproxCurve.hxx>
#include <GeomConvert.hxx>
#include <GeomConvert_BSplineCurveToBezierCurve.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColGeom_HArray1OfCurve.hxx>
#include <Geom_Circle.hxx>

ShapeUpgrade_ConvertCurve3dToBezier::ShapeUpgrade_ConvertCurve3dToBezier()
{
  mySegments = new TColGeom_HSequenceOfCurve;
  mySplitParams = new TColStd_HSequenceOfReal;
  myLineMode = Standard_True;
  myCircleMode = Standard_True;
  myConicMode = Standard_True;
}

//=======================================================================
//function : Compute
//purpose  : 
//=======================================================================

void ShapeUpgrade_ConvertCurve3dToBezier::Compute()
{
  mySegments->Clear();
  mySplitParams->Clear();
  Standard_Real precision = Precision::PConfusion();
  Standard_Real First =  mySplitValues->Value(1);
  Standard_Real Last = mySplitValues->Value(mySplitValues->Length());
  if(myCurve->IsKind(STANDARD_TYPE(Geom_TrimmedCurve))) {
    Handle(Geom_TrimmedCurve) tmp = Handle(Geom_TrimmedCurve)::DownCast (myCurve);
    Handle(Geom_Curve) BasCurve = tmp->BasisCurve();
    ShapeUpgrade_ConvertCurve3dToBezier converter;
    converter.Init(BasCurve,First,Last);
    converter.SetSplitValues(mySplitValues);
    converter.Compute();
    mySplitValues->ChangeSequence() = converter.SplitValues()->Sequence();
    myNbCurves = mySplitValues->Length()-1;
    myStatus |= converter.myStatus;
    mySegments->ChangeSequence() = converter.Segments()->Sequence();
    mySplitParams->ChangeSequence() = converter.SplitParams()->Sequence();
    return;
  }
  else if(myCurve->IsKind(STANDARD_TYPE(Geom_BezierCurve))) {
    Handle(Geom_BezierCurve) bezier = Handle(Geom_BezierCurve)::DownCast (myCurve);
    myNbCurves = mySplitValues->Length()-1;
    mySplitParams->Append(First);
    mySplitParams->Append(Last);
    if(First < precision && Last > 1 - precision) {
      mySegments->Append(bezier);
      myStatus = ShapeExtend::EncodeStatus (ShapeExtend_OK);
    } else {
      Handle(Geom_BezierCurve) besNew = Handle(Geom_BezierCurve)::DownCast(bezier->Copy());
      besNew->Segment(First,Last);
      mySegments->Append(besNew);
      myStatus = ShapeExtend::EncodeStatus (ShapeExtend_DONE2);
    }
    return;
  }
  else if(myCurve->IsKind(STANDARD_TYPE(Geom_Line))) {
    Handle(Geom_Line) aLine = Handle(Geom_Line)::DownCast(myCurve);
    myNbCurves = mySplitValues->Length()-1;
    mySplitParams->Append(First);
    mySplitParams->Append(Last);
    if(!myLineMode) {
      mySegments->Append(aLine);
      myStatus = ShapeExtend::EncodeStatus (ShapeExtend_OK);
      return;
    }
    TColgp_Array1OfPnt poles(1,2);
    poles(1) = aLine->Value(First);
    poles(2) = aLine->Value(Last);
    Handle(Geom_BezierCurve) bezier = new Geom_BezierCurve(poles);
    mySegments->Append(bezier);
    myStatus = ShapeExtend::EncodeStatus (ShapeExtend_DONE1);
    return;
  }
  else if((myCurve->IsKind(STANDARD_TYPE(Geom_Conic))&&!myConicMode)||
	  (myCurve->IsKind(STANDARD_TYPE(Geom_Circle))&&!myCircleMode)) {
    myNbCurves = mySplitValues->Length()-1;
    mySplitParams->Append(First);
    mySplitParams->Append(Last);
    mySegments->Append(myCurve);
    myStatus = ShapeExtend::EncodeStatus (ShapeExtend_OK);
    return;
  }
  else {
    Handle(Geom_BSplineCurve) aBSpline;
    Standard_Real Shift = 0.;
    if(myCurve->IsKind(STANDARD_TYPE(Geom_Conic))) {
      Handle(Geom_TrimmedCurve) tcurve = new Geom_TrimmedCurve(myCurve,First,Last); //protection agains parabols ets
      GeomConvert_ApproxCurve approx (tcurve, Precision::Approximation(), 
				      GeomAbs_C1, 100, 6 );
      if ( approx.HasResult() )
	aBSpline = Handle(Geom_BSplineCurve)::DownCast(approx.Curve());
      else {
	Handle(Geom_TrimmedCurve) t3d = new Geom_TrimmedCurve(myCurve,First,Last);
	aBSpline = GeomConvert::CurveToBSplineCurve(t3d,Convert_QuasiAngular);
      }
      Shift = First - aBSpline->FirstParameter();
      First = aBSpline->FirstParameter();
      Last = aBSpline->LastParameter();
    }
    else if(!myCurve->IsKind(STANDARD_TYPE(Geom_BSplineCurve))) {
      aBSpline = GeomConvert::CurveToBSplineCurve(myCurve,Convert_QuasiAngular);
    }
    else
      aBSpline = Handle(Geom_BSplineCurve)::DownCast(myCurve);
    
    Standard_Real bf = aBSpline->FirstParameter();
    Standard_Real bl = aBSpline->LastParameter();
    if(Abs(First-bf) < precision)
      First = bf;
    if(Abs(Last-bl) < precision)
      Last = bl;
    if(First < bf){
#ifdef DEB
      cout <<"Warning: The range of the edge exceeds the curve domain" <<endl;
#endif
      First = bf;
      mySplitValues->SetValue(1,First);
    }
    if(Last > bl){
#ifdef DEB
      cout <<"Warning: The range of the edge exceeds the curve domain" <<endl;
#endif
      Last = bl;
      mySplitValues->SetValue(mySplitValues->Length(),Last);
    }
    
    GeomConvert_BSplineCurveToBezierCurve tool(aBSpline,First,Last,precision);
    Standard_Integer nbArcs = tool.NbArcs();
    TColStd_Array1OfReal knots(1,nbArcs+1);
    tool.Knots(knots);
    mySplitParams->Append(First+Shift);
    Standard_Integer j; // svv Jan 10 2000 : porting on DEC
    for(j = 1; j <=nbArcs; j++) {
      Standard_Real nextKnot = knots(j+1)+Shift;
      if(nextKnot - mySplitParams->Value(mySplitParams->Length()) > precision) {
	mySegments->Append(tool.Arc(j));
	mySplitParams->Append(knots(j+1)+Shift);
      }
    }
    
    First = mySplitValues->Value(1);
    for(j = 2; j <= mySplitValues->Length(); j++) {
      Last =  mySplitValues->Value(j);
      for(Standard_Integer i = 2; i <= nbArcs+1; i++) {
	Standard_Real valknot = knots(i)+Shift;
	if(valknot <= First + precision) continue;
	if(valknot >= Last - precision) break;
	mySplitValues->InsertBefore(j++,valknot);
      }
      First = Last;
    }
    myNbCurves = mySplitValues->Length()-1;
  }
  myStatus = ShapeExtend::EncodeStatus (ShapeExtend_DONE1);
}

//=======================================================================
//function : Build
//purpose  : 
//=======================================================================

void ShapeUpgrade_ConvertCurve3dToBezier::Build(const Standard_Boolean /*Segment*/)
{
  Standard_Real prec = Precision::PConfusion();
  Standard_Integer nb = mySplitValues->Length();
  myResultingCurves =  new TColGeom_HArray1OfCurve (1,nb-1);
  Standard_Real prevPar = 0.;
  Standard_Integer j=2;
  for(Standard_Integer i = 2; i <= nb; i++) {
    Standard_Real par = mySplitValues->Value(i);
    for(; j<= mySplitParams->Length(); j++) 
      if(mySplitParams->Value(j)+prec > par) 
	break;
      else
	prevPar = 0.;
	
    Handle(Geom_Curve) crv = Handle(Geom_Curve)::DownCast(mySegments->Value(j-1)->Copy());
    if(crv->IsKind(STANDARD_TYPE(Geom_BezierCurve))) {
      Handle(Geom_BezierCurve) bes = Handle(Geom_BezierCurve)::DownCast(crv);
      Standard_Real uFact = mySplitParams->Value(j) - mySplitParams->Value(j-1);
      Standard_Real pp = mySplitValues->Value(i-1);
      Standard_Real length = (par - pp)/uFact;
      bes->Segment(prevPar, prevPar+length);
      prevPar += length;
      myResultingCurves->SetValue(i-1,bes);
    }
    else 
     myResultingCurves->SetValue(i-1,crv); 
  }
}

//=======================================================================
//function : Segments
//purpose  : 
//=======================================================================

Handle(TColGeom_HSequenceOfCurve) ShapeUpgrade_ConvertCurve3dToBezier::Segments() const
{
  return mySegments;
}

//=======================================================================
//function : SplitParams
//purpose  : 
//=======================================================================

Handle(TColStd_HSequenceOfReal) ShapeUpgrade_ConvertCurve3dToBezier::SplitParams() const
{
  return mySplitParams;
}
Commit	Line	Data
b311480e	1	// Created on: 1999-05-13
	2	// Created by: data exchange team
	3	// Copyright (c) 1999-1999 Matra Datavision
973c2be1	4	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	5	//
973c2be1	6	// This file is part of Open CASCADE Technology software library.
b311480e	7	//
d5f74e42	8	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	9	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	10	// by the Free Software Foundation, with special exception defined in the file
	11	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	12	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	13	//
973c2be1	14	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	15	// commercial license or contractual agreement.
7fd59977	16
	17	#include <ShapeUpgrade_ConvertCurve3dToBezier.ixx>
	18	#include <Precision.hxx>
	19	#include <Geom_TrimmedCurve.hxx>
	20	#include <Geom_BezierCurve.hxx>
	21	#include <ShapeExtend.hxx>
	22	#include <Geom_Line.hxx>
	23	#include <TColgp_Array1OfPnt.hxx>
	24	#include <Geom_BSplineCurve.hxx>
	25	#include <Geom_Conic.hxx>
	26	#include <GeomConvert_ApproxCurve.hxx>
	27	#include <GeomConvert.hxx>
	28	#include <GeomConvert_BSplineCurveToBezierCurve.hxx>
	29	#include <TColStd_Array1OfReal.hxx>
	30	#include <TColGeom_HArray1OfCurve.hxx>
	31	#include <Geom_Circle.hxx>
	32
	33	ShapeUpgrade_ConvertCurve3dToBezier::ShapeUpgrade_ConvertCurve3dToBezier()
	34	{
	35	mySegments = new TColGeom_HSequenceOfCurve;
	36	mySplitParams = new TColStd_HSequenceOfReal;
	37	myLineMode = Standard_True;
	38	myCircleMode = Standard_True;
	39	myConicMode = Standard_True;
	40	}
	41
	42	//=======================================================================
	43	//function : Compute
	44	//purpose :
	45	//=======================================================================
	46
	47	void ShapeUpgrade_ConvertCurve3dToBezier::Compute()
	48	{
	49	mySegments->Clear();
	50	mySplitParams->Clear();
	51	Standard_Real precision = Precision::PConfusion();
	52	Standard_Real First = mySplitValues->Value(1);
	53	Standard_Real Last = mySplitValues->Value(mySplitValues->Length());
	54	if(myCurve->IsKind(STANDARD_TYPE(Geom_TrimmedCurve))) {
	55	Handle(Geom_TrimmedCurve) tmp = Handle(Geom_TrimmedCurve)::DownCast (myCurve);
	56	Handle(Geom_Curve) BasCurve = tmp->BasisCurve();
	57	ShapeUpgrade_ConvertCurve3dToBezier converter;
	58	converter.Init(BasCurve,First,Last);
	59	converter.SetSplitValues(mySplitValues);
	60	converter.Compute();
	61	mySplitValues->ChangeSequence() = converter.SplitValues()->Sequence();
	62	myNbCurves = mySplitValues->Length()-1;
	63	myStatus \|= converter.myStatus;
	64	mySegments->ChangeSequence() = converter.Segments()->Sequence();
	65	mySplitParams->ChangeSequence() = converter.SplitParams()->Sequence();
	66	return;
	67	}
	68	else if(myCurve->IsKind(STANDARD_TYPE(Geom_BezierCurve))) {
	69	Handle(Geom_BezierCurve) bezier = Handle(Geom_BezierCurve)::DownCast (myCurve);
	70	myNbCurves = mySplitValues->Length()-1;
	71	mySplitParams->Append(First);
	72	mySplitParams->Append(Last);
	73	if(First < precision && Last > 1 - precision) {
	74	mySegments->Append(bezier);
	75	myStatus = ShapeExtend::EncodeStatus (ShapeExtend_OK);
	76	} else {
	77	Handle(Geom_BezierCurve) besNew = Handle(Geom_BezierCurve)::DownCast(bezier->Copy());
	78	besNew->Segment(First,Last);
	79	mySegments->Append(besNew);
80	myStatus = ShapeExtend::EncodeStatus (ShapeExtend_DONE2);
81	}
82	return;
83	}
84	else if(myCurve->IsKind(STANDARD_TYPE(Geom_Line))) {
85	Handle(Geom_Line) aLine = Handle(Geom_Line)::DownCast(myCurve);
86	myNbCurves = mySplitValues->Length()-1;
87	mySplitParams->Append(First);
88	mySplitParams->Append(Last);
89	if(!myLineMode) {
90	mySegments->Append(aLine);
91	myStatus = ShapeExtend::EncodeStatus (ShapeExtend_OK);
92	return;
93	}
94	TColgp_Array1OfPnt poles(1,2);
95	poles(1) = aLine->Value(First);
96	poles(2) = aLine->Value(Last);
97	Handle(Geom_BezierCurve) bezier = new Geom_BezierCurve(poles);
98	mySegments->Append(bezier);
99	myStatus = ShapeExtend::EncodeStatus (ShapeExtend_DONE1);
100	return;
101	}
102	else if((myCurve->IsKind(STANDARD_TYPE(Geom_Conic))&&!myConicMode)\|\|
103	(myCurve->IsKind(STANDARD_TYPE(Geom_Circle))&&!myCircleMode)) {
104	myNbCurves = mySplitValues->Length()-1;
105	mySplitParams->Append(First);
106	mySplitParams->Append(Last);
107	mySegments->Append(myCurve);
108	myStatus = ShapeExtend::EncodeStatus (ShapeExtend_OK);
109	return;
110	}
111	else {
112	Handle(Geom_BSplineCurve) aBSpline;
113	Standard_Real Shift = 0.;
114	if(myCurve->IsKind(STANDARD_TYPE(Geom_Conic))) {
115	Handle(Geom_TrimmedCurve) tcurve = new Geom_TrimmedCurve(myCurve,First,Last); //protection agains parabols ets
116	GeomConvert_ApproxCurve approx (tcurve, Precision::Approximation(),
117	GeomAbs_C1, 100, 6 );
118	if ( approx.HasResult() )
119	aBSpline = Handle(Geom_BSplineCurve)::DownCast(approx.Curve());
120	else {
121	Handle(Geom_TrimmedCurve) t3d = new Geom_TrimmedCurve(myCurve,First,Last);
122	aBSpline = GeomConvert::CurveToBSplineCurve(t3d,Convert_QuasiAngular);
123	}
124	Shift = First - aBSpline->FirstParameter();
125	First = aBSpline->FirstParameter();
126	Last = aBSpline->LastParameter();
127	}
128	else if(!myCurve->IsKind(STANDARD_TYPE(Geom_BSplineCurve))) {
129	aBSpline = GeomConvert::CurveToBSplineCurve(myCurve,Convert_QuasiAngular);
130	}
131	else
132	aBSpline = Handle(Geom_BSplineCurve)::DownCast(myCurve);
133
134	Standard_Real bf = aBSpline->FirstParameter();
135	Standard_Real bl = aBSpline->LastParameter();
136	if(Abs(First-bf) < precision)
137	First = bf;
138	if(Abs(Last-bl) < precision)
139	Last = bl;
140	if(First < bf){
141	#ifdef DEB
142	cout <<"Warning: The range of the edge exceeds the curve domain" <<endl;
143	#endif
144	First = bf;
145	mySplitValues->SetValue(1,First);
146	}
147	if(Last > bl){
148	#ifdef DEB
149	cout <<"Warning: The range of the edge exceeds the curve domain" <<endl;
150	#endif
151	Last = bl;
152	mySplitValues->SetValue(mySplitValues->Length(),Last);
153	}
154
155	GeomConvert_BSplineCurveToBezierCurve tool(aBSpline,First,Last,precision);
156	Standard_Integer nbArcs = tool.NbArcs();
157	TColStd_Array1OfReal knots(1,nbArcs+1);
158	tool.Knots(knots);
159	mySplitParams->Append(First+Shift);
160	Standard_Integer j; // svv Jan 10 2000 : porting on DEC
161	for(j = 1; j <=nbArcs; j++) {
162	Standard_Real nextKnot = knots(j+1)+Shift;
163	if(nextKnot - mySplitParams->Value(mySplitParams->Length()) > precision) {
164	mySegments->Append(tool.Arc(j));
165	mySplitParams->Append(knots(j+1)+Shift);
166	}
167	}
168
169	First = mySplitValues->Value(1);
170	for(j = 2; j <= mySplitValues->Length(); j++) {
171	Last = mySplitValues->Value(j);
172	for(Standard_Integer i = 2; i <= nbArcs+1; i++) {
173	Standard_Real valknot = knots(i)+Shift;
174	if(valknot <= First + precision) continue;
175	if(valknot >= Last - precision) break;
176	mySplitValues->InsertBefore(j++,valknot);
177	}
178	First = Last;
179	}
180	myNbCurves = mySplitValues->Length()-1;
181	}
182	myStatus = ShapeExtend::EncodeStatus (ShapeExtend_DONE1);
183	}
184
185	//=======================================================================
186	//function : Build
187	//purpose :
188	//=======================================================================
189
190	void ShapeUpgrade_ConvertCurve3dToBezier::Build(const Standard_Boolean /Segment/)
191	{
192	Standard_Real prec = Precision::PConfusion();
193	Standard_Integer nb = mySplitValues->Length();
194	myResultingCurves = new TColGeom_HArray1OfCurve (1,nb-1);
195	Standard_Real prevPar = 0.;
196	Standard_Integer j=2;
197	for(Standard_Integer i = 2; i <= nb; i++) {
198	Standard_Real par = mySplitValues->Value(i);
199	for(; j<= mySplitParams->Length(); j++)
200	if(mySplitParams->Value(j)+prec > par)
201	break;
202	else
203	prevPar = 0.;
204
205	Handle(Geom_Curve) crv = Handle(Geom_Curve)::DownCast(mySegments->Value(j-1)->Copy());
206	if(crv->IsKind(STANDARD_TYPE(Geom_BezierCurve))) {
207	Handle(Geom_BezierCurve) bes = Handle(Geom_BezierCurve)::DownCast(crv);
208	Standard_Real uFact = mySplitParams->Value(j) - mySplitParams->Value(j-1);
209	Standard_Real pp = mySplitValues->Value(i-1);
210	Standard_Real length = (par - pp)/uFact;
211	bes->Segment(prevPar, prevPar+length);
212	prevPar += length;
213	myResultingCurves->SetValue(i-1,bes);
214	}
215	else
216	myResultingCurves->SetValue(i-1,crv);
217	}
218	}
219
220	//=======================================================================
221	//function : Segments
222	//purpose :
223	//=======================================================================
224
225	Handle(TColGeom_HSequenceOfCurve) ShapeUpgrade_ConvertCurve3dToBezier::Segments() const
226	{
227	return mySegments;
228	}
229
230	//=======================================================================
231	//function : SplitParams
232	//purpose :
233	//=======================================================================
234
235	Handle(TColStd_HSequenceOfReal) ShapeUpgrade_ConvertCurve3dToBezier::SplitParams() const
236	{
237	return mySplitParams;
238	}