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

// Created on: 1998-11-12
// Created by: data exchange team
// Copyright (c) 1998-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.

//    abv 24.05.99 S4174: methods Debug() commented

#include <BSplCLib.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <ShapeUpgrade.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>

/*
// Debug state= True / False.
static Standard_Boolean Dbg=Standard_False;
void ShapeUpgrade::SetDebug(const Standard_Boolean State) 
{
  Dbg=State;
}
Standard_Boolean ShapeUpgrade::Debug() 
{
  return Dbg;
}
*/
//=======================================================================
//function : C0BSplineToSequenceOfC1BSplineCurve
//purpose  : 
//=======================================================================
 Standard_Boolean ShapeUpgrade::C0BSplineToSequenceOfC1BSplineCurve(const Handle(Geom_BSplineCurve)& BS,
	 							    Handle(TColGeom_HSequenceOfBoundedCurve)& seqBS) 
{
  if (BS.IsNull() || (BS->IsCN (1))) return Standard_False;
  
  seqBS = new TColGeom_HSequenceOfBoundedCurve;
  BS->SetNotPeriodic(); //to have equation NbPoles = NbKnots with Multiplicities - degree - 1
  
  Standard_Integer deg     = BS->Degree();
  Standard_Integer NbKnots = BS->NbKnots();
  Standard_Integer NbPoles = BS->NbPoles();
  TColgp_Array1OfPnt      Poles        (1, NbPoles);
  TColStd_Array1OfReal    Weights      (1, NbPoles);
  TColStd_Array1OfReal    Knots        (1, NbKnots);
  TColStd_Array1OfInteger Mults        (1, NbKnots);
  TColStd_Array1OfReal    KnotSequence (1, NbPoles + deg + 1);

  BS->Poles(Poles);
  if (BS->IsRational())
    BS->Weights(Weights);
  else
    Weights.Init(1.);
  BS->Knots(Knots);
  BS->Multiplicities(Mults);
  BS->KnotSequence (KnotSequence);
	
  Standard_Integer StartKnotIndex, EndKnotIndex, j;

  StartKnotIndex = BS->FirstUKnotIndex();
  for ( EndKnotIndex = StartKnotIndex + 1; EndKnotIndex <= BS->LastUKnotIndex(); EndKnotIndex++ ) {
    if ( ( Mults (EndKnotIndex) < deg ) && ( EndKnotIndex < BS->LastUKnotIndex() ) ) continue;

    Standard_Integer StartFlatIndex = BSplCLib::FlatIndex (deg, StartKnotIndex, Mults, Standard_False);
//    StartFlatIndex += Mults (StartKnotIndex) - 1;
    Standard_Integer EndFlatIndex   = BSplCLib::FlatIndex (deg, EndKnotIndex,   Mults, Standard_False);
    EndFlatIndex -= Mults (EndKnotIndex) - 1;

    TColStd_Array1OfReal    TempKnots (1, NbKnots);
    TColStd_Array1OfInteger TempMults (1, NbKnots);
    TempMults.Init (1);
    Standard_Integer TempKnotIndex = 1;
    TempKnots (TempKnotIndex) = KnotSequence (StartFlatIndex - deg);

    for ( j = StartFlatIndex - deg + 1; j <= EndFlatIndex + deg; j++ )
      if (Abs (KnotSequence (j) - KnotSequence (j - 1)) <= gp::Resolution())
	TempMults (TempKnotIndex) ++;
      else
	TempKnots (++TempKnotIndex) = KnotSequence (j);
    
    Standard_Integer TempStartIndex = 1, TempEndIndex = TempKnotIndex;
    if (TempMults (TempStartIndex) == 1)
      TempMults (++TempStartIndex) ++;
    if (TempMults (TempEndIndex) == 1)
      TempMults (--TempEndIndex) ++;

    Standard_Integer NewNbKnots = TempEndIndex - TempStartIndex + 1;
    TColStd_Array1OfInteger newMults (1, NewNbKnots);
    TColStd_Array1OfReal    newKnots (1, NewNbKnots);
    for ( j = 1; j <= NewNbKnots; j++ ) {
      newMults (j) = TempMults (j + TempStartIndex - 1);
      newKnots (j) = TempKnots (j + TempStartIndex - 1);
    }
	
    Standard_Integer NewNbPoles = BSplCLib::NbPoles(deg, Standard_False, newMults);
    TColgp_Array1OfPnt   newPoles (1, NewNbPoles);
    TColStd_Array1OfReal newWeights (1, NewNbPoles);
    Standard_Integer PoleIndex = StartFlatIndex - deg;//Index of starting pole when splitting B-Spline is an index of starting knot
    for (j = 1; j <= NewNbPoles; j++) {
      newWeights (j) = Weights (j + PoleIndex - 1);
      newPoles   (j) = Poles   (j + PoleIndex - 1);
    }
	
    Handle(Geom_BSplineCurve) newC = new Geom_BSplineCurve
      (newPoles, newWeights, newKnots, newMults,deg);
    seqBS->Append (newC);
    
    StartKnotIndex = EndKnotIndex;
  }
  return Standard_True;
}

//=======================================================================
//function : C0BSplineToSequenceOfC1BSplineCurve
//purpose  : 
//=======================================================================

static Handle(Geom_BSplineCurve) BSplineCurve2dTo3d (const Handle(Geom2d_BSplineCurve)& BS)
{
  Standard_Integer deg     = BS->Degree();
  Standard_Integer NbKnots = BS->NbKnots();
  Standard_Integer NbPoles = BS->NbPoles();
  TColgp_Array1OfPnt2d    Poles2d (1,NbPoles);
  TColStd_Array1OfReal    Weights (1,NbPoles);
  TColStd_Array1OfReal    Knots   (1,NbKnots);
  TColStd_Array1OfInteger Mults   (1,NbKnots);

  BS->Poles(Poles2d);
  if (BS->IsRational())
    BS->Weights(Weights);
  else
    Weights.Init (1);
  BS->Knots (Knots);
  BS->Multiplicities (Mults);

  TColgp_Array1OfPnt Poles3d (1,NbPoles);
  for (Standard_Integer i = 1; i <= NbPoles; i++)
    Poles3d (i) = gp_Pnt (Poles2d (i).X(), Poles2d (i).Y(), 0);
  
  Handle(Geom_BSplineCurve) BS3d = new Geom_BSplineCurve (Poles3d, Weights,
							  Knots, Mults, deg, BS->IsPeriodic());
  return BS3d;
}

static Handle(Geom2d_BSplineCurve) BSplineCurve3dTo2d (const Handle(Geom_BSplineCurve)& BS)
{
  Standard_Integer deg     = BS->Degree();
  Standard_Integer NbKnots = BS->NbKnots();
  Standard_Integer NbPoles = BS->NbPoles();
  TColgp_Array1OfPnt      Poles3d (1, NbPoles);
  TColStd_Array1OfReal    Weights (1, NbPoles);
  TColStd_Array1OfReal    Knots   (1, NbKnots);
  TColStd_Array1OfInteger Mults   (1, NbKnots);

  BS->Poles(Poles3d);
  if (BS->IsRational())
    BS->Weights(Weights);
  else
    Weights.Init (1);
  BS->Knots (Knots);
  BS->Multiplicities (Mults);

  TColgp_Array1OfPnt2d Poles2d (1,NbPoles);
  for (Standard_Integer i = 1; i <= NbPoles; i++)
    Poles2d (i) = gp_Pnt2d (Poles3d (i).X(), Poles3d (i).Y());
  
  Handle(Geom2d_BSplineCurve) BS2d = new Geom2d_BSplineCurve (Poles2d, Weights,
							      Knots, Mults, deg, BS->IsPeriodic());
  return BS2d;
}

 Standard_Boolean ShapeUpgrade::C0BSplineToSequenceOfC1BSplineCurve(const Handle(Geom2d_BSplineCurve)& BS,
								    Handle(TColGeom2d_HSequenceOfBoundedCurve)& seqBS) 
{
  if (BS.IsNull() || (BS->IsCN (1))) return Standard_False;
  
  Handle(Geom_BSplineCurve) BS3d = BSplineCurve2dTo3d (BS);
  Handle(TColGeom_HSequenceOfBoundedCurve) seqBS3d;
  Standard_Boolean result = C0BSplineToSequenceOfC1BSplineCurve (BS3d, seqBS3d); 
  if (result) {
    seqBS = new TColGeom2d_HSequenceOfBoundedCurve;
    for (Standard_Integer i = 1; i <= seqBS3d->Length(); i++)
      seqBS->Append (BSplineCurve3dTo2d (Handle(Geom_BSplineCurve)::DownCast (seqBS3d->Value (i))));
  }
  return result;
}
Commit	Line	Data
b311480e	1	// Created on: 1998-11-12
	2	// Created by: data exchange team
	3	// Copyright (c) 1998-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.
b311480e	16
7fd59977	17	// abv 24.05.99 S4174: methods Debug() commented
7fd59977	18
7fd59977	19	#include <BSplCLib.hxx>
42cf5bc1	20	#include <Geom2d_BSplineCurve.hxx>
ec357c5c	21	#include <Geom_BSplineCurve.hxx>
42cf5bc1	22	#include <ShapeUpgrade.hxx>
	23	#include <TColgp_Array1OfPnt.hxx>
	24	#include <TColStd_Array1OfInteger.hxx>
	25	#include <TColStd_Array1OfReal.hxx>
7fd59977	26
	27	/*
	28	// Debug state= True / False.
	29	static Standard_Boolean Dbg=Standard_False;
7fd59977	30	void ShapeUpgrade::SetDebug(const Standard_Boolean State)
	31	{
	32	Dbg=State;
	33	}
7fd59977	34	Standard_Boolean ShapeUpgrade::Debug()
	35	{
	36	return Dbg;
	37	}
	38	*/
7fd59977	39	//=======================================================================
	40	//function : C0BSplineToSequenceOfC1BSplineCurve
	41	//purpose :
	42	//=======================================================================
7fd59977	43	Standard_Boolean ShapeUpgrade::C0BSplineToSequenceOfC1BSplineCurve(const Handle(Geom_BSplineCurve)& BS,
	44	Handle(TColGeom_HSequenceOfBoundedCurve)& seqBS)
	45	{
	46	if (BS.IsNull() \|\| (BS->IsCN (1))) return Standard_False;
	47
	48	seqBS = new TColGeom_HSequenceOfBoundedCurve;
	49	BS->SetNotPeriodic(); //to have equation NbPoles = NbKnots with Multiplicities - degree - 1
	50
	51	Standard_Integer deg = BS->Degree();
	52	Standard_Integer NbKnots = BS->NbKnots();
	53	Standard_Integer NbPoles = BS->NbPoles();
	54	TColgp_Array1OfPnt Poles (1, NbPoles);
	55	TColStd_Array1OfReal Weights (1, NbPoles);
	56	TColStd_Array1OfReal Knots (1, NbKnots);
	57	TColStd_Array1OfInteger Mults (1, NbKnots);
	58	TColStd_Array1OfReal KnotSequence (1, NbPoles + deg + 1);
	59
	60	BS->Poles(Poles);
	61	if (BS->IsRational())
	62	BS->Weights(Weights);
	63	else
	64	Weights.Init(1.);
	65	BS->Knots(Knots);
	66	BS->Multiplicities(Mults);
	67	BS->KnotSequence (KnotSequence);
	68
	69	Standard_Integer StartKnotIndex, EndKnotIndex, j;
	70
	71	StartKnotIndex = BS->FirstUKnotIndex();
	72	for ( EndKnotIndex = StartKnotIndex + 1; EndKnotIndex <= BS->LastUKnotIndex(); EndKnotIndex++ ) {
	73	if ( ( Mults (EndKnotIndex) < deg ) && ( EndKnotIndex < BS->LastUKnotIndex() ) ) continue;
	74
	75	Standard_Integer StartFlatIndex = BSplCLib::FlatIndex (deg, StartKnotIndex, Mults, Standard_False);
	76	// StartFlatIndex += Mults (StartKnotIndex) - 1;
	77	Standard_Integer EndFlatIndex = BSplCLib::FlatIndex (deg, EndKnotIndex, Mults, Standard_False);
	78	EndFlatIndex -= Mults (EndKnotIndex) - 1;
	79
	80	TColStd_Array1OfReal TempKnots (1, NbKnots);
	81	TColStd_Array1OfInteger TempMults (1, NbKnots);
	82	TempMults.Init (1);
	83	Standard_Integer TempKnotIndex = 1;
	84	TempKnots (TempKnotIndex) = KnotSequence (StartFlatIndex - deg);
	85
	86	for ( j = StartFlatIndex - deg + 1; j <= EndFlatIndex + deg; j++ )
	87	if (Abs (KnotSequence (j) - KnotSequence (j - 1)) <= gp::Resolution())
	88	TempMults (TempKnotIndex) ++;
	89	else
	90	TempKnots (++TempKnotIndex) = KnotSequence (j);
	91
	92	Standard_Integer TempStartIndex = 1, TempEndIndex = TempKnotIndex;
	93	if (TempMults (TempStartIndex) == 1)
	94	TempMults (++TempStartIndex) ++;
	95	if (TempMults (TempEndIndex) == 1)
	96	TempMults (--TempEndIndex) ++;
	97
	98	Standard_Integer NewNbKnots = TempEndIndex - TempStartIndex + 1;
	99	TColStd_Array1OfInteger newMults (1, NewNbKnots);
	100	TColStd_Array1OfReal newKnots (1, NewNbKnots);
	101	for ( j = 1; j <= NewNbKnots; j++ ) {
	102	newMults (j) = TempMults (j + TempStartIndex - 1);
	103	newKnots (j) = TempKnots (j + TempStartIndex - 1);
	104	}
	105
	106	Standard_Integer NewNbPoles = BSplCLib::NbPoles(deg, Standard_False, newMults);
107	TColgp_Array1OfPnt newPoles (1, NewNbPoles);
108	TColStd_Array1OfReal newWeights (1, NewNbPoles);
109	Standard_Integer PoleIndex = StartFlatIndex - deg;//Index of starting pole when splitting B-Spline is an index of starting knot
110	for (j = 1; j <= NewNbPoles; j++) {
111	newWeights (j) = Weights (j + PoleIndex - 1);
112	newPoles (j) = Poles (j + PoleIndex - 1);
113	}
114
115	Handle(Geom_BSplineCurve) newC = new Geom_BSplineCurve
116	(newPoles, newWeights, newKnots, newMults,deg);
117	seqBS->Append (newC);
118
119	StartKnotIndex = EndKnotIndex;
120	}
121	return Standard_True;
122	}
123
124	//=======================================================================
125	//function : C0BSplineToSequenceOfC1BSplineCurve
126	//purpose :
127	//=======================================================================
128
129	static Handle(Geom_BSplineCurve) BSplineCurve2dTo3d (const Handle(Geom2d_BSplineCurve)& BS)
130	{
131	Standard_Integer deg = BS->Degree();
132	Standard_Integer NbKnots = BS->NbKnots();
133	Standard_Integer NbPoles = BS->NbPoles();
134	TColgp_Array1OfPnt2d Poles2d (1,NbPoles);
135	TColStd_Array1OfReal Weights (1,NbPoles);
136	TColStd_Array1OfReal Knots (1,NbKnots);
137	TColStd_Array1OfInteger Mults (1,NbKnots);
138
139	BS->Poles(Poles2d);
140	if (BS->IsRational())
141	BS->Weights(Weights);
142	else
143	Weights.Init (1);
144	BS->Knots (Knots);
145	BS->Multiplicities (Mults);
146
147	TColgp_Array1OfPnt Poles3d (1,NbPoles);
148	for (Standard_Integer i = 1; i <= NbPoles; i++)
149	Poles3d (i) = gp_Pnt (Poles2d (i).X(), Poles2d (i).Y(), 0);
150
151	Handle(Geom_BSplineCurve) BS3d = new Geom_BSplineCurve (Poles3d, Weights,
152	Knots, Mults, deg, BS->IsPeriodic());
153	return BS3d;
154	}
155
156	static Handle(Geom2d_BSplineCurve) BSplineCurve3dTo2d (const Handle(Geom_BSplineCurve)& BS)
157	{
158	Standard_Integer deg = BS->Degree();
159	Standard_Integer NbKnots = BS->NbKnots();
160	Standard_Integer NbPoles = BS->NbPoles();
161	TColgp_Array1OfPnt Poles3d (1, NbPoles);
162	TColStd_Array1OfReal Weights (1, NbPoles);
163	TColStd_Array1OfReal Knots (1, NbKnots);
164	TColStd_Array1OfInteger Mults (1, NbKnots);
165
166	BS->Poles(Poles3d);
167	if (BS->IsRational())
168	BS->Weights(Weights);
169	else
170	Weights.Init (1);
171	BS->Knots (Knots);
172	BS->Multiplicities (Mults);
173
174	TColgp_Array1OfPnt2d Poles2d (1,NbPoles);
175	for (Standard_Integer i = 1; i <= NbPoles; i++)
176	Poles2d (i) = gp_Pnt2d (Poles3d (i).X(), Poles3d (i).Y());
177
178	Handle(Geom2d_BSplineCurve) BS2d = new Geom2d_BSplineCurve (Poles2d, Weights,
179	Knots, Mults, deg, BS->IsPeriodic());
180	return BS2d;
181	}
182
183	Standard_Boolean ShapeUpgrade::C0BSplineToSequenceOfC1BSplineCurve(const Handle(Geom2d_BSplineCurve)& BS,
184	Handle(TColGeom2d_HSequenceOfBoundedCurve)& seqBS)
185	{
186	if (BS.IsNull() \|\| (BS->IsCN (1))) return Standard_False;
187
188	Handle(Geom_BSplineCurve) BS3d = BSplineCurve2dTo3d (BS);
189	Handle(TColGeom_HSequenceOfBoundedCurve) seqBS3d;
190	Standard_Boolean result = C0BSplineToSequenceOfC1BSplineCurve (BS3d, seqBS3d);
191	if (result) {
192	seqBS = new TColGeom2d_HSequenceOfBoundedCurve;
193	for (Standard_Integer i = 1; i <= seqBS3d->Length(); i++)
194	seqBS->Append (BSplineCurve3dTo2d (Handle(Geom_BSplineCurve)::DownCast (seqBS3d->Value (i))));
195	}
196	return result;
197	}
198