lili/opennurbs
1
0
Fork 0
mirror of https://github.com/mcneel/opennurbs.git synced 2026-03-02 03:57:00 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
01cdb463e645a2f0829dd87bb1fe29b5bb5bc306
opennurbs/opennurbs_offsetsurface.cpp
Will Pearson 98797aac6e Normalise line endings (unix)
2019-04-09 10:11:17 -07:00

889 lines
21 KiB
C++
Raw Blame History

/* $NoKeywords: $ */
/*
//
// Copyright (c) 1993-2012 Robert McNeel & Associates. All rights reserved.
// OpenNURBS, Rhinoceros, and Rhino3D are registered trademarks of Robert
// McNeel & Associates.
//
// THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
// ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF
// MERCHANTABILITY ARE HEREBY DISCLAIMED.
//
// For complete openNURBS copyright information see <http://www.opennurbs.org>.
//
////////////////////////////////////////////////////////////////
*/
#include "opennurbs.h"
#if !defined(ON_COMPILING_OPENNURBS)
// This check is included in all opennurbs source .c and .cpp files to insure
// ON_COMPILING_OPENNURBS is defined when opennurbs source is compiled.
// When opennurbs source is being compiled, ON_COMPILING_OPENNURBS is defined
// and the opennurbs .h files alter what is declared and how it is declared.
#error ON_COMPILING_OPENNURBS must be defined when compiling opennurbs
#endif
ON_OBJECT_IMPLEMENT(ON_OffsetSurface,ON_SurfaceProxy,"00C61749-D430-4ecc-83A8-29130A20CF9C");
ON_OffsetSurface::ON_OffsetSurface()
: m__pSrf(0)
{
}
ON_OffsetSurface::~ON_OffsetSurface()
{
m_offset_function.SetBaseSurface( 0 );
if ( 0 != m__pSrf && this != m__pSrf )
delete m__pSrf;
m__pSrf = 0;
}
ON_OffsetSurface::ON_OffsetSurface( const ON_OffsetSurface& src)
: ON_SurfaceProxy(src),
m__pSrf(0),
m_offset_function(src.m_offset_function)
{
if ( 0 != src.m__pSrf )
{
m__pSrf = src.ON_SurfaceProxy::DuplicateSurface();
SetProxySurface(m__pSrf);
}
m_offset_function.SetBaseSurface( BaseSurface() );
}
ON_OffsetSurface& ON_OffsetSurface::operator=(const ON_OffsetSurface& src)
{
if ( this != &src )
{
if ( 0 != m__pSrf && this != m__pSrf )
delete m__pSrf;
m__pSrf = 0;
if ( 0 != src.m__pSrf )
{
m__pSrf = src.ON_SurfaceProxy::DuplicateSurface();
SetProxySurface(m__pSrf);
}
else
{
ON_SurfaceProxy::operator=(src);
}
m_offset_function = src.m_offset_function;
m_offset_function.SetBaseSurface( BaseSurface() );
}
return *this;
}
ON_OffsetSurfaceFunction& ON_OffsetSurface::OffsetFunction()
{
return m_offset_function;
}
const ON_OffsetSurfaceFunction& ON_OffsetSurface::OffsetFunction() const
{
return m_offset_function;
}
bool ON_OffsetSurface::SetBaseSurface(
const ON_Surface* base_surface
)
{
bool rc = false;
if ( this != base_surface )
{
rc = true;
if ( 0 == base_surface )
{
if ( 0 != m__pSrf && this != m__pSrf )
delete m__pSrf;
m__pSrf = 0;
ON_SurfaceProxy::SetProxySurface(0);
m_offset_function.SetBaseSurface(0);
}
else if ( BaseSurface() != base_surface )
{
if ( 0 != m__pSrf && this != m__pSrf )
delete m__pSrf;
m__pSrf = 0;
ON_SurfaceProxy::SetProxySurface(base_surface);
}
m_offset_function.SetBaseSurface( BaseSurface() );
}
return rc;
}
bool ON_OffsetSurface::SetBaseSurface(
ON_Surface* base_surface,
bool bManage
)
{
bool rc = SetBaseSurface(base_surface);
if (rc && bManage )
m__pSrf = base_surface;
return rc;
}
const ON_Surface* ON_OffsetSurface::BaseSurface() const
{
return ProxySurface();
}
bool ON_OffsetSurface::GetBBox(
double* bbox_min,
double* bbox_max,
bool bGrowBox
) const
{
bool rc = ON_SurfaceProxy::GetBBox(bbox_min,bbox_max);
if ( rc )
{
double d, distance = 0.0;
int i, count = m_offset_function.m_offset_value.Count();
for ( i = 0; i < count; i++ )
{
d = fabs(m_offset_function.m_offset_value[i].m_distance);
if ( distance < d)
distance = d;
}
distance *= 2;
if ( 0 != bbox_min )
{
bbox_min[0] -= distance;
bbox_min[1] -= distance;
bbox_min[2] -= distance;
}
if ( 0 != bbox_max )
{
bbox_max[0] += distance;
bbox_max[1] += distance;
bbox_max[2] += distance;
}
}
return rc;
}
bool ON_OffsetSurface::Evaluate(
double s, double t,
int der_count,
int v_stride,
double* v,
int side,
int* hint
) const
{
int vv_stride = v_stride;
double* vv = v;
ON_3dVector srf_value[6];//, normal_value[3];
if ( der_count < 2 )
{
vv = &srf_value[0].x;
vv_stride = 3;
}
bool rc = ON_SurfaceProxy::Evaluate(s,t,(der_count>2?der_count:2),vv_stride,vv,side,hint);
if ( v != vv )
{
// save answer in v[] array
v[0] = srf_value[0].x;
v[1] = srf_value[0].y;
v[2] = srf_value[0].z;
if ( der_count > 0 )
{
v[v_stride] = srf_value[1].x;
v[v_stride+1] = srf_value[1].y;
v[v_stride+2] = srf_value[1].z;
v[2*v_stride] = srf_value[2].x;
v[2*v_stride+1] = srf_value[2].y;
v[2*v_stride+2] = srf_value[2].z;
}
}
else
{
srf_value[0] = v;
srf_value[1] = v+v_stride;
srf_value[2] = v+2*v_stride;
srf_value[3] = v+3*v_stride;
srf_value[4] = v+4*v_stride;
srf_value[5] = v+5*v_stride;
}
if (rc)
{
double darray[21]; // 21 = ((5+1)*(5+2)/2) = enough room for der_count <= 5
double* d = (der_count>5)
? (double*)onmalloc(((der_count+1)*(der_count+2))/2*sizeof(d[0]))
: darray;
rc = m_offset_function.EvaluateDistance(s,t,der_count,d);
if (rc)
{
ON_3dVector N;
ON_EvNormal(side,
srf_value[1], srf_value[2],
srf_value[3], srf_value[4], srf_value[5],
N);
v[0] += d[0]*N.x;
v[1] += d[0]*N.y;
v[2] += d[0]*N.z;
if ( der_count > 0 )
{
ON_3dVector Ns, Nt;
ON_EvNormalPartials(srf_value[1], srf_value[2],
srf_value[3], srf_value[4], srf_value[5],
Ns, Nt);
v[v_stride] += d[0]*Ns.x + d[1]*N.x;
v[v_stride+1] += d[0]*Ns.y + d[1]*N.y;
v[v_stride+2] += d[0]*Ns.z + d[1]*N.z;
v[2*v_stride] += d[0]*Nt.x + d[2]*N.x;
v[2*v_stride+1] += d[0]*Nt.y + d[2]*N.y;
v[2*v_stride+2] += d[0]*Nt.z + d[2]*N.z;
}
}
if ( d != darray )
onfree(d);
}
return rc;
}
void ON_BumpFunction::Internal_EvaluateLinearBump(double t, double dt, int der_count, double* value) const
{
value[0] = t;
if (der_count>0)
{
value[1] = dt;
if ( der_count > 1 )
{
der_count--;
value += 2;
while(der_count--)
*value++ = 0.0;
}
}
}
void ON_BumpFunction::Internal_EvaluateQuinticBump(double t, double dt, int der_count, double* value) const
{
// c(t) = (1-t)^3 * (1 + 3t + 6t^2)
//bool neg = (t<0.0);
//t = fabs(t);
if ( fabs(t) < 1.0)
{
double a2 = (1-t);
double a1 = a2*a2;
double a = a1*a2;
double b = 1.0 + t*(3.0 + 6.0*t);
value[0] = a*b;
if (der_count>0)
{
a1 *= -3.0;
double b1 = 3.0 + 12.0*t;
value[1] = dt*(a1*b + b1*a);
//if ( neg )
// value[1] = - value[1];
if ( der_count > 1 )
{
value[2] = dt*dt*(6.0*a2*b + 12.0*a + 2.0*a1*b1);
if ( der_count > 2 )
{
der_count-=2;
value += 3;
while ( der_count-- )
*value++ = 0.0;
}
}
}
}
else
{
while ( der_count-- >= 0 )
*value++ = 0.0;
}
}
/*
double EvaluateCubicBump(double t, double* d, double* dd) const
{
// c(t) = 1 - 3t^2 + 2t^3
// CubicBump(t) = c(t) if 0 <= t < 1
// c(-t) if -1 < t <= 0
// 0 otherwise
bool neg = (t<0.0);
t = fabs(t);
if ( t < 1.0)
{
// f(t) = 1 - 3t^2 + 2t^3
if (d)
{
// f'(t) = -6t + 6t^2
*d = (neg) ? (6.0*t*(1.0-t)) : (6.0*t*(t-1.0));
}
if (dd)
{
// f"(t) = -6 + 12t
*dd = -6.0 + 12.0*t;
}
t = 1.0+t*(t*(2.0*t-3.0));
}
else
{
t = 0.0;
if ( d )
*d = 0.0
if ( *dd )
*dd = 0.0
}
return t
}
*/
void ON_BumpFunction::Evaluate(double s, double t, int der_count, double* value) const
{
double tmp[20];
double* xvalue;
double* yvalue;
xvalue = ( der_count > 9 )
? ((double*)onmalloc((der_count+1)*2*sizeof(xvalue[0])))
: &tmp[0];
yvalue = xvalue + (der_count+1);
double x = s-m_x0;
const double dx = m_sx[x >= 0.0 ? 1 : 0];
x *= dx;
double y = t-m_y0;
const double dy = m_sy[y >= 0.0 ? 1 : 0];
y *= dy;
if ( 5 == m_type[0] )
{
Internal_EvaluateQuinticBump(x,dx,der_count,xvalue);
}
else
{
Internal_EvaluateLinearBump(x,dx,der_count,xvalue);
}
if ( 5 == m_type[1] )
{
Internal_EvaluateQuinticBump(y,dy,der_count,yvalue);
}
else
{
Internal_EvaluateLinearBump(y,dy,der_count,yvalue);
}
int n, i, j;
for ( n = 0; n <= der_count; n++ )
{
for ( i = n, j = 0; j <= n; i--, j++ )
{
*value++ = m_a*xvalue[i]*yvalue[j]; // d^nf/(ds^i dt^j)
}
}
}
bool ON_OffsetSurfaceFunction::SetBaseSurface( const ON_Surface* srf )
{
bool rc = false;
Destroy();
m_srf = srf;
if ( 0 != m_srf )
{
m_domain[0] = m_srf->Domain(0);
m_domain[1] = m_srf->Domain(1);
rc = m_domain[0].IsIncreasing() && m_domain[1].IsIncreasing();
if ( !rc )
Destroy();
}
return rc;
}
bool ON_OffsetSurfaceFunction::SetSideTangency(
int side,
bool bEnable
)
{
bool rc = false;
if ( 0 <= side && side < 4 )
{
m_bZeroSideDerivative[side] = bEnable?true:false;
m_bValid = false;
rc = true;
}
return rc;
}
bool ON_OffsetSurfaceFunction::SideTangency(int side) const
{
bool rc = ( 0 <= side && side < 4 )
? m_bZeroSideDerivative[side]
: false;
return rc;
}
int ON_OffsetSurfaceFunction::OffsetPointCount() const
{
return (0 != m_srf) ? m_offset_value.Count() : 0;
}
double ON_OffsetSurfaceFunction::DistanceAt(
double s,
double t
) const
{
double d = 0.0;
EvaluateDistance( s, t, 0, &d );
return d;
}
bool ON_OffsetSurfaceFunction::EvaluateDistance(
double s,
double t,
int num_der,
double* value
) const
{
const int vcnt = ((num_der+1)*(num_der+2))/2;
for ( int vi = 0; vi < vcnt; vi++ )
{
value[vi] = 0;
}
bool rc = const_cast<ON_OffsetSurfaceFunction*>(this)->Initialize();
if (rc)
{
double barray[21];
double* bump_value = (vcnt > 21)
? (double*)onmalloc(vcnt*sizeof(bump_value[0]))
: barray;
const int bump_count = m_bumps.Count();
int bump_index;
for ( bump_index = 0; bump_index < bump_count; bump_index++ )
{
m_bumps[bump_index].Evaluate( s, t, num_der, bump_value );
for ( int vi = 0; vi < vcnt; vi++ )
{
value[vi] += bump_value[vi];
}
}
if ( bump_value != barray )
onfree(bump_value);
}
return rc;
}
ON_3dPoint ON_OffsetSurfaceFunction::PointAt(
double s,
double t
) const
{
//double d = 0.0;
ON_3dPoint P(ON_3dPoint::NanPoint);
ON_3dVector N(ON_3dVector::NanVector);
if ( 0 != m_srf )
{
if ( m_srf->EvNormal(s,t,P,N) )
{
P = P + DistanceAt(s,t)*N;
}
}
return P;
}
ON_2dPoint ON_OffsetSurfaceFunction::OffsetSurfaceParameter(int i) const
{
ON_2dPoint p(ON_UNSET_VALUE,ON_UNSET_VALUE);
if ( 0 != m_srf && i >= 0 && i < m_offset_value.Count() )
{
p.x = m_offset_value[i].m_s;
p.y = m_offset_value[i].m_t;
}
return p;
}
const ON_Surface* ON_OffsetSurfaceFunction::BaseSurface() const
{
return m_srf;
}
double ON_OffsetSurfaceFunction::OffsetDistance(int i) const
{
double d = ON_UNSET_VALUE;
if ( 0 != m_srf && i >= 0 && i < m_offset_value.Count() )
{
d = m_offset_value[i].m_distance;
}
return d;
}
bool ON_OffsetSurfaceFunction::SetOffsetPoint(
double s,
double t,
double distance,
double radius
)
{
bool rc = false;
if ( ON_IsValid(s) && ON_IsValid(t) && ON_IsValid(distance) && ON_IsValid(radius) )
{
double u = m_domain[0].NormalizedParameterAt(s);
// 14 Jan 2008, Mikko, TRR 29861:
// Changing the clamping to happen when the
// point is outside or nearly outside the domain.
const double dTol = ON_SQRT_EPSILON; // tiny border around untrimmed edges
if ( u < dTol)
{
s = m_domain[0][0];
u = 0.0;
}
if ( u > 1.0-dTol)
{
s = m_domain[0][1];
u = 1.0;
}
double v = m_domain[1].NormalizedParameterAt(t);
if ( v < dTol)
{
t = m_domain[1][0];
v = 0.0;
}
if ( v > 1.0-dTol)
{
t = m_domain[1][1];
v = 1.0;
}
if ( u >= 0.0 && u <= 1.0 && v >= 0.0 && v <= 1.0 )
{
ON_OffsetSurfaceValue offset_value;
offset_value.m_s = s;
offset_value.m_t = t;
offset_value.m_distance = distance;
offset_value.m_radius = (radius > 0.0) ? radius : 0.0;
offset_value.m_index = (int)((u + v*4096.0)*4096.0);
int i;
for ( i = 0; i < m_offset_value.Count(); i++ )
{
if ( m_offset_value[i].m_index == offset_value.m_index )
{
m_offset_value[i] = offset_value;
break;
}
}
if (i == m_offset_value.Count())
{
m_offset_value.Append(offset_value);
m_bumps.SetCount(0);
m_bValid = false;
}
rc = true;
}
}
return rc;
}
bool ON_OffsetSurfaceFunction::SetDistance( int index, double distance)
{
int count = m_offset_value.Count();
if( index < 0 || index > count-1)
return false;
m_offset_value[index].m_distance = distance;
m_bValid = false;
return true;
}
bool ON_OffsetSurfaceFunction::SetPoint( int index, double s, double t)
{
int count = m_offset_value.Count();
if( index < 0 || index > count-1)
return false;
m_offset_value[index].m_s = s;
m_offset_value[index].m_t = t;
m_bValid = false;
return true;
}
void ON_OffsetSurfaceFunction::Destroy()
{
m_srf = 0;
m_bZeroSideDerivative[0] = false;
m_bZeroSideDerivative[1] = false;
m_bZeroSideDerivative[2] = false;
m_bZeroSideDerivative[3] = false;
m_domain[0] = ON_Interval::EmptyInterval;
m_domain[1] = ON_Interval::EmptyInterval;
m_bumps.SetCount(0);
m_bValid = false;
}
ON_OffsetSurfaceFunction::ON_OffsetSurfaceFunction()
{
Destroy();
}
ON_OffsetSurfaceFunction::~ON_OffsetSurfaceFunction()
{
Destroy();
}
bool ON_OffsetSurfaceFunction::Initialize()
{
const int count = m_offset_value.Count();
if ( !m_bValid && 0 != m_srf && count > 0)
{
ON_Workspace ws;
m_bumps.SetCount(0);
m_bumps.Reserve(count);
int i;
double a,b,ds,dt;
for (i = 0; i < count; i++ )
{
ON_BumpFunction& bump = m_bumps.AppendNew();
ON_OffsetSurfaceValue offset_value = m_offset_value[i];
double ds0 = offset_value.m_s - m_domain[0][0];
double ds1 = m_domain[0][1] - offset_value.m_s;
if ( 0.0 == ds0 )
ds0 = -ds1;
else if ( 0.0 == ds1 )
ds1 = -ds0;
double dt0 = offset_value.m_t - m_domain[1][0];
double dt1 = m_domain[1][1] - offset_value.m_t;
if ( 0.0 == dt0 )
dt0 = -dt1;
else if ( 0.0 == dt1 )
dt1 = -dt0;
// default is a large cubic bump
bump.m_point.x = offset_value.m_s;
bump.m_point.y = offset_value.m_t;
bump.m_x0 = bump.m_point.x;
bump.m_y0 = bump.m_point.y;
bump.m_sx[0] = -1.0/ds0;
bump.m_sx[1] = 1.0/ds1;
bump.m_sy[0] = -1.0/dt0;
bump.m_sy[1] = 1.0/dt1;
bump.m_type[0] = 5;
bump.m_type[1] = 5;
bump.m_a = 1.0;
if ( offset_value.m_radius > 0.0 )
{
// user specified cubic bump size
ON_3dPoint Pt;
ON_3dVector Ds, Dt;
if ( m_srf->Ev1Der(offset_value.m_s,offset_value.m_t,Pt,Ds,Dt) )
{
ds = (ds0>ds1) ? ds0 : ds1;
dt = (dt0>dt1) ? dt0 : dt1;
a = Ds.Length();
if ( a > ON_ZERO_TOLERANCE )
{
b = offset_value.m_radius/a;
if ( b < ds )
ds = b;
}
a = Dt.Length();
if ( a > ON_ZERO_TOLERANCE )
{
b = offset_value.m_radius/a;
if ( b < dt )
dt = b;
}
if ( !m_bZeroSideDerivative[0] || dt < dt0 )
dt0 = dt;
if ( !m_bZeroSideDerivative[1] || ds < ds1 )
ds1 = ds;
if ( !m_bZeroSideDerivative[2] || dt < dt1 )
dt1 = dt;
if ( !m_bZeroSideDerivative[3] || ds < ds0 )
ds0 = ds;
bump.m_sx[0] = -1.0/ds0;
bump.m_sx[1] = 1.0/ds1;
bump.m_sy[0] = -1.0/dt0;
bump.m_sy[1] = 1.0/dt1;
}
}
else if ( bump.m_point.x == m_domain[0][0] && bump.m_point.y == m_domain[1][0] )
{
// SW corner bilinear bump
if ( !m_bZeroSideDerivative[1] && !m_bZeroSideDerivative[3] )
{
bump.m_type[0] = 1;
bump.m_x0 = m_domain[0][1];
bump.m_sx[0] = -1.0/m_domain[0].Length();
bump.m_sx[1] = -1.0/m_domain[0].Length();
}
if ( !m_bZeroSideDerivative[0] && !m_bZeroSideDerivative[2] )
{
bump.m_type[1] = 1;
bump.m_y0 = m_domain[1][1];
bump.m_sy[0] = -1.0/m_domain[1].Length();
bump.m_sy[1] = -1.0/m_domain[1].Length();
}
}
else if ( bump.m_point.x == m_domain[0][1] && bump.m_point.y == m_domain[1][0] )
{
// SE corner bilinear bump
if ( !m_bZeroSideDerivative[1] && !m_bZeroSideDerivative[3] )
{
bump.m_type[0] = 1;
bump.m_x0 = m_domain[0][0];
bump.m_sx[0] = 1.0/m_domain[0].Length();
bump.m_sx[1] = 1.0/m_domain[0].Length();
}
if ( !m_bZeroSideDerivative[0] && !m_bZeroSideDerivative[2] )
{
bump.m_type[1] = 1;
bump.m_y0 = m_domain[1][1];
bump.m_sy[0] = -1.0/m_domain[1].Length();
bump.m_sy[1] = -1.0/m_domain[1].Length();
}
}
else if ( bump.m_point.x == m_domain[0][1] && bump.m_point.y == m_domain[1][1] )
{
// NE corner bilinear bump
if ( !m_bZeroSideDerivative[1] && !m_bZeroSideDerivative[3] )
{
bump.m_type[0] = 1;
bump.m_x0 = m_domain[0][0];
bump.m_sx[0] = 1.0/m_domain[0].Length();
bump.m_sx[1] = 1.0/m_domain[0].Length();
}
if ( !m_bZeroSideDerivative[0] && !m_bZeroSideDerivative[2] )
{
bump.m_type[1] = 1;
bump.m_y0 = m_domain[1][0];
bump.m_sy[0] = 1.0/m_domain[1].Length();
bump.m_sy[1] = 1.0/m_domain[1].Length();
}
}
else if ( bump.m_point.x == m_domain[0][0] && bump.m_point.y == m_domain[1][1] )
{
// NW corner bilinear bump
if ( !m_bZeroSideDerivative[1] && !m_bZeroSideDerivative[3] )
{
bump.m_x0 = m_domain[0][1];
bump.m_sx[0] = -1.0/m_domain[0].Length();
bump.m_sx[1] = -1.0/m_domain[0].Length();
bump.m_type[0] = 1;
}
if ( !m_bZeroSideDerivative[0] && !m_bZeroSideDerivative[2] )
{
bump.m_y0 = m_domain[1][0];
bump.m_sy[0] = 1.0/m_domain[1].Length();
bump.m_sy[1] = 1.0/m_domain[1].Length();
bump.m_type[1] = 1;
}
}
}
ON_Matrix M(count,count);
double* B = (double*)onmalloc(2*count*sizeof(*B));
double* X = B + count;
int j;
for ( i = 0; i < count; i++ )
{
ON_2dPoint p = m_bumps[i].m_point;
B[i] = m_offset_value[i].m_distance;
for ( j = 0; j < count; j++ )
{
M[i][j] = m_bumps[j].ValueAt(p.x,p.y);
}
}
int rank = M.RowReduce(ON_ZERO_TOLERANCE,B);
if ( count == rank )
{
if ( M.BackSolve(ON_ZERO_TOLERANCE,count,B,X) )
{
m_bValid = true;
}
}
if ( !m_bValid )
{
#if 0 //defined(TL2_MATRIX_INC_)
// Have access to SVD - try it
for ( i = 0; i < count; i++ )
{
ON_2dPoint p = m_bumps[i].m_point;
B[i] = m_offset_value[i].m_distance;
for ( j = 0; j < count; j++ )
{
M[i][j] = m_bumps[j].ValueAt(p.x,p.y);
}
}
ON_Matrix U, V;
double* diagonal = (double*)onmalloc(2*count*sizeof(*diagonal));
double* inverted_diagonal = diagonal + count;
if ( TL2_MatrixSVD(M,U,diagonal,V,30) )
{
rank = TL2_MatrixSVDInvertDiagonal(count,diagonal,inverted_diagonal);
if ( rank > 0 )
{
if ( TL2_MatrixSVDSolve(U,inverted_diagonal,V,1,B,1,X) )
{
m_bValid = true;
}
}
}
#endif
}
if ( m_bValid )
{
for ( i = 0; i < count; i++ )
{
m_bumps[i].m_a = X[i];
}
}
onfree(B);
}
return m_bValid;
}
ON_BumpFunction::ON_BumpFunction()
{
m_type[0] = 0;
m_type[1] = 0;
m_sx[0] = 0.0;
m_sx[1] = 0.0;
m_sy[0] = 0.0;
m_sy[1] = 0.0;
}
double ON_BumpFunction::ValueAt(
double s,
double t
) const
{
double v;
Evaluate(s,t,0,&v);
return v;
}
Reference in New Issue View Git Blame Copy Permalink