ArcTessellator Class Reference

#include <arctess.h>

Collaboration diagram for ArcTessellator:

Public Member Functions
	ArcTessellator (TrimVertexPool &, Pool &)
	~ArcTessellator (void)
void	bezier (Arc_ptr, REAL, REAL, REAL, REAL)
void	pwl (Arc_ptr, REAL, REAL, REAL, REAL, REAL)
void	pwl_left (Arc_ptr, REAL, REAL, REAL, REAL)
void	pwl_right (Arc_ptr, REAL, REAL, REAL, REAL)
void	pwl_top (Arc_ptr, REAL, REAL, REAL, REAL)
void	pwl_bottom (Arc_ptr, REAL, REAL, REAL, REAL)
void	tessellateLinear (Arc_ptr, REAL, REAL, int)
void	tessellateNonlinear (Arc_ptr, REAL, REAL, int)

Static Private Member Functions
static void	trim_power_coeffs (BezierArc *, REAL[MAXORDER], int)

Private Attributes
Pool &	pwlarcpool
TrimVertexPool &	trimvertexpool

Static Private Attributes
static const REAL	gl_Bernstein [][MAXORDER][MAXORDER]

Detailed Description

Definition at line 47 of file arctess.h.

Constructor & Destructor Documentation

ArcTessellator()

ArcTessellator::ArcTessellator	(	TrimVertexPool &	t,
		Pool &	p
	)

Definition at line 59 of file arctess.cc.

    : pwlarcpool(p), trimvertexpool(t)
{
}

~ArcTessellator()

ArcTessellator::~ArcTessellator

(

void

)

Definition at line 69 of file arctess.cc.

{
}

Member Function Documentation

bezier()

void ArcTessellator::bezier	(	Arc_ptr	,
		REAL	,
		REAL	,
		REAL	,
		REAL
	)

Definition at line 79 of file arctess.cc.

{
    assert( arc != 0 );
    assert( ! arc->isTessellated() );

#ifndef NDEBUG
    switch( arc->getside() ) {
    case arc_left:
        assert( s1 == s2 );
        assert( t2 < t1 );
        break;
    case arc_right:
        assert( s1 == s2 );
        assert( t1 < t2 );
        break;
    case arc_top:
        assert( t1 == t2 );
        assert( s2 < s1 );
        break;
    case arc_bottom:
        assert( t1 == t2 );
        assert( s1 < s2 );
        break;
    case arc_none:
        (void) abort();
        break;
    }
#endif
    
    TrimVertex *p = trimvertexpool.get(2);
    arc->pwlArc = new(pwlarcpool) PwlArc( 2, p );
    p[0].param[0] = s1;
    p[0].param[1] = t1;
    p[1].param[0] = s2;
    p[1].param[1] = t2;
    assert( (s1 == s2) || (t1 == t2) );
    arc->setbezier();
}

Referenced by Subdivider::join_s(), Subdivider::join_t(), Subdivider::makeBorderTrim(), and Subdivider::makePatchBoundary().

pwl()

void ArcTessellator::pwl	(	Arc_ptr	,
		REAL	,
		REAL	,
		REAL	,
		REAL	,
		REAL
	)

Definition at line 243 of file arctess.cc.

{

/*    if(rate <= 0.06) rate = 0.06;*/

    int snsteps = 1 + (int) (glu_abs(s2 - s1) / rate );
    int tnsteps = 1 + (int) (glu_abs(t2 - t1) / rate );
    int nsteps = max(1,max( snsteps, tnsteps ));

    REAL sstepsize = (s2 - s1) / (REAL) nsteps;
    REAL tstepsize = (t2 - t1) / (REAL) nsteps;
    TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
    long i;
    for( i = 0; i < nsteps; i++ ) {
    newvert[i].param[0] = s1;
    newvert[i].param[1] = t1;
    s1 += sstepsize;
    t1 += tstepsize;
    }
    newvert[i].param[0] = s2;
    newvert[i].param[1] = t2;

    /* arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_bottom ); */
    arc->pwlArc = new(pwlarcpool) PwlArc( nsteps+1, newvert );

    arc->clearbezier();
    arc->clearside( );
}

Referenced by tessellateLinear().

pwl_bottom()

void ArcTessellator::pwl_bottom	(	Arc_ptr	,
		REAL	,
		REAL	,
		REAL	,
		REAL
	)

Definition at line 214 of file arctess.cc.

{
    assert( s1 < s2 );

/*    if(rate <= 0.06) rate = 0.06;*/

/*    int nsteps = 1 + (int) ((s2 - s1) / rate ); */
    int nsteps = steps_function(s2,s1,rate);
    REAL stepsize = (s2 - s1) / (REAL) nsteps;

    TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
    int i;
    for( i = 0; i < nsteps; i++ ) {
    newvert[i].param[0] = s1;
    newvert[i].param[1] = t;
    s1 += stepsize;
    }
    newvert[i].param[0] = s2;
    newvert[i].param[1] = t;

    arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_bottom );
}

Referenced by Subdivider::join_t(), Subdivider::tessellate(), and tessellateLinear().

pwl_left()

void ArcTessellator::pwl_left	(	Arc_ptr	,
		REAL	,
		REAL	,
		REAL	,
		REAL
	)

Definition at line 125 of file arctess.cc.

{
    assert( t2 < t1 );

/*    if(rate <= 0.06) rate = 0.06;*/
/*    int nsteps = 1 + (int) ((t1 - t2) / rate ); */
    int nsteps = steps_function(t1, t2, rate);


    REAL stepsize = (t1 - t2) / (REAL) nsteps;

    TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
    int i;
    for( i = nsteps; i > 0; i-- ) {
    newvert[i].param[0] = s;
    newvert[i].param[1] = t2;
    t2 += stepsize;
    }
    newvert[i].param[0] = s;
    newvert[i].param[1] = t1;

    arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_left );
}

Referenced by Subdivider::join_s(), Subdivider::tessellate(), and tessellateLinear().

pwl_right()

void ArcTessellator::pwl_right	(	Arc_ptr	,
		REAL	,
		REAL	,
		REAL	,
		REAL
	)

Definition at line 155 of file arctess.cc.

{
    assert( t1 < t2 );

/*    if(rate <= 0.06) rate = 0.06;*/

/*    int nsteps = 1 + (int) ((t2 - t1) / rate ); */
    int nsteps = steps_function(t2,t1,rate);
    REAL stepsize = (t2 - t1) / (REAL) nsteps;

    TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
    int i;
    for( i = 0; i < nsteps; i++ ) {
    newvert[i].param[0] = s;
    newvert[i].param[1] = t1;
    t1 += stepsize;
    }
    newvert[i].param[0] = s;
    newvert[i].param[1] = t2;

    arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_right );
}

Referenced by Subdivider::join_s(), Subdivider::tessellate(), and tessellateLinear().

pwl_top()

void ArcTessellator::pwl_top	(	Arc_ptr	,
		REAL	,
		REAL	,
		REAL	,
		REAL
	)

Definition at line 185 of file arctess.cc.

{
    assert( s2 < s1 );

/*    if(rate <= 0.06) rate = 0.06;*/

/*    int nsteps = 1 + (int) ((s1 - s2) / rate ); */
    int nsteps = steps_function(s1,s2,rate);
    REAL stepsize = (s1 - s2) / (REAL) nsteps;

    TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
    int i;
    for( i = nsteps; i > 0; i-- ) {
    newvert[i].param[0] = s2;
    newvert[i].param[1] = t;
    s2 += stepsize;
    }
    newvert[i].param[0] = s1;
    newvert[i].param[1] = t;

    arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_top );
}

Referenced by Subdivider::join_t(), Subdivider::tessellate(), and tessellateLinear().

tessellateLinear()

void ArcTessellator::tessellateLinear	(	Arc_ptr	,
		REAL	,
		REAL	,
		int
	)

Definition at line 279 of file arctess.cc.

{
    assert( arc->pwlArc == NULL );
    REAL s1, s2, t1, t2;

    //we don't need to scale by arc_stepsize if the trim curve
    //is piecewise linear. Reason: In pwl_right, pwl_left, pwl_top, pwl_left,
    //and pwl, the nsteps is computed by deltaU (or V) /stepsize. 
    //The quantity deltaU/arc_stepsize doesn't have any meaning. And
    //it causes problems: see bug 517641
    REAL stepsize = geo_stepsize; /* * arc_stepsize*/;

    BezierArc *b = arc->bezierArc;

    if( isrational ) {
    s1 = b->cpts[0] / b->cpts[2];
    t1 = b->cpts[1] / b->cpts[2];
    s2 = b->cpts[b->stride+0] / b->cpts[b->stride+2];
    t2 = b->cpts[b->stride+1] / b->cpts[b->stride+2];
    } else {
    s1 = b->cpts[0];
    t1 = b->cpts[1];
    s2 = b->cpts[b->stride+0];
    t2 = b->cpts[b->stride+1];
    }
    if( s1 == s2 )
    if( t1 < t2 )
        pwl_right( arc, s1, t1, t2, stepsize );
    else
        pwl_left( arc, s1, t1, t2, stepsize );
    else if( t1 == t2 )
    if( s1 < s2 ) 
        pwl_bottom( arc, t1, s1, s2, stepsize );
    else
        pwl_top( arc, t1, s1, s2, stepsize );
    else
    pwl( arc, s1, s2, t1, t2, stepsize );
}

Referenced by Subdivider::tessellate().

tessellateNonlinear()

void ArcTessellator::tessellateNonlinear	(	Arc_ptr	,
		REAL	,
		REAL	,
		int
	)

Definition at line 324 of file arctess.cc.

{
    assert( arc->pwlArc == NULL );

    REAL stepsize   = geo_stepsize * arc_stepsize;

    BezierArc *bezierArc = arc->bezierArc;

    REAL size; //bounding box size of the curve in UV 
    {
      int i,j;
      REAL min_u, min_v, max_u,max_v;
      min_u = max_u = bezierArc->cpts[0];
      min_v = max_v = bezierArc->cpts[1];
      for(i=1, j=bezierArc->stride; i<bezierArc->order; i++, j+= bezierArc->stride)
    {
      if(bezierArc->cpts[j] < min_u)
        min_u = bezierArc->cpts[j];
      if(bezierArc->cpts[j] > max_u)
        max_u = bezierArc->cpts[j];
      if(bezierArc->cpts[j+1] < min_v)
        min_v = bezierArc->cpts[j+1];     
      if(bezierArc->cpts[j+1] > max_v)
        max_v = bezierArc->cpts[j+1]; 
    }

      size = max_u - min_u;
      if(size < max_v - min_v)
    size = max_v - min_v;
    }
      
    /*int   nsteps      = 1 + (int) (1.0/stepsize);*/

    int nsteps = (int) (size/stepsize);
    if(nsteps <=0)
      nsteps=1;

    TrimVertex *vert    = trimvertexpool.get( nsteps+1 );
    REAL dp         = 1.0/nsteps;


    arc->pwlArc     = new(pwlarcpool) PwlArc();
    arc->pwlArc->pts    = vert;

    if( isrational ) {
        REAL pow_u[MAXORDER], pow_v[MAXORDER], pow_w[MAXORDER];
        trim_power_coeffs( bezierArc, pow_u, 0 );
        trim_power_coeffs( bezierArc, pow_v, 1 );
        trim_power_coeffs( bezierArc, pow_w, 2 );

    /* compute first point exactly */
        REAL *b = bezierArc->cpts;
    vert->param[0] = b[0]/b[2];
    vert->param[1] = b[1]/b[2];

    /* strength reduction on p = dp * step would introduce error */
    int step;
#ifndef NOELIMINATION
    int ocanremove = 0;
#endif
        long order =  bezierArc->order;
    for( step=1, ++vert; step<nsteps; step++, vert++ ) {
        REAL p = dp * step;
            REAL u = pow_u[0];
            REAL v = pow_v[0];
        REAL w = pow_w[0];
        for( int i = 1; i < order; i++ ) {
            u = u * p + pow_u[i];
            v = v * p + pow_v[i];
            w = w * p + pow_w[i];
            }
            vert->param[0] = u/w;
            vert->param[1] = v/w;
#ifndef NOELIMINATION
        REAL ds = glu_abs(vert[0].param[0] - vert[-1].param[0]);
        REAL dt = glu_abs(vert[0].param[1] - vert[-1].param[1]);
        int canremove = (ds<geo_stepsize && dt<geo_stepsize) ? 1 : 0;
        REAL ods=0.0, odt=0.0;

        if( ocanremove && canremove ) {
        REAL nds = ds + ods;
        REAL ndt = dt + odt;
        if( nds<geo_stepsize && ndt<geo_stepsize ) {
            // remove previous point
            --vert;
            vert[0].param[0] = vert[1].param[0];
            vert[0].param[1] = vert[1].param[1];
            ods = nds;
            odt = ndt;
            ocanremove = 1;
        } else {
            ocanremove = canremove;
            ods = ds;
            odt = dt;
        }
        } else {
        ocanremove = canremove;
        ods = ds;
        odt = dt;
        }
#endif  
    }

    /* compute last point exactly */
    b += (order - 1) * bezierArc->stride;
    vert->param[0] = b[0]/b[2];
    vert->param[1] = b[1]/b[2];

    } else {
        REAL pow_u[MAXORDER], pow_v[MAXORDER];
    trim_power_coeffs( bezierArc, pow_u, 0 );
    trim_power_coeffs( bezierArc, pow_v, 1 );

    /* compute first point exactly */
        REAL *b = bezierArc->cpts;
    vert->param[0] = b[0];
    vert->param[1] = b[1];

    /* strength reduction on p = dp * step would introduce error */
    int step;
#ifndef NOELIMINATION
    int ocanremove = 0;
#endif
        long order =  bezierArc->order;
    for( step=1, ++vert; step<nsteps; step++, vert++ ) {
        REAL p = dp * step;
        REAL u = pow_u[0];
            REAL v = pow_v[0];
            for( int i = 1; i < bezierArc->order; i++ ) {
            u = u * p + pow_u[i];
            v = v * p + pow_v[i];
            }
            vert->param[0] = u;
        vert->param[1] = v;
#ifndef NOELIMINATION
        REAL ds = glu_abs(vert[0].param[0] - vert[-1].param[0]);
        REAL dt = glu_abs(vert[0].param[1] - vert[-1].param[1]);
        int canremove = (ds<geo_stepsize && dt<geo_stepsize) ? 1 : 0;
        REAL ods=0.0, odt=0.0;

        if( ocanremove && canremove ) {
        REAL nds = ds + ods;
        REAL ndt = dt + odt;
        if( nds<geo_stepsize && ndt<geo_stepsize ) {
            // remove previous point
            --vert;
            vert[0].param[0] = vert[1].param[0];
            vert[0].param[1] = vert[1].param[1];
            ods = nds;
            odt = ndt;
            ocanremove = 1;
        } else {
            ocanremove = canremove;
            ods = ds;
            odt = dt;
        }
        } else {
        ocanremove = canremove;
        ods = ds;
        odt = dt;
        }
#endif  
    }

    /* compute last point exactly */
    b += (order - 1) * bezierArc->stride;
    vert->param[0] = b[0];
    vert->param[1] = b[1];
    }
    arc->pwlArc->npts = vert - arc->pwlArc->pts + 1;
/*
    for( TrimVertex *vt=pwlArc->pts; vt != vert-1; vt++ ) {
    if( tooclose( vt[0].param[0], vt[1].param[0] ) )
        vt[1].param[0] = vt[0].param[0];
    if( tooclose( vt[0].param[1], vt[1].param[1] ) )
        vt[1].param[1] = vt[0].param[1];
    }
*/
}

Referenced by Subdivider::tessellate().

trim_power_coeffs()

void ArcTessellator::trim_power_coeffs ( BezierArc *  , REAL  [MAXORDER], int    )

staticprivate

Definition at line 592 of file arctess.cc.

{
    int stride = bez_arc->stride;
    int order = bez_arc->order;
    REAL *base = bez_arc->cpts + coord;

    REAL const (*mat)[MAXORDER][MAXORDER] = &gl_Bernstein[order-1];
    REAL const (*lrow)[MAXORDER] = &(*mat)[order];

    /* WIN32 didn't like the following line within the for-loop */
    REAL const (*row)[MAXORDER] =  &(*mat)[0];
    for( ; row != lrow; row++ ) {
    REAL s = 0.0;
    REAL *point = base;
    REAL const *mlast = *row + order;
    for( REAL const *m = *row; m != mlast; m++, point += stride ) 
        s += *(m) * (*point);
    *(p++) = s;
    }
}

Referenced by tessellateNonlinear().

Member Data Documentation

gl_Bernstein

const REAL ArcTessellator::gl_Bernstein

staticprivate

Definition at line 60 of file arctess.h.

Referenced by trim_power_coeffs().

pwlarcpool

Pool& ArcTessellator::pwlarcpool

private

Definition at line 61 of file arctess.h.

Referenced by bezier(), pwl(), pwl_bottom(), pwl_left(), pwl_right(), pwl_top(), and tessellateNonlinear().

trimvertexpool

TrimVertexPool& ArcTessellator::trimvertexpool

private

Definition at line 62 of file arctess.h.

Referenced by bezier(), pwl(), pwl_bottom(), pwl_left(), pwl_right(), pwl_top(), and tessellateNonlinear().

---

The documentation for this class was generated from the following files:

• dll/opengl/glu32/src/libnurbs/internals/arctess.h
• dll/opengl/glu32/src/libnurbs/internals/arctess.cc