| 1 |
/* |
| 2 |
* |
| 3 |
* Copyright (C) 2000 Silicon Graphics, Inc. All Rights Reserved. |
| 4 |
* |
| 5 |
* This library is free software; you can redistribute it and/or |
| 6 |
* modify it under the terms of the GNU Lesser General Public |
| 7 |
* License as published by the Free Software Foundation; either |
| 8 |
* version 2.1 of the License, or (at your option) any later version. |
| 9 |
* |
| 10 |
* This library is distributed in the hope that it will be useful, |
| 11 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 13 |
* Lesser General Public License for more details. |
| 14 |
* |
| 15 |
* Further, this software is distributed without any warranty that it is |
| 16 |
* free of the rightful claim of any third person regarding infringement |
| 17 |
* or the like. Any license provided herein, whether implied or |
| 18 |
* otherwise, applies only to this software file. Patent licenses, if |
| 19 |
* any, provided herein do not apply to combinations of this program with |
| 20 |
* other software, or any other product whatsoever. |
| 21 |
* |
| 22 |
* You should have received a copy of the GNU Lesser General Public |
| 23 |
* License along with this library; if not, write to the Free Software |
| 24 |
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 25 |
* |
| 26 |
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy, |
| 27 |
* Mountain View, CA 94043, or: |
| 28 |
* |
| 29 |
* http://www.sgi.com |
| 30 |
* |
| 31 |
* For further information regarding this notice, see: |
| 32 |
* |
| 33 |
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/ |
| 34 |
* |
| 35 |
*/ |
| 36 |
|
| 37 |
/* |
| 38 |
* curve.c++ - $Revision: 1.1.1.1 $ |
| 39 |
* Derrick Burns - 1991 |
| 40 |
*/ |
| 41 |
|
| 42 |
#include "glimports.h" |
| 43 |
#include "myassert.h" |
| 44 |
#include "mystdio.h" |
| 45 |
#include "mymath.h" |
| 46 |
#include "curve.h" |
| 47 |
#include "mapdesc.h" |
| 48 |
#include "types.h" |
| 49 |
#include "quilt.h" |
| 50 |
#include "nurbsconsts.h" |
| 51 |
|
| 52 |
/*-------------------------------------------------------------------------- |
| 53 |
* Curve::Curve - copy curve from quilt and transform control points |
| 54 |
*-------------------------------------------------------------------------- |
| 55 |
*/ |
| 56 |
|
| 57 |
Curve::Curve( Quilt_ptr geo, REAL pta, REAL ptb, Curve *c ) |
| 58 |
{ |
| 59 |
mapdesc = geo->mapdesc; |
| 60 |
next = c; |
| 61 |
needsSampling = mapdesc->isRangeSampling() ? 1 : 0; |
| 62 |
cullval = mapdesc->isCulling() ? CULL_ACCEPT : CULL_TRIVIAL_ACCEPT; |
| 63 |
order = geo->qspec[0].order; |
| 64 |
stride = MAXCOORDS; |
| 65 |
|
| 66 |
REAL *ps = geo->cpts; |
| 67 |
Quiltspec_ptr qs = geo->qspec; |
| 68 |
ps += qs->offset; |
| 69 |
ps += qs->index * qs->order * qs->stride; |
| 70 |
REAL *pend = ps + qs->order * qs->stride; |
| 71 |
|
| 72 |
if( needsSampling ) |
| 73 |
mapdesc->xformSampling( ps, qs->order, qs->stride, spts, stride ); |
| 74 |
|
| 75 |
if( cullval == CULL_ACCEPT ) |
| 76 |
mapdesc->xformCulling( ps, qs->order, qs->stride, cpts, stride ); |
| 77 |
|
| 78 |
/* set untrimmed curve range */ |
| 79 |
range[0] = qs->breakpoints[qs->index]; |
| 80 |
range[1] = qs->breakpoints[qs->index+1]; |
| 81 |
range[2] = range[1] - range[0]; |
| 82 |
|
| 83 |
if( range[0] != pta ) { |
| 84 |
Curve lower( *this, pta, 0 ); |
| 85 |
lower.next = next; |
| 86 |
*this = lower; |
| 87 |
} |
| 88 |
if( range[1] != ptb ) { |
| 89 |
Curve lower( *this, ptb, 0 ); |
| 90 |
} |
| 91 |
} |
| 92 |
|
| 93 |
/*-------------------------------------------------------------------------- |
| 94 |
* Curve::Curve - subdivide a curve along an isoparametric line |
| 95 |
*-------------------------------------------------------------------------- |
| 96 |
*/ |
| 97 |
|
| 98 |
Curve::Curve( Curve& upper, REAL value, Curve *c ) |
| 99 |
{ |
| 100 |
Curve &lower = *this; |
| 101 |
|
| 102 |
lower.next = c; |
| 103 |
lower.mapdesc = upper.mapdesc; |
| 104 |
lower.needsSampling = upper.needsSampling; |
| 105 |
lower.order = upper.order; |
| 106 |
lower.stride = upper.stride; |
| 107 |
lower.cullval = upper.cullval; |
| 108 |
|
| 109 |
REAL d = (value - upper.range[0]) / upper.range[2]; |
| 110 |
|
| 111 |
if( needsSampling ) |
| 112 |
mapdesc->subdivide( upper.spts, lower.spts, d, upper.stride, upper.order ); |
| 113 |
|
| 114 |
if( cullval == CULL_ACCEPT ) |
| 115 |
mapdesc->subdivide( upper.cpts, lower.cpts, d, upper.stride, upper.order ); |
| 116 |
|
| 117 |
lower.range[0] = upper.range[0]; |
| 118 |
lower.range[1] = value; |
| 119 |
lower.range[2] = value - upper.range[0]; |
| 120 |
upper.range[0] = value; |
| 121 |
upper.range[2] = upper.range[1] - value; |
| 122 |
} |
| 123 |
|
| 124 |
|
| 125 |
/*-------------------------------------------------------------------------- |
| 126 |
* Curve::clamp - clamp the sampling rate to a given maximum |
| 127 |
*-------------------------------------------------------------------------- |
| 128 |
*/ |
| 129 |
|
| 130 |
void |
| 131 |
Curve::clamp( void ) |
| 132 |
{ |
| 133 |
if( stepsize < minstepsize ) |
| 134 |
stepsize = mapdesc->clampfactor * minstepsize; |
| 135 |
} |
| 136 |
|
| 137 |
void |
| 138 |
Curve::setstepsize( REAL max ) |
| 139 |
{ |
| 140 |
stepsize = ( max >= 1.0 ) ? (range[2] / max) : range[2]; |
| 141 |
minstepsize = stepsize; |
| 142 |
} |
| 143 |
|
| 144 |
void |
| 145 |
Curve::getstepsize( void ) |
| 146 |
{ |
| 147 |
minstepsize= 0; |
| 148 |
|
| 149 |
if( mapdesc->isConstantSampling() ) { |
| 150 |
// fixed number of samples per patch in each direction |
| 151 |
// maxrate is number of s samples per patch |
| 152 |
setstepsize( mapdesc->maxrate ); |
| 153 |
} else if( mapdesc->isDomainSampling() ) { |
| 154 |
// maxrate is number of s samples per unit s length of domain |
| 155 |
setstepsize( mapdesc->maxrate * range[2] ); |
| 156 |
} else { |
| 157 |
// upper bound on path length between sample points |
| 158 |
|
| 159 |
assert( order <= MAXORDER ); |
| 160 |
|
| 161 |
/* points have been transformed, therefore they are homogeneous */ |
| 162 |
REAL tmp[MAXORDER][MAXCOORDS]; |
| 163 |
const int tstride = sizeof(tmp[0]) / sizeof(REAL); |
| 164 |
int val = mapdesc->project( spts, stride, &tmp[0][0], tstride, order ); |
| 165 |
|
| 166 |
if( val == 0 ) { |
| 167 |
// control points cross infinity, therefore derivatives are undefined |
| 168 |
setstepsize( mapdesc->maxrate ); |
| 169 |
} else { |
| 170 |
REAL t = mapdesc->getProperty( N_PIXEL_TOLERANCE ); |
| 171 |
if( mapdesc->isParametricDistanceSampling() ) { |
| 172 |
REAL d = mapdesc->calcPartialVelocity( &tmp[0][0], tstride, order, 2, range[2] ); |
| 173 |
stepsize = (d > 0.0) ? ::sqrtf( 8.0 * t / d ) : range[2]; |
| 174 |
minstepsize = ( mapdesc->maxrate > 0.0 ) ? (range[2] / mapdesc->maxrate) : 0.0; |
| 175 |
} else if( mapdesc->isPathLengthSampling() ) { |
| 176 |
// t is upper bound on path (arc) length |
| 177 |
REAL d = mapdesc->calcPartialVelocity( &tmp[0][0], tstride, order, 1, range[2] ); |
| 178 |
stepsize = ( d > 0.0 ) ? (t / d) : range[2]; |
| 179 |
minstepsize = ( mapdesc->maxrate > 0.0 ) ? (range[2] / mapdesc->maxrate) : 0.0; |
| 180 |
} else { |
| 181 |
// control points cross infinity, therefore partials are undefined |
| 182 |
setstepsize( mapdesc->maxrate ); |
| 183 |
} |
| 184 |
} |
| 185 |
} |
| 186 |
} |
| 187 |
|
| 188 |
int |
| 189 |
Curve::needsSamplingSubdivision( void ) |
| 190 |
{ |
| 191 |
return ( stepsize < minstepsize ) ? 1 : 0; |
| 192 |
} |
| 193 |
|
| 194 |
int |
| 195 |
Curve::cullCheck( void ) |
| 196 |
{ |
| 197 |
if( cullval == CULL_ACCEPT ) |
| 198 |
cullval = mapdesc->cullCheck( cpts, order, stride ); |
| 199 |
return cullval; |
| 200 |
} |
| 201 |
|