Slicer Class Reference

#include <slicer.h>

Inheritance diagram for Slicer:

Collaboration diagram for Slicer:

Public Member Functions
	Slicer (Backend &)
	~Slicer (void)
void	slice (Arc_ptr)
void	slice_old (Arc_ptr)
void	slice_new (Arc_ptr)
void	evalStream (primStream *)
void	evalRBArray (rectBlockArray *rbArray, gridWrap *grid)
void	outline (Arc_ptr)
void	setstriptessellation (REAL, REAL)
void	setisolines (int)
void	set_ulinear (int ulinear_flag)
void	set_vlinear (int vlinear_flag)
Public Member Functions inherited from CoveAndTiler
	CoveAndTiler (Backend &)
	~CoveAndTiler (void)
void	coveAndTile (void)
Public Member Functions inherited from TrimRegion
	TrimRegion ()
void	init (REAL)
void	advance (REAL, REAL, REAL)
void	setDu (REAL)
void	init (long, Arc_ptr)
void	getPts (Arc_ptr)
void	getPts (Backend &)
void	getGridExtent (TrimVertex *, TrimVertex *)
void	getGridExtent (void)
int	canTile (void)
Public Member Functions inherited from Mesher
	Mesher (Backend &)
	~Mesher (void)
void	init (unsigned int)
void	mesh (void)
Public Member Functions inherited from Hull
	Hull (void)
	~Hull (void)
void	init (void)
GridTrimVertex *	nextlower (GridTrimVertex *)
GridTrimVertex *	nextupper (GridTrimVertex *)

Private Member Functions
void	outline (void)
void	initGridlines (void)
void	advanceGridlines (long)

Private Attributes
Backend &	backend
REAL	oneOverDu
REAL	du
REAL	dv
int	isolines
int	ulinear
int	vlinear

Additional Inherited Members
Public Attributes inherited from TrimRegion
Trimline	left
Trimline	right
Gridline	top
Gridline	bot
Uarray	uarray

Detailed Description

Definition at line 49 of file slicer.h.

Constructor & Destructor Documentation

Slicer()

Slicer::Slicer

(

Backend &

b

)

Definition at line 1181 of file slicer.cc.

    : CoveAndTiler( b ), Mesher( b ), backend( b )
{
    oneOverDu = 0;
    du = 0;
    dv = 0;
    isolines = 0;
    ulinear = 0;
    vlinear = 0;
}

~Slicer()

Slicer::~Slicer

(

void

)

Definition at line 1192 of file slicer.cc.

{
}

Member Function Documentation

advanceGridlines()

void Slicer::advanceGridlines ( long  )

private

evalRBArray()

void Slicer::evalRBArray	(	rectBlockArray *	rbArray,
		gridWrap *	grid
	)

Definition at line 1001 of file slicer.cc.

{
  Int i,j,k;
  
  Int n_vlines=grid->get_n_vlines();
  //the reason to switch the position of v_max and v_min is because of the
  //the orientation problem. glEvalMesh generates quad_strip clockwise, but
  //we need counter-clockwise.
  backend.surfgrid(grid->get_u_min(), grid->get_u_max(), grid->get_n_ulines()-1,
           grid->get_v_max(), grid->get_v_min(), n_vlines-1);
 
 
  for(j=0; j<rbArray->get_n_elements(); j++)
    {
      rectBlock* block = rbArray->get_element(j);
      Int low = block->get_lowGridLineIndex();
      Int high = block->get_upGridLineIndex();
 
      for(k=0, i=high; i>low; i--, k++)
    {
      backend.surfmesh(block->get_leftIndices()[k+1], n_vlines-1-i, block->get_rightIndices()[k+1]-block->get_leftIndices()[k+1], 1);
    }
    }
}

Referenced by slice_new().

evalStream()

void Slicer::evalStream

(

primStream *

pStream

)

Definition at line 1027 of file slicer.cc.

{
  Int i,j,k;
  k=0;
/*  TrimVertex X;*/
  TrimVertex *trimVert =/*&X*/  (TrimVertex*)malloc(sizeof(TrimVertex));
  trimVert -> nuid = 0;//???
  Real* vertices = pStream->get_vertices(); //for efficiency
  for(i=0; i<pStream->get_n_prims(); i++)
    {
 
     //ith primitive  has #vertices = lengths[i], type=types[i]
      switch(pStream->get_type(i)){
      case PRIMITIVE_STREAM_FAN:
 
    backend.bgntfan();
 
    for(j=0; j<pStream->get_length(i); j++)
      {     
        trimVert->param[0] = vertices[k];
        trimVert->param[1] = vertices[k+1];
        backend.tmeshvert(trimVert);       
        
//      backend.tmeshvert(vertices[k], vertices[k+1]);
        k += 2;
      }
    backend.endtfan();
    break;
    
      default:
    fprintf(stderr, "evalStream: not implemented yet\n");
    exit(1);
 
      }
    }
  free(trimVert);
}

Referenced by Subdivider::drawSurfaces(), and slice_new().

initGridlines()

void Slicer::initGridlines ( void  )

private

outline() [1/2]

void Slicer::outline

(

Arc_ptr

jarc

)

Definition at line 1292 of file slicer.cc.

{
    jarc->markverts();
 
    if( jarc->pwlArc->npts >= 2 ) {
    backend.bgnoutline();
    for( int j = jarc->pwlArc->npts-1; j >= 0; j--  )
        backend.linevert( &(jarc->pwlArc->pts[j]) );
    backend.endoutline();
    }
}

Referenced by Subdivider::outline().

outline() [2/2]

void Slicer::outline ( void  )

private

Definition at line 1266 of file slicer.cc.

{
    GridTrimVertex upper, lower;
    Hull::init( );
 
    backend.bgnoutline();
    while( (nextupper( &upper )) ) {
    if( upper.isGridVert() )
        backend.linevert( upper.g );
    else
        backend.linevert( upper.t );
    }
    backend.endoutline();
 
    backend.bgnoutline();
    while( (nextlower( &lower )) ) {
    if( lower.isGridVert() )
        backend.linevert( lower.g );
    else
        backend.linevert( lower.t );
    }
    backend.endoutline();
}

Referenced by slice_old().

set_ulinear()

void Slicer::set_ulinear ( int  ulinear_flag )

inline

Definition at line 63 of file slicer.h.

      {
    ulinear = ulinear_flag;
      }

Referenced by Subdivider::tessellation().

set_vlinear()

void Slicer::set_vlinear ( int  vlinear_flag )

inline

Definition at line 67 of file slicer.h.

      {
    vlinear = vlinear_flag;
      }

Referenced by Subdivider::tessellation().

setisolines()

void Slicer::setisolines

(

int

x

)

Definition at line 1197 of file slicer.cc.

{
    isolines = x;
}

Referenced by Subdivider::render().

setstriptessellation()

void Slicer::setstriptessellation	(	REAL	x,
		REAL	y
	)

Definition at line 1203 of file slicer.cc.

{
    assert(x > 0 && y > 0);
    du = x;
    dv = y;
    setDu( du );
}

Referenced by Subdivider::tessellation().

slice()

void Slicer::slice

(

Arc_ptr

loop

)

Definition at line 1165 of file slicer.cc.

{
#ifdef USE_READ_FLAG
  if(read_flag("flagFile"))
    slice_new(loop);
  else
    slice_old(loop);
 
#else
    slice_new(loop);
#endif
 
}

Referenced by Subdivider::render().

slice_new()

void Slicer::slice_new

(

Arc_ptr

loop

)

Definition at line 1068 of file slicer.cc.

{
//count++;
//if(count == 78) count=1;
//printf("count=%i\n", count);
//if( ! (4<= count && count <=4)) return;
 
 
  Int num_ulines;
  Int num_vlines;
  Real uMin, uMax, vMin, vMax;
  Real mydu, mydv;
  uMin = uMax = loop->tail()[0];
  vMin = vMax = loop->tail()[1];
  mydu = (du>0)? du: -du;
  mydv = (dv>0)? dv: -dv;
 
  for(Arc_ptr jarc=loop->next; jarc != loop; jarc = jarc->next)
   {
 
     if(jarc->tail()[0] < uMin)
       uMin = jarc->tail()[0];
     if(jarc->tail()[0] > uMax)
       uMax = jarc->tail()[0];
     if(jarc->tail()[1] < vMin)
       vMin = jarc->tail()[1];
     if(jarc->tail()[1] > vMax)
       vMax = jarc->tail()[1];
   }
 
  if (uMax == uMin)
    return; // prevent divide-by-zero.  Jon Perry.  17 June 2002
 
  if(mydu > uMax - uMin)
    num_ulines = 2;
  else
    {
      num_ulines = 3 + (Int) ((uMax-uMin)/mydu);
    }
  if(mydv>=vMax-vMin)
    num_vlines = 2;
  else
    {
      num_vlines = 2+(Int)((vMax-vMin)/mydv);
    }
 
  Int isRect = is_rect(loop);
 
  if(isRect && (num_ulines<=2 || num_vlines<=2))
    {
      if(vlinear)
    triangulateRect(loop, backend, 1, ulinear, vlinear);
      else if(ulinear)
    triangulateRect(loop, backend, -1, ulinear, vlinear);   
      else
    triangulateRect(loop, backend, 0, ulinear, vlinear);        
    }
 
   else if(isRect)
    {
      triangulateRectGen(loop, num_ulines-2, num_vlines-2, backend); 
    }
  else if( (num_ulines<=2 || num_vlines <=2) && ulinear)
    {
      monoTriangulationFunBackend(loop, compV2InY, &backend);
    }
  else if( (!ulinear) && (!vlinear) && (num_ulines == 2) && (num_vlines > 2))
    {
      monoTriangulationFunBackend(loop, compV2InY, &backend);
    }
  else 
    {
      directedLine* poly = arcLoopToDLineLoop(loop);
 
      gridWrap grid(num_ulines, num_vlines, uMin, uMax, vMin, vMax);
      primStream pStream(20, 20);
      rectBlockArray rbArray(20);
 
      sampleMonoPoly(poly, &grid, ulinear, vlinear, &pStream, &rbArray);
 
      evalStream(&pStream);
 
      evalRBArray(&rbArray, &grid);
      
#ifdef COUNT_TRIANGLES
      num_triangles += pStream.num_triangles();
      num_quads += rbArray.num_quads();
#endif
      poly->deleteSinglePolygonWithSline();      
    }
  
#ifdef COUNT_TRIANGLES
  printf("num_triangles=%i\n", num_triangles);
  printf("num_quads = %i\n", num_quads);
#endif
}

Referenced by slice().

slice_old()

void Slicer::slice_old

(

Arc_ptr

loop

)

Definition at line 1212 of file slicer.cc.

{
    loop->markverts();
 
    Arc_ptr extrema[4];
    loop->getextrema( extrema );
 
    unsigned int npts = loop->numpts();
    TrimRegion::init( npts, extrema[0] );
 
    Mesher::init( npts );
 
    long ulines = uarray.init( du, extrema[1], extrema[3] );
//printf("ulines = %i\n", ulines);
    Varray varray;
    long vlines = varray.init( dv, extrema[0], extrema[2] );
//printf("vlines = %i\n", vlines);
    long botv = 0;
    long topv;
    TrimRegion::init( varray.varray[botv] );
    getGridExtent( &extrema[0]->pwlArc->pts[0], &extrema[0]->pwlArc->pts[0] );
 
    for( long quad=0; quad<varray.numquads; quad++ ) {
    backend.surfgrid( uarray.uarray[0], 
               uarray.uarray[ulines-1], 
               ulines-1, 
               varray.vval[quad], 
               varray.vval[quad+1], 
               varray.voffset[quad+1] - varray.voffset[quad] );
 
    for( long i=varray.voffset[quad]+1; i <= varray.voffset[quad+1]; i++ ) {
            topv = botv++;
            advance( topv - varray.voffset[quad], 
             botv - varray.voffset[quad], 
             varray.varray[botv] );
        if( i == vlines )
        getPts( extrema[2] );
        else
        getPts( backend );
        getGridExtent();
            if( isolines ) {
            outline();
        } else {
        if( canTile() ) 
            coveAndTile();
        else
            mesh();
        }
        }
   }
}

Referenced by slice().

Member Data Documentation

backend

Backend& Slicer::backend

private

Definition at line 72 of file slicer.h.

Referenced by evalRBArray(), evalStream(), outline(), slice_new(), and slice_old().

du

REAL Slicer::du

private

Definition at line 74 of file slicer.h.

Referenced by setstriptessellation(), slice_new(), slice_old(), and Slicer().

dv

REAL Slicer::dv

private

Definition at line 74 of file slicer.h.

Referenced by setstriptessellation(), slice_new(), slice_old(), and Slicer().

isolines

int Slicer::isolines

private

Definition at line 75 of file slicer.h.

Referenced by setisolines(), slice_old(), and Slicer().

oneOverDu

REAL Slicer::oneOverDu

private

Definition at line 73 of file slicer.h.

Referenced by Slicer().

ulinear

int Slicer::ulinear

private

Definition at line 81 of file slicer.h.

Referenced by set_ulinear(), slice_new(), and Slicer().

vlinear

int Slicer::vlinear

private

Definition at line 82 of file slicer.h.

Referenced by set_vlinear(), slice_new(), and Slicer().

---

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

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