void* ON_Workspace::GetMemory( size_t size )
{
void* p = NULL;
if ( size > 0 )
{
struct ON_Workspace_MBLK* pBlk = (struct ON_Workspace_MBLK*)onmalloc(sizeof(*pBlk));
if ( pBlk )
{
pBlk->pMem = p = onmalloc(size);
pBlk->pNext = m_pMemBlk;
m_pMemBlk = pBlk;
}
}
return p;
}
bool ON_Matrix::Create( int row_count, int col_count)
{
bool b = false;
Destroy();
if ( row_count > 0 && col_count > 0 )
{
m_rowmem.Reserve(row_count);
if ( 0 != m_rowmem.Array() )
{
m_rowmem.SetCount(row_count);
// In general, allocate coefficient memory in chunks
// of <= max_dblblk_size bytes. The value of max_dblblk_size
// is tuned to maximize speed on calculations involving
// large matrices. If all of the coefficients will fit
// into a chunk of memory <= 1.1*max_dblblk_size, then
// a single chunk is allocated.
// In limited testing, these two values appeared to work ok.
// The latter was a hair faster in solving large row reduction
// problems (for reasons I do not understand).
//const int max_dblblk_size = 1024*1024*8;
const int max_dblblk_size = 512*1024;
int rows_per_block = max_dblblk_size/(col_count*sizeof(double));
if ( rows_per_block > row_count )
rows_per_block = row_count;
else if ( rows_per_block < 1 )
rows_per_block = 1;
else if ( rows_per_block < row_count && 11*rows_per_block >= 10*row_count )
rows_per_block = row_count;
int j, i = row_count;
m = m_rowmem.Array();
double** row = m;
for ( i = row_count; i > 0; i -= rows_per_block )
{
if ( i < rows_per_block )
rows_per_block = i;
int dblblk_count = rows_per_block*col_count;
struct DBLBLK* p = (struct DBLBLK*)onmalloc(sizeof(*p) + dblblk_count*sizeof(p->a[0]));
p->a = (double*)(p+1);
p->count = dblblk_count;
p->next = (struct DBLBLK*)m_cmem;
m_cmem = p;
*row = p->a;
j = rows_per_block-1;
while(j--)
{
row[1] = row[0] + col_count;
row++;
}
row++;
}
m_row_count = row_count;
m_col_count = col_count;
b = true;
}
}
return b;
}
ON_3dPoint ON_BezierCage::PointAt( ON_3dPoint rst ) const
{
ON_3dPoint pt;
if ( m_dim <= 3 )
{
pt.x = 0.0;
pt.y = 0.0;
pt.z = 0.0;
Evaluate(rst.x,rst.y,rst.z,0,3,&pt.x);
}
else
{
double stack_buffer[16];
double* v;
size_t sizeof_buffer = m_dim*sizeof(*v);
v = (sizeof_buffer <= sizeof(stack_buffer)) ? stack_buffer : (double*)onmalloc(sizeof_buffer);
v[0] = 0.0;
v[1] = 0.0;
v[2] = 0.0;
Evaluate(rst.x,rst.y,rst.z,0,m_dim,v);
pt.x = v[0];
pt.y = v[1];
pt.z = v[2];
if ( v != stack_buffer )
onfree(v);
}
return pt;
}
//Do not change SpanCount() without making sure it gives the correct result for use in GetSpanVector()
int ON_CurveProxy::SpanCount() const
{
if (!m_real_curve) return 0;
int rsc = m_real_curve->SpanCount();
ON_Interval domain = m_real_curve->Domain();
if (m_real_curve_domain == domain)
return rsc;
double* rsv = (double*)onmalloc((rsc+1)*sizeof(double));
if (!rsv) return 0;
if (!m_real_curve->GetSpanVector(rsv)){
onfree((void*)rsv);
return 0;
}
int i=0;
int sc = 0;
while (i <= rsc && rsv[i] <= m_real_curve_domain[0]) i++;
while (i <= rsc && rsv[i] < m_real_curve_domain[1]){
sc++;
i++;
}
sc++;
onfree((void*)rsv);
return sc;
}
struct ON_MeshNgon* ON_MeshNgonList::AddNgon(int N)
{
if ( N < 3 || N > 100000 )
return 0;
if ( m_ngons_count >= m_ngons_capacity )
{
int capacity = 2*m_ngons_count;
if (capacity < m_ngons_count+16)
capacity = m_ngons_count+16;
if ( !ReserveNgonCapacity(capacity) )
return 0;
}
ON_MeshNgon& ngon = m_ngons[m_ngons_count++];
ngon.N = N;
struct ON_NGON_MEMBLK* blk = (struct ON_NGON_MEMBLK*)onmalloc(sizeof(*blk) + (2*N)*sizeof(int));
if ( 0 == blk )
return 0;
ngon.vi = (int*)(blk + 1);
ngon.fi = ngon.vi + N;
memset(ngon.vi,0xFF,(2*N)*sizeof(int)); // set all indicies to -1
blk->next = m_memblk_list;
m_memblk_list = blk;
return &ngon;
}
void* ON_Object::operator new[] (size_t sz)
{
// ON_Object array new
// The else "sz?sz:1" is there because section 3.7.3.1,
// paragraph 2 of the C++ "standard" says something along
// the lines of:
//
// The function shall return the address of the start of a
// block of storage whose length in bytes shall be at least
// as large as the requested size. There are no constraints
// on the contents of the allocated storage on return from
// the allocation function. The order, contiguity, and initial
// value of storage allocated by successive calls to an
// allocation function is unspecified. The pointer returned
// shall be suitably aligned so that it can be converted to a
// pointer of any complete object type and then used to
// access the object or array in the storage allocated (until
// the storage is explicitly deallocated by a call to a
// corresponding deallocation function). If the size of the
// space requested is zero, the value returned shall not be a
// null pointer value. The results of dereferencing a pointer
// returned as a request for zero size are undefined.
return onmalloc(sz?sz:1);
}
//////////
// If t is in the domain of the surface, GetSpanVectorIndex() returns the
// span vector index "i" such that span_vector[i] <= t <= span_vector[i+1].
// The "side" parameter determines which span is selected when t is at the
// end of a span.
//
//virtual
ON_BOOL32 ON_Surface::GetSpanVectorIndex(
int dir, // 0 gets first parameter's domain, 1 gets second parameter's domain
double t, // [IN] t = evaluation parameter
int side, // [IN] side 0 = default, -1 = from below, +1 = from above
int* span_vector_i, // [OUT] span vector index
ON_Interval* span_domain // [OUT] domain of the span containing "t"
) const
{
ON_BOOL32 rc = false;
int i;
int span_count = SpanCount(dir);
if ( span_count > 0 ) {
double* span_vector = (double*)onmalloc((span_count+1)*sizeof(span_vector[0]));
rc = GetSpanVector( dir, span_vector );
if (rc) {
i = ON_NurbsSpanIndex( 2, span_count, span_vector, t, side, 0 );
if ( i >= 0 && i <= span_count ) {
if ( span_vector_i )
*span_vector_i = i;
if ( span_domain )
span_domain->Set( span_vector[i], span_vector[i+1] );
}
else
rc = false;
}
onfree(span_vector);
}
return rc;
}
bool ON_CompressStream::Begin()
{
if ( 0 != m_implementation )
{
onfree(m_implementation);
m_implementation = 0;
}
// zero these because the same instance of an
// ON_CompressStream class may be used multiple times.
m_in_size = 0;
m_out_size = 0;
m_in_crc = 0;
m_out_crc = 0;
struct ON_ZlibImplementation* imp = (struct ON_ZlibImplementation*)onmalloc(sizeof(*imp));
memset(&imp->m_strm,0,sizeof(imp->m_strm));
if ( Z_OK != deflateInit( &imp->m_strm, Z_BEST_COMPRESSION ) )
{
onfree(imp);
return false;
}
m_implementation = imp;
return true;
}
CRhinoCommand::result CCommandSampleTriangulatePolygon::RunCommand( const CRhinoCommandContext& context )
{
CRhinoGetObject go;
go.SetCommandPrompt( L"Select closed planar polygon to triangulate" );
go.SetGeometryFilter( CRhinoGetObject::curve_object );
go.SetGeometryFilter( CRhinoGetObject::closed_curve );
go.EnableSubObjectSelect( FALSE );
go.GetObjects( 1, 1 );
if( go.CommandResult() != CRhinoCommand::success )
return go.CommandResult();
const CRhinoObjRef& ref = go.Object(0);
ON_3dPointArray vertices;
const ON_PolylineCurve* pc = ON_PolylineCurve::Cast( ref.Curve() );
if( pc )
{
vertices = pc->m_pline;
}
else
{
const ON_NurbsCurve* nc = ON_NurbsCurve::Cast( ref.Curve() );
if( nc )
nc->IsPolyline( &vertices );
}
if( vertices.Count() < 5 )
{
RhinoApp().Print( L"Curve not polygon with at least four sides.\n" );
return CRhinoCommand::nothing;
}
int* triangles = (int*)onmalloc( (vertices.Count()-3) * sizeof(int) * 3 );
if( 0 == triangles )
return CRhinoCommand::failure; // out of memory
memset( triangles, 0, (vertices.Count()-3) * sizeof(int) * 3 );
int rc = RhinoTriangulate3dPolygon( vertices.Count()-1, 3, (const double*)vertices.Array(), 3, triangles);
if( 0 == rc )
{
int i;
for( i = 0; i < vertices.Count()-3; i++ )
{
ON_Polyline pline;
pline.Append( vertices[triangles[i * 3]] );
pline.Append( vertices[triangles[i * 3 + 1]] );
pline.Append( vertices[triangles[i * 3 + 2]] );
pline.Append( pline[0] );
context.m_doc.AddCurveObject( pline );
}
context.m_doc.Redraw();
}
onfree( triangles );
return CRhinoCommand::success;
}
int
ON_Matrix::RowReduce(
double zero_tolerance,
ON_3dPoint* B,
double* pivot
)
{
ON_3dPoint t;
double x, piv;
int i, k, ix, rank;
double** this_m = ThisM();
piv = 0.0;
rank = 0;
const int n = m_row_count <= m_col_count ? m_row_count : m_col_count;
for ( k = 0; k < n; k++ ) {
//onfree( onmalloc( 1)); // 8-06-03 lw for cancel thread responsiveness
onmalloc( 0); // 9-4-03 lw changed to 0
ix = k;
x = fabs(this_m[ix][k]);
for ( i = k+1; i < m_row_count; i++ ) {
if ( fabs(this_m[i][k]) > x ) {
ix = i;
x = fabs(this_m[ix][k]);
}
}
if ( x < piv || k == 0 ) {
piv = x;
}
if ( x <= zero_tolerance )
break;
rank++;
// swap rows of matrix and B
SwapRows( ix, k );
t = B[ix]; B[ix] = B[k]; B[k] = t;
// scale row k of matrix and B
x = 1.0/this_m[k][k];
this_m[k][k] = 1.0;
ON_ArrayScale( m_col_count - 1 - k, x, &this_m[k][k+1], &this_m[k][k+1] );
B[k] *= x;
// zero column k for rows below this_m[k][k]
for ( i = k+1; i < m_row_count; i++ ) {
x = -this_m[i][k];
this_m[i][k] = 0.0;
if ( fabs(x) > zero_tolerance ) {
ON_Array_aA_plus_B( m_col_count - 1 - k, x, &this_m[k][k+1], &this_m[i][k+1], &this_m[i][k+1] );
B[i] += x*B[k];
}
}
}
if ( pivot )
*pivot = piv;
return rank;
}
bool ON_SolveSVD(
int row_count,
int col_count,
double const * const * U,
const double* invW,
double const * const * V,
const double* B,
double*& X
)
{
int i, j;
double *Y;
const double* p0;
double workY[128], x;
if ( row_count < 1 || col_count < 1 || 0 == U || 0 == invW || 0 == V || 0 == B)
return false;
if ( 0 == X )
X = (double*)onmalloc(col_count*sizeof(X[0]));
Y = (col_count > 128)
? ( (double*)onmalloc(col_count*sizeof(*Y)) )
: workY;
for (i = 0; i < col_count; i++)
{
double y = 0.0;
for (j = 0; j < row_count; j++)
y += U[j][i] * *B++;
B -= row_count;
Y[i] = invW[i] * y;
}
for (i = 0; i < col_count; i++)
{
p0 = V[i];
j = col_count;
x = 0.0;
while (j--)
x += *p0++ * *Y++;
Y -= col_count;
X[i] = x;
}
if (Y != workY)
onfree(Y);
return true;
}
bool ON_CompressedBuffer::Read( ON_BinaryArchive& binary_archive )
{
int major_version = 0;
int minor_version = 0;
bool rc = binary_archive.BeginRead3dmChunk(TCODE_ANONYMOUS_CHUNK,&major_version,&minor_version);
if ( !rc )
return false;
for(;;)
{
rc = ( 1 == major_version );
if ( !rc )
break;
rc = binary_archive.ReadSize(&m_sizeof_uncompressed);
if (!rc)
break;
rc = binary_archive.ReadSize(&m_sizeof_compressed);
if (!rc)
break;
rc = binary_archive.ReadInt(&m_crc_uncompressed);
if (!rc)
break;
rc = binary_archive.ReadInt(&m_crc_compressed);
if (!rc)
break;
rc = binary_archive.ReadInt(&m_method);
if (!rc)
break;
rc = binary_archive.ReadInt(&m_sizeof_element);
if (!rc)
break;
if ( m_sizeof_compressed > 0 )
{
m_buffer_compressed = onmalloc(m_sizeof_compressed);
if ( m_buffer_compressed )
{
m_buffer_compressed_capacity = m_sizeof_compressed;
rc = binary_archive.ReadByte(m_sizeof_compressed,m_buffer_compressed);
}
else
{
m_sizeof_compressed =0;
}
if (!rc)
break;
}
break;
}
if ( !binary_archive.EndRead3dmChunk() )
rc = false;
return rc;
}
ON_BOOL32
ON_Surface::Ev1Der( // returns false if unable to evaluate
double s, double t, // evaluation parameters
ON_3dPoint& point,
ON_3dVector& ds,
ON_3dVector& dt,
int side, // optional - determines which side to evaluate from
// 0 = default
// 1 from NE quadrant
// 2 from NW quadrant
// 3 from SW quadrant
// 4 from SE quadrant
int* hint // optional - evaluation hint (int[2]) used to speed
// repeated evaluations
) const
{
ON_BOOL32 rc = false;
const int dim = Dimension();
double ws[3*32];
double* v;
point.x = 0.0;
point.y = 0.0;
point.z = 0.0;
ds.x = 0.0;
ds.y = 0.0;
ds.z = 0.0;
dt.x = 0.0;
dt.y = 0.0;
dt.z = 0.0;
if ( dim <= 32 ) {
v = ws;
}
else {
v = (double*)onmalloc(3*dim*sizeof(*v));
}
rc = Evaluate( s, t, 1, dim, v, side, hint );
point.x = v[0];
ds.x = v[dim];
dt.x = v[2*dim];
if ( dim > 1 ) {
point.y = v[1];
ds.y = v[dim+1];
dt.y = v[2*dim+1];
if ( dim > 2 ) {
point.z = v[2];
ds.z = v[dim+2];
dt.z = v[2*dim+2];
if ( dim > 32 )
onfree(v);
}
}
return rc;
}
void ON_String::CopyToArray( int w_count, const wchar_t* w )
{
// convert UTF-16 string to UTF-8 string
int c_count = w2c_size( w_count, w );
char* c = (char*)onmalloc(c_count+1);
memset( c, 0, c_count+1 );
const int c_length = w2c( w_count, w, c_count, c );
c[c_length] = 0;
CopyToArray( c_count, c );
onfree(c);
}
ON_wString::ON_wString( unsigned char c, int repeat_count )
{
Create();
if ( repeat_count > 0 ) {
char* s = (char*)onmalloc((repeat_count+1)*sizeof(*s));
s[repeat_count] = 0;
memset( s, c, repeat_count*sizeof(*s) );
CopyToArray( repeat_count, s );
onfree(s);
m_s[repeat_count] = 0;
Header()->string_length = repeat_count;
}
}
void ON_String::CreateArray( int capacity )
{
Destroy();
if ( capacity > 0 ) {
ON_aStringHeader* p =
(ON_aStringHeader*)onmalloc( sizeof(ON_aStringHeader) + (capacity+1)*sizeof(*m_s) );
p->ref_count = 1;
p->string_length = 0;
p->string_capacity = capacity;
m_s = p->string_array();
memset( m_s, 0, (capacity+1)*sizeof(*m_s) );
}
}
bool ON_BezierCage::Write(ON_BinaryArchive& archive) const
{
bool rc = archive.BeginWrite3dmChunk(TCODE_ANONYMOUS_CHUNK,1,0);
if (rc)
{
rc = archive.WriteInt(m_dim);
if(rc)
rc = archive.WriteInt(m_is_rat);
if (rc)
rc = archive.WriteInt(m_order[0]);
if (rc)
rc = archive.WriteInt(m_order[1]);
if (rc)
rc = archive.WriteInt(m_order[2]);
int i,j,k;
const int cv_dim = m_is_rat?(m_dim+1):m_dim;
double* bogus_cv = 0;
for(i = 0; i < m_order[0] && rc; i++)
{
for(j = 0; j < m_order[1] && rc; j++)
{
for ( k = 0; k < m_order[2] && rc; k++)
{
const double* cv = CV(i,j,k);
if ( !cv )
{
if ( 0 == bogus_cv )
{
bogus_cv = (double*)onmalloc(cv_dim*sizeof(*bogus_cv));
for ( int n = 0; n < cv_dim; n++ )
bogus_cv[n] = ON_UNSET_VALUE;
}
cv = bogus_cv;
}
rc = archive.WriteDouble(cv_dim,cv);
}
}
}
if ( 0 != bogus_cv )
onfree(bogus_cv);
if ( !archive.EndWrite3dmChunk() )
{
rc = false;
}
}
return rc;
}
void* onmemdup( const void* src, size_t sz )
{
void* p;
if ( src && sz>0 )
{
p = onmalloc(sz);
if (p)
memcpy(p,src,sz);
}
else {
p = 0;
}
return p;
}
void
ON_hsort(void *base, size_t nel, size_t width, int (*compar)(const void*,const void*))
{
size_t
i_end,k;
unsigned char
work_memory[work_size], *e_tmp, *e_end;
if (nel < 2) return;
k = nel >> 1;
i_end = nel-1;
e_end = ((unsigned char*)base) + i_end*width;
e_tmp = (width > work_size) ? (unsigned char*)onmalloc(width) : work_memory;
for (;;) {
if (k) {
--k;
memcpy(e_tmp,((unsigned char*)base)+k*width,width); /* e_tmp = e[k]; */
}
else {
memcpy(e_tmp,e_end,width); /* e_tmp = e[i_end]; */
memcpy(e_end,base,width); /* e[i_end] = e[0]; */
if (!(--i_end)) {
memcpy(base,e_tmp,width); /* e[0] = e_tmp; */
break;
}
e_end -= width;
}
{ size_t i, j;
unsigned char *e_i, *e_j;
i = k;
j = (k<<1) + 1;
e_i = ((unsigned char*)base) + i*width;
while (j <= i_end) {
e_j = ((unsigned char*)base) + j*width;
if (j < i_end && compar(e_j,e_j+width)<0 /*e[j] < e[j + 1] */)
{j++; e_j += width;}
if (compar(e_tmp,e_j)<0 /* e_tmp < e[j] */) {
memcpy(e_i,e_j,width); /* e[i] = e[j]; */
i = j;
e_i = e_j;
j = (j<<1) + 1;
} else j = i_end + 1;
}
memcpy(e_i,e_tmp,width); /* e[i] = e_tmp; */
}
}
if (width > work_size) onfree(e_tmp);
}
void* onrealloc( void* memblock, size_t sz )
{
if ( 0 == memblock )
{
return onmalloc(sz);
}
if ( 0 == sz )
{
onfree(memblock);
return 0;
}
#if defined(ON_REALLOC_BROKEN)
/* use malloc() and memcpy() instead of buggy realloc() */
void* p;
const size_t memblocksz = _msize(memblock);
if ( sz <= memblocksz ) {
/* shrink */
if ( memblocksz <= 28 || 8*sz >= 7*memblocksz )
{
/* don't bother reallocating */
p = memblock;
}
else {
/* allocate smaller block */
p = malloc(sz);
if ( p )
{
memcpy( p, memblock, sz );
free(memblock);
}
}
}
else if ( sz > memblocksz ) {
/* grow */
p = malloc(sz);
if ( p ) {
memcpy( p, memblock, memblocksz );
free(memblock);
}
}
return p;
#else
return realloc( memblock, sz );
#endif
}
int ON_wString::Find( const char* s ) const
{
int rc = -1;
if ( s && s[0] && !IsEmpty() ) {
const int s_count = (int)strlen(s); // the (int) is for 64 bit size_t conversion
wchar_t* w = (wchar_t*)onmalloc( (s_count+2)*sizeof(w[0]) );
c2w( s_count, s, s_count+1, w );
const wchar_t* p;
p = wcsstr( m_s, w );
if ( p )
{
rc = ((int)(p-m_s)); // the (int) cast is for 64 bit compilers
}
onfree( w );
}
return rc;
}
int ON_GetBase32Digits( const unsigned char* x, int x_count, unsigned char* base32_digits )
{
int x_bit_count = 8*x_count;
unsigned char mask, c;
unsigned char bits[5] = {0,0,0,0,0};
unsigned int bits_count = 0;
unsigned int base32_digit_count = 0;
int i;
if ( 0 == base32_digits || 0 == x || x_count <= 0 )
return 0;
if ( x == base32_digits )
{
unsigned char* tmp = (unsigned char*)onmalloc(x_count*sizeof(x[0]));
if ( 0 == tmp )
return 0;
memcpy(tmp,x,x_count*sizeof(x[0]));
i = ON_GetBase32Digits(tmp,x_count,base32_digits);
onfree(tmp);
return i;
}
i = x_bit_count % 5;
if ( i )
bits_count = 5-i;
for ( i = 0; i < x_count; i++)
{
c = x[i];
for (mask = 128; 0 != mask; mask /= 2 )
{
bits[bits_count++] = (0 != (c & mask)) ? 1 : 0;
if ( 5 == bits_count )
{
base32_digits[base32_digit_count++] = 16*bits[0] + 8*bits[1] + 4*bits[2] + 2*bits[3] + bits[4];
bits_count = 0;
}
}
}
return base32_digit_count;
}
/////////////////////////////////////////////////////////////////
// Tools for managing CV and knot memory
bool ON_BezierCage::ReserveCVCapacity(
int capacity// number of doubles to reserve
)
{
if ( m_cv_capacity < capacity ) {
if ( m_cv ) {
if ( m_cv_capacity ) {
m_cv = (double*)onrealloc( m_cv, capacity*sizeof(*m_cv) );
m_cv_capacity = (m_cv) ? capacity : 0;
}
// else user supplied m_cv[] array
}
else {
m_cv = (double*)onmalloc( capacity*sizeof(*m_cv) );
m_cv_capacity = (m_cv) ? capacity : 0;
}
}
return ( m_cv ) ? true : false;
}
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] )
{
EvaluateHelperQuinticBump(x,dx,der_count,xvalue);
}
else
{
EvaluateHelperLinearBump(x,dx,der_count,xvalue);
}
if ( 5 == m_type[1] )
{
EvaluateHelperQuinticBump(y,dy,der_count,yvalue);
}
else
{
EvaluateHelperLinearBump(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)
}
}
}
int ON_InvertSVDW(
int count,
const double* W,
double*& invW
)
{
double w, maxw;
int i;
if ( 0 == W || count <= 0 )
return -1;
if ( 0 == invW )
{
invW = (double*)onmalloc(count*sizeof(invW[0]));
}
maxw = fabs(W[0]);
for (i = 1; i < count; i++) {
w = fabs(W[i]);
if (w > maxw) maxw = w;
}
if (maxw == 0.0)
{
if ( W != invW )
memset(invW,0,count*sizeof(invW[0]));
return 0;
}
i = 0;
maxw *= ON_SQRT_EPSILON;
while (count--)
{
if (fabs(W[count]) > maxw)
{
i++;
invW[count] = 1.0/W[count];
}
else
invW[count] = 0.0;
}
return i; // number of nonzero terms in invW[]
}
int ON_wString::CompareNoCase( const char* s) const
{
int rc = 0;
if ( s && s[0] ) {
if ( IsEmpty() ) {
rc = -1;
}
else {
int c_count = w2c_size( Length(m_s), m_s );
char* c = (char*)onmalloc((c_count+1)*sizeof(*c));
w2c( Length(m_s), m_s, c_count, c );
c[c_count] = 0;
rc = on_stricmp( c, s );
onfree(c);
}
}
else {
rc = IsEmpty() ? 0 : 1;
}
return rc;
}
ON_BOOL32
ON_Surface::EvPoint( // returns false if unable to evaluate
double s, double t, // evaluation parameters
ON_3dPoint& point,
int side, // optional - determines which side to evaluate from
// 0 = default
// 1 from NE quadrant
// 2 from NW quadrant
// 3 from SW quadrant
// 4 from SE quadrant
int* hint // optional - evaluation hint (int[2]) used to speed
// repeated evaluations
) const
{
ON_BOOL32 rc = false;
double ws[128];
double* v;
if ( Dimension() <= 3 ) {
v = &point.x;
point.x = 0.0;
point.y = 0.0;
point.z = 0.0;
}
else if ( Dimension() <= 128 ) {
v = ws;
}
else {
v = (double*)onmalloc(Dimension()*sizeof(*v));
}
rc = Evaluate( s, t, 0, Dimension(), v, side, hint );
if ( Dimension() > 3 ) {
point.x = v[0];
point.y = v[1];
point.z = v[2];
if ( Dimension() > 128 )
onfree(v);
}
return rc;
}
bool ON_OffsetSurfaceFunction::EvaluateDistance(
double s,
double t,
int num_der,
double* value
) const
{
const int vcnt = ((num_der+1)*(num_der+2))/2;
int vi;
for ( 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, vi;
for ( bump_index = 0; bump_index < bump_count; bump_index++ )
{
m_bumps[bump_index].Evaluate( s, t, num_der, bump_value );
for ( vi = 0; vi < vcnt; vi++ )
{
value[vi] += bump_value[vi];
}
}
if ( bump_value != barray )
onfree(bump_value);
}
return rc;
}
ON_CompressedBuffer& ON_CompressedBuffer::operator=(const ON_CompressedBuffer& src)
{
if ( this != &src )
{
Destroy();
if( src.m_buffer_compressed && src.m_sizeof_compressed > 0 )
{
m_sizeof_uncompressed = src.m_sizeof_uncompressed;
m_sizeof_compressed = src.m_sizeof_compressed;
m_crc_uncompressed = src.m_crc_uncompressed;
m_crc_compressed = src.m_crc_compressed;
m_method = src.m_method;
m_sizeof_element = src.m_sizeof_element;
m_buffer_compressed = onmalloc(m_sizeof_compressed);
if( m_buffer_compressed )
{
m_buffer_compressed_capacity = m_sizeof_compressed;
memcpy(m_buffer_compressed,src.m_buffer_compressed,m_sizeof_compressed);
}
}
}
return *this;
}
/*
Returns:
Height of the 'I' character when the font is drawn
with m_logfont.lfHeight = 256.
*/
int ON_Font::HeightOfI() const
{
if ( m_I_height <= 0 )
{
// Default is height of Arial 'I'. If we are running
// on Windows, then we calculate the actual height of
// an 'I' in the font.
// The ..ON_Font::normal_font_height/256 is here
// so this code will continue to work correctly
// if somebody changes ON_Font::normal_font_height.
int I_height = (166*ON_Font::normal_font_height)/256;
#if defined(ON_OS_WINDOWS_GDI)
if ( m_logfont.lfFaceName[0] )
{
// Get the height of an 'I'
HDC hdc = ::GetDC( NULL);
if (hdc)
{
LOGFONT logfont = m_logfont;
logfont.lfHeight = normal_font_height;
HFONT font = ::CreateFontIndirect( &logfont);
if ( font )
{
wchar_t str[2];
str[0] = ON_Font::m_metrics_char;
str[1] = 0;
HFONT oldfont = (HFONT)::SelectObject( hdc, font);
::SetBkMode( hdc, TRANSPARENT);
::BeginPath(hdc);
::ExtTextOut( hdc, 0, 0, 0, NULL, str, 1, NULL);
::EndPath( hdc);
int numPoints = ::GetPath( hdc, NULL, NULL, 0);
if( numPoints > 2)
{
// Allocate room for the points & point types
LPPOINT pPoints = (LPPOINT)onmalloc( numPoints * sizeof(*pPoints) );
LPBYTE pTypes = (LPBYTE)onmalloc( numPoints * sizeof(*pTypes) );
if ( pTypes && pPoints)
{
// Get the points and types from the current path
numPoints = ::GetPath( hdc, pPoints, pTypes, numPoints);
if( numPoints > 2)
{
int ymin = pPoints[0].y;
int ymax = ymin;
int k;
for( k = 1; k < numPoints; k++)
{
if( pPoints[k].y < ymin)
ymin = pPoints[k].y;
else if( pPoints[k].y > ymax)
ymax = pPoints[k].y;
}
I_height = ymax - ymin + 1;
}
}
onfree( pPoints);
onfree( pTypes);
}
::SelectObject( hdc, oldfont);
::DeleteObject( font);
}
}
::ReleaseDC( NULL, hdc);
}
#endif
const_cast<ON_Font*>(this)->m_I_height = I_height;
}
return m_I_height;
}
