mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-08-19 13:40:49 +03:00
b9280b8b27
Removed unused exception classes OSD_Exception_FLT_DIVIDE_BY_ZERO, OSD_Exception_INT_DIVIDE_BY_ZERO, OSD_Exception_FLT_DENORMAL_OPERAND, OSD_Exception_FLT_INEXACT_RESULT, OSD_Exception_FLT_INVALID_OPERATION, OSD_Exception_FLT_OVERFLOW, OSD_Exception_FLT_STACK_CHECK, OSD_Exception_FLT_UNDERFLOW.
649 lines
20 KiB
C++
649 lines
20 KiB
C++
// Created on: 1995-11-16
|
|
// Created by: Laurent BOURESCHE
|
|
// Copyright (c) 1995-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.
|
|
|
|
// Programme cree
|
|
|
|
#include <BSplCLib.hxx>
|
|
#include <Law_BSpline.hxx>
|
|
#include <Law_Interpolate.hxx>
|
|
#include <PLib.hxx>
|
|
#include <Standard_ConstructionError.hxx>
|
|
#include <StdFail_NotDone.hxx>
|
|
#include <TColStd_Array1OfBoolean.hxx>
|
|
#include <TColStd_Array1OfInteger.hxx>
|
|
|
|
//=======================================================================
|
|
//function : CheckParameters
|
|
//purpose :
|
|
//=======================================================================
|
|
static Standard_Boolean CheckParameters
|
|
(const TColStd_Array1OfReal& Parameters)
|
|
{
|
|
Standard_Integer ii;
|
|
Standard_Real distance;
|
|
Standard_Boolean result = Standard_True;
|
|
for (ii = Parameters.Lower() ; result && ii < Parameters.Upper() ; ii++) {
|
|
distance = Parameters.Value(ii+1) - Parameters.Value(ii);
|
|
result = (distance >= RealSmall());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : BuildParameters
|
|
//purpose :
|
|
//=======================================================================
|
|
static void BuildParameters(const Standard_Boolean PeriodicFlag,
|
|
const TColStd_Array1OfReal& PointsArray,
|
|
Handle(TColStd_HArray1OfReal)& ParametersPtr)
|
|
{
|
|
Standard_Integer ii, index = 2;
|
|
Standard_Real distance;
|
|
Standard_Integer num_parameters = PointsArray.Length();
|
|
if (PeriodicFlag) {
|
|
num_parameters += 1;
|
|
}
|
|
ParametersPtr = new TColStd_HArray1OfReal(1, num_parameters);
|
|
ParametersPtr->SetValue(1,0.);
|
|
for (ii = PointsArray.Lower(); ii < PointsArray.Upper(); ii++) {
|
|
distance = Abs(PointsArray.Value(ii) - PointsArray.Value(ii+1));
|
|
ParametersPtr->SetValue(index, ParametersPtr->Value(ii) + distance);
|
|
index += 1 ;
|
|
}
|
|
if (PeriodicFlag) {
|
|
distance = Abs(PointsArray.Value(PointsArray.Upper()) -
|
|
PointsArray.Value(PointsArray.Lower()));
|
|
ParametersPtr->SetValue(index, ParametersPtr->Value(ii) + distance);
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : BuildPeriodicTangents
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
static void BuildPeriodicTangent
|
|
(const TColStd_Array1OfReal& PointsArray,
|
|
TColStd_Array1OfReal& TangentsArray,
|
|
TColStd_Array1OfBoolean& TangentFlags,
|
|
const TColStd_Array1OfReal& ParametersArray)
|
|
{
|
|
Standard_Real point_array[3], parameter_array[3], eval_result[2];
|
|
|
|
if (PointsArray.Length() < 2) {
|
|
TangentFlags.SetValue(1,Standard_True);
|
|
TangentsArray.SetValue(1,0.);
|
|
}
|
|
else if (!TangentFlags.Value(1)){
|
|
//Pour les periodiques on evalue la tangente du point de fermeture
|
|
//par une interpolation de degre 2 entre le dernier point, le point
|
|
//de fermeture et le deuxieme point.
|
|
Standard_Integer degree = 2;
|
|
Standard_Real period = (ParametersArray.Value(ParametersArray.Upper()) -
|
|
ParametersArray.Value(ParametersArray.Lower()));
|
|
point_array [0] = PointsArray.Value(PointsArray.Upper());
|
|
point_array [1] = PointsArray.Value(PointsArray.Lower());
|
|
point_array [2] = PointsArray.Value(PointsArray.Lower()+1);
|
|
parameter_array[0] = ParametersArray.Value(ParametersArray.Upper() - 1) - period;
|
|
parameter_array[1] = ParametersArray.Value(ParametersArray.Lower());
|
|
parameter_array[2] = ParametersArray.Value(ParametersArray.Lower() + 1);
|
|
TangentFlags.SetValue(1,Standard_True);
|
|
PLib::EvalLagrange(parameter_array[1],
|
|
1,
|
|
degree,
|
|
1,
|
|
point_array[0],
|
|
parameter_array[0],
|
|
eval_result[0]);
|
|
TangentsArray.SetValue(1,eval_result[1]);
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : BuildTangents
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
static void BuildTangents(const TColStd_Array1OfReal& PointsArray,
|
|
TColStd_Array1OfReal& TangentsArray,
|
|
TColStd_Array1OfBoolean& TangentFlags,
|
|
const TColStd_Array1OfReal& ParametersArray)
|
|
{
|
|
Standard_Integer degree = 3;//,ii;
|
|
Standard_Real *point_array, *parameter_array, eval_result[2];
|
|
|
|
if ( PointsArray.Length() < 3) {
|
|
throw Standard_ConstructionError();
|
|
}
|
|
if (PointsArray.Length() == 3) {
|
|
degree = 2;
|
|
}
|
|
if (!TangentFlags.Value(1)) {
|
|
point_array = (Standard_Real *) &PointsArray.Value(PointsArray.Lower());
|
|
parameter_array = (Standard_Real *) &ParametersArray.Value(1);
|
|
TangentFlags.SetValue(1,Standard_True);
|
|
PLib::EvalLagrange(ParametersArray.Value(1),
|
|
1,
|
|
degree,
|
|
1,
|
|
point_array[0],
|
|
parameter_array[0],
|
|
eval_result[0]);
|
|
TangentsArray.SetValue(1,eval_result[1]);
|
|
}
|
|
if (! TangentFlags.Value(TangentFlags.Upper())) {
|
|
point_array =
|
|
(Standard_Real *) &PointsArray.Value(PointsArray.Upper() - degree);
|
|
TangentFlags.SetValue(TangentFlags.Upper(),Standard_True);
|
|
Standard_Integer iup = ParametersArray.Upper() - degree;
|
|
parameter_array = (Standard_Real *) &ParametersArray.Value(iup);
|
|
PLib::EvalLagrange(ParametersArray.Value(ParametersArray.Upper()),
|
|
1,
|
|
degree,
|
|
1,
|
|
point_array[0],
|
|
parameter_array[0],
|
|
eval_result[0]);
|
|
TangentsArray.SetValue(TangentsArray.Upper(),eval_result[1]);
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Law_Interpolate
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
Law_Interpolate::Law_Interpolate
|
|
(const Handle(TColStd_HArray1OfReal)& PointsPtr,
|
|
const Standard_Boolean PeriodicFlag,
|
|
const Standard_Real Tolerance) :
|
|
myTolerance(Tolerance),
|
|
myPoints(PointsPtr),
|
|
myIsDone(Standard_False),
|
|
myPeriodic(PeriodicFlag),
|
|
myTangentRequest(Standard_False)
|
|
|
|
{
|
|
//Standard_Integer ii;
|
|
myTangents = new TColStd_HArray1OfReal (myPoints->Lower(),
|
|
myPoints->Upper());
|
|
myTangentFlags = new TColStd_HArray1OfBoolean(myPoints->Lower(),
|
|
myPoints->Upper());
|
|
|
|
BuildParameters(PeriodicFlag,
|
|
PointsPtr->Array1(),
|
|
myParameters);
|
|
myTangentFlags->Init(Standard_False);
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Law_Interpolate
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
Law_Interpolate::Law_Interpolate
|
|
(const Handle(TColStd_HArray1OfReal)& PointsPtr,
|
|
const Handle(TColStd_HArray1OfReal)& ParametersPtr,
|
|
const Standard_Boolean PeriodicFlag,
|
|
const Standard_Real Tolerance) :
|
|
myTolerance(Tolerance),
|
|
myPoints(PointsPtr),
|
|
myIsDone(Standard_False),
|
|
myParameters(ParametersPtr),
|
|
myPeriodic(PeriodicFlag),
|
|
myTangentRequest(Standard_False)
|
|
{
|
|
//Standard_Integer ii;
|
|
if (PeriodicFlag) {
|
|
if ((PointsPtr->Length()) + 1 != ParametersPtr->Length()) {
|
|
throw Standard_ConstructionError();
|
|
}
|
|
}
|
|
myTangents = new TColStd_HArray1OfReal(myPoints->Lower(),
|
|
myPoints->Upper());
|
|
myTangentFlags = new TColStd_HArray1OfBoolean(myPoints->Lower(),
|
|
myPoints->Upper());
|
|
Standard_Boolean result = CheckParameters(ParametersPtr->Array1());
|
|
if (!result) {
|
|
throw Standard_ConstructionError();
|
|
}
|
|
myTangentFlags->Init(Standard_False);
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Load
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void Law_Interpolate::Load
|
|
(const TColStd_Array1OfReal& Tangents,
|
|
const Handle(TColStd_HArray1OfBoolean)& TangentFlagsPtr)
|
|
{
|
|
//Standard_Boolean result;
|
|
Standard_Integer ii;
|
|
myTangentRequest = Standard_True;
|
|
myTangentFlags = TangentFlagsPtr;
|
|
if (Tangents.Length() != myPoints->Length() ||
|
|
TangentFlagsPtr->Length() != myPoints->Length()) {
|
|
throw Standard_ConstructionError();
|
|
}
|
|
myTangents = new TColStd_HArray1OfReal(Tangents.Lower(),Tangents.Upper());
|
|
for (ii = Tangents.Lower() ; ii <= Tangents.Upper() ; ii++ ) {
|
|
myTangents->SetValue(ii,Tangents.Value(ii));
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Load
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void Law_Interpolate::Load(const Standard_Real InitialTangent,
|
|
const Standard_Real FinalTangent)
|
|
{
|
|
//Standard_Boolean result;
|
|
myTangentRequest = Standard_True;
|
|
myTangentFlags->SetValue(1,Standard_True);
|
|
myTangents->SetValue(1,InitialTangent);
|
|
myTangentFlags->SetValue(myPoints->Length(),Standard_True);
|
|
myTangents->SetValue(myPoints->Length(),FinalTangent) ;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Perform
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void Law_Interpolate::Perform()
|
|
{
|
|
if (myPeriodic) {
|
|
PerformPeriodic();
|
|
}
|
|
else {
|
|
PerformNonPeriodic();
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : PerformPeriodic
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void Law_Interpolate::PerformPeriodic()
|
|
{
|
|
Standard_Integer degree,
|
|
ii,
|
|
//jj,
|
|
index,
|
|
index1,
|
|
//index2,
|
|
mult_index,
|
|
half_order,
|
|
inversion_problem,
|
|
num_points,
|
|
num_distinct_knots,
|
|
num_poles;
|
|
|
|
Standard_Real period;
|
|
|
|
//gp_Pnt a_point;
|
|
|
|
num_points = myPoints->Length();
|
|
period = myParameters->Value(myParameters->Upper()) -
|
|
myParameters->Value(myParameters->Lower()) ;
|
|
num_poles = num_points + 1 ;
|
|
num_distinct_knots = num_points + 1;
|
|
half_order = 2;
|
|
degree = 3;
|
|
num_poles += 2;
|
|
if (myTangentRequest) {
|
|
for (ii = myTangentFlags->Lower() + 1;
|
|
ii <= myTangentFlags->Upper(); ii++) {
|
|
if (myTangentFlags->Value(ii)) {
|
|
num_poles += 1;
|
|
}
|
|
}
|
|
}
|
|
TColStd_Array1OfReal parameters(1,num_poles);
|
|
TColStd_Array1OfReal flatknots(1,num_poles + degree + 1);
|
|
TColStd_Array1OfInteger mults(1,num_distinct_knots);
|
|
TColStd_Array1OfInteger contact_order_array(1, num_poles);
|
|
TColStd_Array1OfReal poles(1,num_poles);
|
|
|
|
for (ii = 1 ; ii <= half_order ; ii++) {
|
|
flatknots.SetValue(ii,myParameters->Value(myParameters->Upper() -1) -
|
|
period);
|
|
flatknots.SetValue(ii + half_order,myParameters->
|
|
Value(myParameters->Lower()));
|
|
flatknots.SetValue(num_poles + ii,
|
|
myParameters->Value(myParameters->Upper()));
|
|
flatknots.SetValue(num_poles + half_order + ii,
|
|
myParameters->Value(half_order) + period);
|
|
}
|
|
for (ii = 1 ; ii <= num_poles ; ii++) {
|
|
contact_order_array.SetValue(ii,0) ;
|
|
}
|
|
for (ii = 2; ii < num_distinct_knots; ii++) {
|
|
mults.SetValue(ii,1);
|
|
}
|
|
mults.SetValue(1,half_order);
|
|
mults.SetValue(num_distinct_knots ,half_order);
|
|
|
|
BuildPeriodicTangent(myPoints->Array1(),
|
|
myTangents->ChangeArray1(),
|
|
myTangentFlags->ChangeArray1(),
|
|
myParameters->Array1());
|
|
|
|
contact_order_array.SetValue(2,1);
|
|
parameters.SetValue(1,myParameters->Value(1));
|
|
parameters.SetValue(2,myParameters->Value(1));
|
|
poles.SetValue(1,myPoints->Value(1));
|
|
poles.SetValue(2,myTangents->Value(1));
|
|
mult_index = 2;
|
|
index = 3;
|
|
index1 = degree + 2;
|
|
if (myTangentRequest) {
|
|
for (ii = myTangentFlags->Lower() + 1;
|
|
ii <= myTangentFlags->Upper(); ii++) {
|
|
parameters.SetValue(index,myParameters->Value(ii));
|
|
flatknots.SetValue(index1,myParameters->Value(ii));
|
|
poles.SetValue(index,myPoints->Value(ii));
|
|
index += 1;
|
|
index1 += 1;
|
|
if (myTangentFlags->Value(ii)) {
|
|
mults.SetValue(mult_index,mults.Value(mult_index) + 1);
|
|
contact_order_array(index) = 1;
|
|
|
|
parameters.SetValue(index,
|
|
myParameters->Value(ii));
|
|
flatknots.SetValue(index1,myParameters->Value(ii));
|
|
poles.SetValue(index,myTangents->Value(ii));
|
|
index += 1;
|
|
index1 += 1;
|
|
}
|
|
mult_index += 1;
|
|
}
|
|
}
|
|
else {
|
|
index = degree + 1;
|
|
index1 = 2 ;
|
|
for(ii = myParameters->Lower(); ii <= myParameters->Upper(); ii++) {
|
|
parameters.SetValue(index1, myParameters->Value(ii));
|
|
flatknots.SetValue(index, myParameters->Value(ii));
|
|
index += 1;
|
|
index1 += 1;
|
|
}
|
|
index = 3;
|
|
for (ii = myPoints->Lower() + 1; ii <= myPoints->Upper(); ii++) {
|
|
//
|
|
// copy all the given points since the last one will be initialized
|
|
// below by the first point in the array myPoints
|
|
//
|
|
poles.SetValue(index, myPoints->Value(ii));
|
|
index += 1;
|
|
}
|
|
}
|
|
contact_order_array.SetValue(num_poles - 1, 1);
|
|
parameters.SetValue(num_poles-1,
|
|
myParameters->Value(myParameters->Upper()));
|
|
//
|
|
// for the periodic curve ONLY the tangent of the first point
|
|
// will be used since the curve should close itself at the first
|
|
// point See BuildPeriodicTangent
|
|
//
|
|
poles.SetValue(num_poles-1,myTangents->Value(1));
|
|
parameters.SetValue(num_poles,
|
|
myParameters->Value(myParameters->Upper()));
|
|
poles.SetValue(num_poles,
|
|
myPoints->Value(1));
|
|
|
|
BSplCLib::Interpolate(degree,
|
|
flatknots,
|
|
parameters,
|
|
contact_order_array,
|
|
1,
|
|
poles(1),
|
|
inversion_problem);
|
|
if (!inversion_problem) {
|
|
TColStd_Array1OfReal newpoles(poles.Value(1),
|
|
1,
|
|
num_poles - 2) ;
|
|
myCurve = new Law_BSpline(newpoles,
|
|
myParameters->Array1(),
|
|
mults,
|
|
degree,
|
|
myPeriodic);
|
|
myIsDone = Standard_True;
|
|
}
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
//function : PerformNonPeriodic
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void Law_Interpolate::PerformNonPeriodic()
|
|
{
|
|
Standard_Integer degree,
|
|
ii,
|
|
//jj,
|
|
index,
|
|
index1,
|
|
index2,
|
|
index3,
|
|
mult_index,
|
|
inversion_problem,
|
|
num_points,
|
|
num_distinct_knots,
|
|
num_poles;
|
|
|
|
num_points =
|
|
num_distinct_knots =
|
|
num_poles = myPoints->Length();
|
|
if (num_poles == 2 && !myTangentRequest) {
|
|
degree = 1;
|
|
}
|
|
else if (num_poles == 3 && !myTangentRequest) {
|
|
degree = 2;
|
|
num_distinct_knots = 2;
|
|
}
|
|
else {
|
|
degree = 3;
|
|
num_poles += 2;
|
|
if (myTangentRequest) {
|
|
for (ii = myTangentFlags->Lower() + 1;
|
|
ii < myTangentFlags->Upper(); ii++) {
|
|
if (myTangentFlags->Value(ii)) {
|
|
num_poles += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
TColStd_Array1OfReal parameters(1,num_poles) ;
|
|
TColStd_Array1OfReal flatknots(1,num_poles + degree + 1) ;
|
|
TColStd_Array1OfInteger mults(1,num_distinct_knots) ;
|
|
TColStd_Array1OfReal knots(1,num_distinct_knots) ;
|
|
TColStd_Array1OfInteger contact_order_array(1, num_poles) ;
|
|
TColStd_Array1OfReal poles(1,num_poles) ;
|
|
|
|
for (ii = 1 ; ii <= degree + 1 ; ii++) {
|
|
flatknots.SetValue(ii,myParameters->Value(1));
|
|
flatknots.SetValue(ii + num_poles,
|
|
myParameters->Value(num_points));
|
|
}
|
|
for (ii = 1 ; ii <= num_poles ; ii++) {
|
|
contact_order_array.SetValue(ii,0);
|
|
}
|
|
for (ii = 2 ; ii < num_distinct_knots ; ii++) {
|
|
mults.SetValue(ii,1);
|
|
}
|
|
mults.SetValue(1,degree + 1);
|
|
mults.SetValue(num_distinct_knots ,degree + 1);
|
|
|
|
switch (degree) {
|
|
case 1:
|
|
for (ii = 1 ; ii <= num_poles ; ii++) {
|
|
poles.SetValue(ii ,myPoints->Value(ii));
|
|
}
|
|
myCurve =
|
|
new Law_BSpline(poles,
|
|
myParameters->Array1(),
|
|
mults,
|
|
degree) ;
|
|
myIsDone = Standard_True ;
|
|
break ;
|
|
case 2:
|
|
knots.SetValue(1,myParameters->Value(1)) ;
|
|
knots.SetValue(2,myParameters->Value(num_poles)) ;
|
|
for (ii = 1 ; ii <= num_poles ; ii++) {
|
|
poles.SetValue(ii,myPoints->Value(ii)) ;
|
|
|
|
}
|
|
BSplCLib::Interpolate(degree,
|
|
flatknots,
|
|
myParameters->Array1(),
|
|
contact_order_array,
|
|
1,
|
|
poles(1),
|
|
inversion_problem) ;
|
|
if (!inversion_problem) {
|
|
myCurve = new Law_BSpline(poles,
|
|
knots,
|
|
mults,
|
|
degree);
|
|
myIsDone = Standard_True;
|
|
}
|
|
break;
|
|
case 3:
|
|
//
|
|
// check if the boundary conditions are set
|
|
//
|
|
if (num_points >= 3) {
|
|
//
|
|
// cannot build the tangents with degree 3 with only 2 points
|
|
// if those where not given in advance
|
|
//
|
|
BuildTangents(myPoints->Array1(),
|
|
myTangents->ChangeArray1(),
|
|
myTangentFlags->ChangeArray1(),
|
|
myParameters->Array1()) ;
|
|
}
|
|
contact_order_array.SetValue(2,1);
|
|
parameters.SetValue(1,myParameters->Value(1));
|
|
parameters.SetValue(2,myParameters->Value(1));
|
|
poles.SetValue(1,myPoints->Value(1));
|
|
poles.SetValue(2,myTangents->Value(1));
|
|
mult_index = 2 ;
|
|
index = 3 ;
|
|
index1 = 2 ;
|
|
index2 = myPoints->Lower() + 1 ;
|
|
index3 = degree + 2 ;
|
|
if (myTangentRequest) {
|
|
for (ii = myParameters->Lower() + 1 ;
|
|
ii < myParameters->Upper() ; ii++) {
|
|
parameters.SetValue(index,myParameters->Value(ii)) ;
|
|
poles.SetValue(index,myPoints->Value(index2)) ;
|
|
flatknots.SetValue(index3,myParameters->Value(ii)) ;
|
|
index += 1 ;
|
|
index3 += 1 ;
|
|
if (myTangentFlags->Value(index1)) {
|
|
//
|
|
// set the multiplicities, the order of the contact, the
|
|
// the flatknots,
|
|
//
|
|
mults.SetValue(mult_index,mults.Value(mult_index) + 1) ;
|
|
contact_order_array(index) = 1 ;
|
|
flatknots.SetValue(index3, myParameters->Value(ii)) ;
|
|
parameters.SetValue(index,
|
|
myParameters->Value(ii));
|
|
poles.SetValue(index,myTangents->Value(ii));
|
|
index += 1 ;
|
|
index3 += 1 ;
|
|
}
|
|
mult_index += 1 ;
|
|
index1 += 1 ;
|
|
index2 += 1 ;
|
|
}
|
|
}
|
|
else {
|
|
index1 = 2 ;
|
|
for(ii = myParameters->Lower(); ii <= myParameters->Upper(); ii++) {
|
|
parameters.SetValue(index1, myParameters->Value(ii));
|
|
index1 += 1;
|
|
}
|
|
index = 3 ;
|
|
for (ii = myPoints->Lower() + 1; ii <= myPoints->Upper() - 1; ii++){
|
|
poles.SetValue(index, myPoints->Value(ii));
|
|
index += 1 ;
|
|
}
|
|
index = degree + 1;
|
|
for(ii = myParameters->Lower(); ii <= myParameters->Upper(); ii++){
|
|
flatknots.SetValue(index, myParameters->Value(ii));
|
|
index += 1 ;
|
|
}
|
|
}
|
|
poles.SetValue(num_poles-1, myTangents->Value(num_points));
|
|
|
|
contact_order_array.SetValue(num_poles - 1, 1);
|
|
parameters.SetValue(num_poles,
|
|
myParameters->Value(myParameters->Upper())) ;
|
|
parameters.SetValue(num_poles -1,
|
|
myParameters->Value(myParameters->Upper())) ;
|
|
|
|
poles.SetValue(num_poles,
|
|
myPoints->Value(num_points)) ;
|
|
|
|
BSplCLib::Interpolate(degree,
|
|
flatknots,
|
|
parameters,
|
|
contact_order_array,
|
|
1,
|
|
poles(1),
|
|
inversion_problem) ;
|
|
if (!inversion_problem) {
|
|
myCurve = new Law_BSpline(poles,
|
|
myParameters->Array1(),
|
|
mults,
|
|
degree) ;
|
|
myIsDone = Standard_True;
|
|
}
|
|
break ;
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Handle(Geom_BSplineCurve)&
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
const Handle(Law_BSpline)& Law_Interpolate::Curve() const
|
|
{
|
|
if ( !myIsDone)
|
|
throw StdFail_NotDone(" ");
|
|
return myCurve;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : IsDone
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
Standard_Boolean Law_Interpolate::IsDone() const
|
|
{
|
|
return myIsDone;
|
|
}
|