src/glu/sgi/libnurbs/internals/arctess.cc

   1 /*
   2 ** License Applicability. Except to the extent portions of this file are
   3 ** made subject to an alternative license as permitted in the SGI Free
   4 ** Software License B, Version 1.1 (the "License"), the contents of this
   5 ** file are subject only to the provisions of the License. You may not use
   6 ** this file except in compliance with the License. You may obtain a copy
   7 ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
   8 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
   9 **
  10 ** http://oss.sgi.com/projects/FreeB
  11 **
  12 ** Note that, as provided in the License, the Software is distributed on an
  13 ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
  14 ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
  15 ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
  16 ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
  17 **
  18 ** Original Code. The Original Code is: OpenGL Sample Implementation,
  19 ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
  20 ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
  21 ** Copyright in any portions created by third parties is as indicated
  22 ** elsewhere herein. All Rights Reserved.
  23 **
  24 ** Additional Notice Provisions: The application programming interfaces
  25 ** established by SGI in conjunction with the Original Code are The
  26 ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
  27 ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
  28 ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
  29 ** Window System(R) (Version 1.3), released October 19, 1998. This software
  30 ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
  31 ** published by SGI, but has not been independently verified as being
  32 ** compliant with the OpenGL(R) version 1.2.1 Specification.
  33 */
  34
  35 /*
  36  * arctessellator.c++
  37  *
  38  */
  39
  40 #include "glimports.h"
  41 #include "mystdio.h"
  42 #include "myassert.h"
  43 #include "arctess.h"
  44 #include "bufpool.h"
  45 #include "simplemath.h"
  46 #include "bezierarc.h"
  47 #include "trimvertex.h"
  48 #include "trimvertpool.h"
  49
  50 #define NOELIMINATION
  51
  52 #define steps_function(large, small, rate) (max(1, 1+ (int) ((large-small)/rate)));
  53
  54 /*-----------------------------------------------------------------------------
  55  * ArcTessellator - construct an ArcTessellator
  56  *-----------------------------------------------------------------------------
  57  */
  58
  59 ArcTessellator::ArcTessellator( TrimVertexPool& t, Pool& p )
  60         : pwlarcpool(p), trimvertexpool(t)
  61 {
  62 }
  63
  64 /*-----------------------------------------------------------------------------
  65  * ~ArcTessellator - destroy an ArcTessellator
  66  *-----------------------------------------------------------------------------
  67  */
  68
  69 ArcTessellator::~ArcTessellator( void )
  70 {
  71 }
  72
  73 /*-----------------------------------------------------------------------------
  74  * bezier - construct a bezier arc and attach it to an Arc
  75  *-----------------------------------------------------------------------------
  76  */
  77
  78 void
  79 ArcTessellator::bezier( Arc *arc, REAL s1, REAL s2, REAL t1, REAL t2 )
  80 {
  81     assert( arc != 0 );
  82     assert( ! arc->isTessellated() );
  83
  84 #ifndef NDEBUG
  85     switch( arc->getside() ) {
  86         case arc_left:
  87             assert( s1 == s2 );
  88             assert( t2 < t1 );
  89             break;
  90         case arc_right:
  91             assert( s1 == s2 );
  92             assert( t1 < t2 );
  93             break;
  94         case arc_top:
  95             assert( t1 == t2 );
  96             assert( s2 < s1 );
  97             break;
  98         case arc_bottom:
  99             assert( t1 == t2 );
 100             assert( s1 < s2 );
 101             break;
 102         case arc_none:
 103             (void) abort();
 104             break;
 105     }
 106 #endif
 107
 108     TrimVertex *p = trimvertexpool.get(2);
 109     arc->pwlArc = new(pwlarcpool) PwlArc( 2, p );
 110     p[0].param[0] = s1;
 111     p[0].param[1] = t1;
 112     p[1].param[0] = s2;
 113     p[1].param[1] = t2;
 114     assert( (s1 == s2) || (t1 == t2) );
 115     arc->setbezier();
 116 }
 117
 118
 119 /*-----------------------------------------------------------------------------
 120  * pwl_left - construct a left boundary pwl arc and attach it to an arc
 121  *-----------------------------------------------------------------------------
 122  */
 123
 124 void
 125 ArcTessellator::pwl_left( Arc *arc, REAL s, REAL t1, REAL t2, REAL rate )
 126 {
 127     assert( t2 < t1 );
 128
 129 /*    if(rate <= 0.06) rate = 0.06;*/
 130 /*    int nsteps = 1 + (int) ((t1 - t2) / rate ); */
 131     int nsteps = steps_function(t1, t2, rate);
 132
 133
 134     REAL stepsize = (t1 - t2) / (REAL) nsteps;
 135
 136     TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
 137     int i;
 138     for( i = nsteps; i > 0; i-- ) {
 139         newvert[i].param[0] = s;
 140         newvert[i].param[1] = t2;
 141         t2 += stepsize;
 142     }
 143     newvert[i].param[0] = s;
 144     newvert[i].param[1] = t1;
 145
 146     arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_left );
 147 }
 148
 149 /*-----------------------------------------------------------------------------
 150  * pwl_right - construct a right boundary pwl arc and attach it to an arc
 151  *-----------------------------------------------------------------------------
 152  */
 153
 154 void
 155 ArcTessellator::pwl_right( Arc *arc, REAL s, REAL t1, REAL t2, REAL rate )
 156 {
 157     assert( t1 < t2 );
 158
 159 /*    if(rate <= 0.06) rate = 0.06;*/
 160
 161 /*    int nsteps = 1 + (int) ((t2 - t1) / rate ); */
 162     int nsteps = steps_function(t2,t1,rate);
 163     REAL stepsize = (t2 - t1) / (REAL) nsteps;
 164
 165     TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
 166     int i;
 167     for( i = 0; i < nsteps; i++ ) {
 168         newvert[i].param[0] = s;
 169         newvert[i].param[1] = t1;
 170         t1 += stepsize;
 171     }
 172     newvert[i].param[0] = s;
 173     newvert[i].param[1] = t2;
 174
 175     arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_right );
 176 }
 177
 178
 179 /*-----------------------------------------------------------------------------
 180  * pwl_top - construct a top boundary pwl arc and attach it to an arc
 181  *-----------------------------------------------------------------------------
 182  */
 183
 184 void
 185 ArcTessellator::pwl_top( Arc *arc, REAL t, REAL s1, REAL s2, REAL rate )
 186 {
 187     assert( s2 < s1 );
 188
 189 /*    if(rate <= 0.06) rate = 0.06;*/
 190
 191 /*    int nsteps = 1 + (int) ((s1 - s2) / rate ); */
 192     int nsteps = steps_function(s1,s2,rate);
 193     REAL stepsize = (s1 - s2) / (REAL) nsteps;
 194
 195     TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
 196     int i;
 197     for( i = nsteps; i > 0; i-- ) {
 198         newvert[i].param[0] = s2;
 199         newvert[i].param[1] = t;
 200         s2 += stepsize;
 201     }
 202     newvert[i].param[0] = s1;
 203     newvert[i].param[1] = t;
 204
 205     arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_top );
 206 }
 207
 208 /*-----------------------------------------------------------------------------
 209  * pwl_bottom - construct a bottom boundary pwl arc and attach it to an arc
 210  *-----------------------------------------------------------------------------
 211  */
 212
 213 void
 214 ArcTessellator::pwl_bottom( Arc *arc, REAL t, REAL s1, REAL s2, REAL rate )
 215 {
 216     assert( s1 < s2 );
 217
 218 /*    if(rate <= 0.06) rate = 0.06;*/
 219
 220 /*    int nsteps = 1 + (int) ((s2 - s1) / rate ); */
 221     int nsteps = steps_function(s2,s1,rate);
 222     REAL stepsize = (s2 - s1) / (REAL) nsteps;
 223
 224     TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
 225     int i;
 226     for( i = 0; i < nsteps; i++ ) {
 227         newvert[i].param[0] = s1;
 228         newvert[i].param[1] = t;
 229         s1 += stepsize;
 230     }
 231     newvert[i].param[0] = s2;
 232     newvert[i].param[1] = t;
 233
 234     arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_bottom );
 235 }
 236
 237 /*-----------------------------------------------------------------------------
 238  * pwl - construct a pwl arc and attach it to an arc
 239  *-----------------------------------------------------------------------------
 240  */
 241
 242 void
 243 ArcTessellator::pwl( Arc *arc, REAL s1, REAL s2, REAL t1, REAL t2, REAL rate )
 244 {
 245
 246 /*    if(rate <= 0.06) rate = 0.06;*/
 247
 248     int snsteps = 1 + (int) (glu_abs(s2 - s1) / rate );
 249     int tnsteps = 1 + (int) (glu_abs(t2 - t1) / rate );
 250     int nsteps = max(1,max( snsteps, tnsteps ));
 251
 252     REAL sstepsize = (s2 - s1) / (REAL) nsteps;
 253     REAL tstepsize = (t2 - t1) / (REAL) nsteps;
 254     TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
 255     long i;
 256     for( i = 0; i < nsteps; i++ ) {
 257         newvert[i].param[0] = s1;
 258         newvert[i].param[1] = t1;
 259         s1 += sstepsize;
 260         t1 += tstepsize;
 261     }
 262     newvert[i].param[0] = s2;
 263     newvert[i].param[1] = t2;
 264
 265     /* arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_bottom ); */
 266     arc->pwlArc = new(pwlarcpool) PwlArc( nsteps+1, newvert );
 267
 268     arc->clearbezier();
 269     arc->clearside( );
 270 }
 271
 272
 273 /*-----------------------------------------------------------------------------
 274  * tessellateLinear - constuct a linear pwl arc and attach it to an Arc
 275  *-----------------------------------------------------------------------------
 276  */
 277
 278 void
 279 ArcTessellator::tessellateLinear( Arc *arc, REAL geo_stepsize, REAL arc_stepsize, int isrational )
 280 {
 281     assert( arc->pwlArc == NULL );
 282     REAL s1, s2, t1, t2;
 283
 284     //we don't need to scale by arc_stepsize if the trim curve
 285     //is piecewise linear. Reason: In pwl_right, pwl_left, pwl_top, pwl_left,
 286     //and pwl, the nsteps is computed by deltaU (or V) /stepsize.
 287     //The quantity deltaU/arc_stepsize doesn't have any meaning. And
 288     //it causes problems: see bug 517641
 289     REAL stepsize = geo_stepsize; /* * arc_stepsize*/;
 290
 291     BezierArc *b = arc->bezierArc;
 292
 293     if( isrational ) {
 294         s1 = b->cpts[0] / b->cpts[2];
 295         t1 = b->cpts[1] / b->cpts[2];
 296         s2 = b->cpts[b->stride+0] / b->cpts[b->stride+2];
 297         t2 = b->cpts[b->stride+1] / b->cpts[b->stride+2];
 298     } else {
 299         s1 = b->cpts[0];
 300         t1 = b->cpts[1];
 301         s2 = b->cpts[b->stride+0];
 302         t2 = b->cpts[b->stride+1];
 303     }
 304     if( s1 == s2 )
 305         if( t1 < t2 )
 306             pwl_right( arc, s1, t1, t2, stepsize );
 307         else
 308             pwl_left( arc, s1, t1, t2, stepsize );
 309     else if( t1 == t2 )
 310         if( s1 < s2 )
 311             pwl_bottom( arc, t1, s1, s2, stepsize );
 312         else
 313             pwl_top( arc, t1, s1, s2, stepsize );
 314     else
 315         pwl( arc, s1, s2, t1, t2, stepsize );
 316 }
 317
 318 /*-----------------------------------------------------------------------------
 319  * tessellateNonlinear - constuct a nonlinear pwl arc and attach it to an Arc
 320  *-----------------------------------------------------------------------------
 321  */
 322
 323 void
 324 ArcTessellator::tessellateNonlinear( Arc *arc, REAL geo_stepsize, REAL arc_stepsize, int isrational )
 325 {
 326     assert( arc->pwlArc == NULL );
 327
 328     REAL stepsize       = geo_stepsize * arc_stepsize;
 329
 330     BezierArc *bezierArc = arc->bezierArc;
 331
 332     REAL size; //bounding box size of the curve in UV
 333     {
 334       int i,j;
 335       REAL min_u, min_v, max_u,max_v;
 336       min_u = max_u = bezierArc->cpts[0];
 337       min_v = max_v = bezierArc->cpts[1];
 338       for(i=1, j=bezierArc->stride; i<bezierArc->order; i++, j+= bezierArc->stride)
 339         {
 340           if(bezierArc->cpts[j] < min_u)
 341             min_u = bezierArc->cpts[j];
 342           if(bezierArc->cpts[j] > max_u)
 343             max_u = bezierArc->cpts[j];
 344           if(bezierArc->cpts[j+1] < min_v)
 345             min_v = bezierArc->cpts[j+1];
 346           if(bezierArc->cpts[j+1] > max_v)
 347             max_v = bezierArc->cpts[j+1];
 348         }
 349
 350       size = max_u - min_u;
 351       if(size < max_v - min_v)
 352         size = max_v - min_v;
 353     }
 354
 355     /*int       nsteps          = 1 + (int) (1.0/stepsize);*/
 356
 357     int nsteps = (int) (size/stepsize);
 358     if(nsteps <=0)
 359       nsteps=1;
 360
 361     TrimVertex *vert    = trimvertexpool.get( nsteps+1 );
 362     REAL dp             = 1.0/nsteps;
 363
 364
 365     arc->pwlArc         = new(pwlarcpool) PwlArc();
 366     arc->pwlArc->pts    = vert;
 367
 368     if( isrational ) {
 369         REAL pow_u[MAXORDER], pow_v[MAXORDER], pow_w[MAXORDER];
 370         trim_power_coeffs( bezierArc, pow_u, 0 );
 371         trim_power_coeffs( bezierArc, pow_v, 1 );
 372         trim_power_coeffs( bezierArc, pow_w, 2 );
 373
 374         /* compute first point exactly */
 375         REAL *b = bezierArc->cpts;
 376         vert->param[0] = b[0]/b[2];
 377         vert->param[1] = b[1]/b[2];
 378
 379         /* strength reduction on p = dp * step would introduce error */
 380         int step;
 381 #ifndef NOELIMINATION
 382         int ocanremove = 0;
 383 #endif
 384         register long order =  bezierArc->order;
 385         for( step=1, ++vert; step<nsteps; step++, vert++ ) {
 386             register REAL p = dp * step;
 387             register REAL u = pow_u[0];
 388             register REAL v = pow_v[0];
 389             register REAL w = pow_w[0];
 390             for( register int i = 1; i < order; i++ ) {
 391                 u = u * p + pow_u[i];
 392                 v = v * p + pow_v[i];
 393                 w = w * p + pow_w[i];
 394             }
 395             vert->param[0] = u/w;
 396             vert->param[1] = v/w;
 397 #ifndef NOELIMINATION
 398             REAL ds = glu_abs(vert[0].param[0] - vert[-1].param[0]);
 399             REAL dt = glu_abs(vert[0].param[1] - vert[-1].param[1]);
 400             int canremove = (ds<geo_stepsize && dt<geo_stepsize) ? 1 : 0;
 401             REAL ods=0.0, odt=0.0;
 402
 403             if( ocanremove && canremove ) {
 404                 REAL nds = ds + ods;
 405                 REAL ndt = dt + odt;
 406                 if( nds<geo_stepsize && ndt<geo_stepsize ) {
 407                     // remove previous point
 408                     --vert;
 409                     vert[0].param[0] = vert[1].param[0];
 410                     vert[0].param[1] = vert[1].param[1];
 411                     ods = nds;
 412                     odt = ndt;
 413                     ocanremove = 1;
 414                 } else {
 415                     ocanremove = canremove;
 416                     ods = ds;
 417                     odt = dt;
 418                 }
 419             } else {
 420                 ocanremove = canremove;
 421                 ods = ds;
 422                 odt = dt;
 423             }
 424 #endif
 425         }
 426
 427         /* compute last point exactly */
 428         b += (order - 1) * bezierArc->stride;
 429         vert->param[0] = b[0]/b[2];
 430         vert->param[1] = b[1]/b[2];
 431
 432     } else {
 433         REAL pow_u[MAXORDER], pow_v[MAXORDER];
 434         trim_power_coeffs( bezierArc, pow_u, 0 );
 435         trim_power_coeffs( bezierArc, pow_v, 1 );
 436
 437         /* compute first point exactly */
 438         REAL *b = bezierArc->cpts;
 439         vert->param[0] = b[0];
 440         vert->param[1] = b[1];
 441
 442         /* strength reduction on p = dp * step would introduce error */
 443         int step;
 444 #ifndef NOELIMINATION
 445         int ocanremove = 0;
 446 #endif
 447         register long order =  bezierArc->order;
 448         for( step=1, ++vert; step<nsteps; step++, vert++ ) {
 449             register REAL p = dp * step;
 450             register REAL u = pow_u[0];
 451             register REAL v = pow_v[0];
 452             for( register int i = 1; i < bezierArc->order; i++ ) {
 453                 u = u * p + pow_u[i];
 454                 v = v * p + pow_v[i];
 455             }
 456             vert->param[0] = u;
 457             vert->param[1] = v;
 458 #ifndef NOELIMINATION
 459             REAL ds = glu_abs(vert[0].param[0] - vert[-1].param[0]);
 460             REAL dt = glu_abs(vert[0].param[1] - vert[-1].param[1]);
 461             int canremove = (ds<geo_stepsize && dt<geo_stepsize) ? 1 : 0;
 462             REAL ods=0.0, odt=0.0;
 463
 464             if( ocanremove && canremove ) {
 465                 REAL nds = ds + ods;
 466                 REAL ndt = dt + odt;
 467                 if( nds<geo_stepsize && ndt<geo_stepsize ) {
 468                     // remove previous point
 469                     --vert;
 470                     vert[0].param[0] = vert[1].param[0];
 471                     vert[0].param[1] = vert[1].param[1];
 472                     ods = nds;
 473                     odt = ndt;
 474                     ocanremove = 1;
 475                 } else {
 476                     ocanremove = canremove;
 477                     ods = ds;
 478                     odt = dt;
 479                 }
 480             } else {
 481                 ocanremove = canremove;
 482                 ods = ds;
 483                 odt = dt;
 484             }
 485 #endif
 486         }
 487
 488         /* compute last point exactly */
 489         b += (order - 1) * bezierArc->stride;
 490         vert->param[0] = b[0];
 491         vert->param[1] = b[1];
 492     }
 493     arc->pwlArc->npts = vert - arc->pwlArc->pts + 1;
 494 /*
 495     for( TrimVertex *vt=pwlArc->pts; vt != vert-1; vt++ ) {
 496         if( tooclose( vt[0].param[0], vt[1].param[0] ) )
 497             vt[1].param[0] = vt[0].param[0];
 498         if( tooclose( vt[0].param[1], vt[1].param[1] ) )
 499             vt[1].param[1] = vt[0].param[1];
 500     }
 501 */
 502 }
 503
 504 const REAL ArcTessellator::gl_Bernstein[][MAXORDER][MAXORDER] = {
 505  {
 506   {1, 0, 0, 0, 0, 0, 0, 0 },
 507   {0, 0, 0, 0, 0, 0, 0, 0 },
 508   {0, 0, 0, 0, 0, 0, 0, 0 },
 509   {0, 0, 0, 0, 0, 0, 0, 0 },
 510   {0, 0, 0, 0, 0, 0, 0, 0 },
 511   {0, 0, 0, 0, 0, 0, 0, 0 },
 512   {0, 0, 0, 0, 0, 0, 0, 0 },
 513   {0, 0, 0, 0, 0, 0, 0, 0 }
 514  },
 515  {
 516   {-1, 1, 0, 0, 0, 0, 0, 0 },
 517   {1, 0, 0, 0, 0, 0, 0, 0 },
 518   {0, 0, 0, 0, 0, 0, 0, 0 },
 519   {0, 0, 0, 0, 0, 0, 0, 0 },
 520   {0, 0, 0, 0, 0, 0, 0, 0 },
 521   {0, 0, 0, 0, 0, 0, 0, 0 },
 522   {0, 0, 0, 0, 0, 0, 0, 0 },
 523   {0, 0, 0, 0, 0, 0, 0, 0 }
 524  },
 525  {
 526   {1, -2, 1, 0, 0, 0, 0, 0 },
 527   {-2, 2, 0, 0, 0, 0, 0, 0 },
 528   {1, 0, 0, 0, 0, 0, 0, 0 },
 529   {0, 0, 0, 0, 0, 0, 0, 0 },
 530   {0, 0, 0, 0, 0, 0, 0, 0 },
 531   {0, 0, 0, 0, 0, 0, 0, 0 },
 532   {0, 0, 0, 0, 0, 0, 0, 0 },
 533   {0, 0, 0, 0, 0, 0, 0, 0 }
 534  },
 535  {
 536   {-1, 3, -3, 1, 0, 0, 0, 0 },
 537   {3, -6, 3, 0, 0, 0, 0, 0 },
 538   {-3, 3, 0, 0, 0, 0, 0, 0 },
 539   {1, 0, 0, 0, 0, 0, 0, 0 },
 540   {0, 0, 0, 0, 0, 0, 0, 0 },
 541   {0, 0, 0, 0, 0, 0, 0, 0 },
 542   {0, 0, 0, 0, 0, 0, 0, 0 },
 543   {0, 0, 0, 0, 0, 0, 0, 0 }
 544  },
 545  {
 546   {1, -4, 6, -4, 1, 0, 0, 0 },
 547   {-4, 12, -12, 4, 0, 0, 0, 0 },
 548   {6, -12, 6, 0, 0, 0, 0, 0 },
 549   {-4, 4, 0, 0, 0, 0, 0, 0 },
 550   {1, 0, 0, 0, 0, 0, 0, 0 },
 551   {0, 0, 0, 0, 0, 0, 0, 0 },
 552   {0, 0, 0, 0, 0, 0, 0, 0 },
 553   {0, 0, 0, 0, 0, 0, 0, 0 }
 554  },
 555  {
 556   {-1, 5, -10, 10, -5, 1, 0, 0 },
 557   {5, -20, 30, -20, 5, 0, 0, 0 },
 558   {-10, 30, -30, 10, 0, 0, 0, 0 },
 559   {10, -20, 10, 0, 0, 0, 0, 0 },
 560   {-5, 5, 0, 0, 0, 0, 0, 0 },
 561   {1, 0, 0, 0, 0, 0, 0, 0 },
 562   {0, 0, 0, 0, 0, 0, 0, 0 },
 563   {0, 0, 0, 0, 0, 0, 0, 0 }
 564  },
 565  {
 566   {1, -6, 15, -20, 15, -6, 1, 0 },
 567   {-6, 30, -60, 60, -30, 6, 0, 0 },
 568   {15, -60, 90, -60, 15, 0, 0, 0 },
 569   {-20, 60, -60, 20, 0, 0, 0, 0 },
 570   {15, -30, 15, 0, 0, 0, 0, 0 },
 571   {-6, 6, 0, 0, 0, 0, 0, 0 },
 572   {1, 0, 0, 0, 0, 0, 0, 0 },
 573   {0, 0, 0, 0, 0, 0, 0, 0 }
 574  },
 575  {
 576   {-1, 7, -21, 35, -35, 21, -7, 1 },
 577   {7, -42, 105, -140, 105, -42, 7, 0 },
 578   {-21, 105, -210, 210, -105, 21, 0, 0 },
 579   {35, -140, 210, -140, 35, 0, 0, 0 },
 580   {-35, 105, -105, 35, 0, 0, 0, 0 },
 581   {21, -42, 21, 0, 0, 0, 0, 0 },
 582   {-7, 7, 0, 0, 0, 0, 0, 0 },
 583   {1, 0, 0, 0, 0, 0, 0, 0 }
 584  }};
 585
 586
 587 /*-----------------------------------------------------------------------------
 588  * trim_power_coeffs - compute power basis coefficients from bezier coeffients
 589  *-----------------------------------------------------------------------------
 590  */
 591 void
 592 ArcTessellator::trim_power_coeffs( BezierArc *bez_arc, REAL *p, int coord )
 593 {
 594     register int stride = bez_arc->stride;
 595     register int order = bez_arc->order;
 596     register REAL *base = bez_arc->cpts + coord;
 597
 598     REAL const (*mat)[MAXORDER][MAXORDER] = &gl_Bernstein[order-1];
 599     REAL const (*lrow)[MAXORDER] = &(*mat)[order];
 600
 601     /* WIN32 didn't like the following line within the for-loop */
 602     REAL const (*row)[MAXORDER] =  &(*mat)[0];
 603     for( ; row != lrow; row++ ) {
 604         register REAL s = 0.0;
 605         register REAL *point = base;
 606         register REAL const *mlast = *row + order;
 607         for( REAL const *m = *row; m != mlast; m++, point += stride )
 608             s += *(m) * (*point);
 609         *(p++) = s;
 610     }
 611 }