slicer.cc File Reference

#include "slicer.h"
#include "backend.h"
#include "simplemath.h"
#include "varray.h"
#include "polyUtil.h"
#include "monoTriangulation.h"
#include "sampleMonoPoly.h"

Include dependency graph for slicer.cc:

Go to the source code of this file.

Macros
#define	max(a, b)   ((a>b)? a:b)
#define	ZERO   0.00001 /*determing whether a loop is a rectngle or not*/
#define	equalRect(a, b)   ((glu_abs(a-b) <= ZERO)? 1:0)

Functions
int	compInY (REAL a[2], REAL b[2])
void	monoTriangulationLoop (Arc_ptr loop, Backend &backend, primStream *pStream)
static void	triangulateRectGen (Arc_ptr loop, int n_ulines, int n_vlines, Backend &backend)
static Int	is_rect (Arc_ptr loop)
void	OPT_OUTVERT (TrimVertex &vv, Backend &backend)
static void	triangulateRectAux (PwlArc *top, PwlArc *bot, PwlArc *left, PwlArc *right, Backend &backend)
static void	triangulateRect (Arc_ptr loop, Backend &backend, int TB_or_LR, int ulinear, int vlinear)
static void	triangulateRectCenter (int n_ulines, REAL *u_val, int n_vlines, REAL *v_val, Backend &backend)
static void	triangulateRectTopGen (Arc_ptr arc, int n_ulines, REAL *u_val, Real v, int dir, int is_u, Backend &backend)
directedLine *	arcToDLine (Arc_ptr arc)
directedLine *	arcToMultDLines (directedLine *original, Arc_ptr arc)
directedLine *	arcLoopToDLineLoop (Arc_ptr loop)

Macro Definition Documentation

equalRect

#define equalRect	(		a,
			b
	)		((glu_abs(a-b) <= ZERO)? 1:0)

Definition at line 83 of file slicer.cc.

max

#define max	(		a,
			b
	)		((a>b)? a:b)

Definition at line 81 of file slicer.cc.

ZERO

#define ZERO   0.00001 /*determing whether a loop is a rectngle or not*/

Definition at line 82 of file slicer.cc.

Function Documentation

arcLoopToDLineLoop()

directedLine * arcLoopToDLineLoop

(

Arc_ptr

loop

)

Definition at line 948 of file slicer.cc.

{
  directedLine* ret;
 
  if(loop == NULL)
    return NULL;
  ret = arcToMultDLines(NULL, loop);
//ret->printSingle();
  for(Arc_ptr temp = loop->next; temp != loop; temp = temp->next){
    ret = arcToMultDLines(ret, temp);
//ret->printSingle();
  }
 
  return ret;
}

Referenced by bin_to_DLineLoops(), and Slicer::slice_new().

arcToDLine()

directedLine * arcToDLine

(

Arc_ptr

arc

)

Definition at line 890 of file slicer.cc.

{
  int i;
  Real vert[2];
  directedLine* ret;
  sampledLine* sline = new sampledLine(arc->pwlArc->npts);
  for(i=0; i<arc->pwlArc->npts; i++)
    {
      vert[0] = arc->pwlArc->pts[i].param[0];
      vert[1] = arc->pwlArc->pts[i].param[1];
      sline->setPoint(i, vert);
    }
  ret = new directedLine(INCREASING, sline);
  return ret;
}

Referenced by arcToMultDLines().

arcToMultDLines()

directedLine * arcToMultDLines	(	directedLine *	original,
		Arc_ptr	arc
	)

Definition at line 907 of file slicer.cc.

{
  directedLine* ret = original;
  int is_linear = 0;
  if(arc->pwlArc->npts == 2 )
    is_linear = 1;
  else if(area(arc->pwlArc->pts[0].param, arc->pwlArc->pts[1].param, arc->pwlArc->pts[arc->pwlArc->npts-1].param) == 0.0)
    is_linear = 1;
  
  if(is_linear)
    {
      directedLine *dline = arcToDLine(arc);
      if(ret == NULL)
    ret = dline;
      else
    ret->insert(dline);
      return ret;
    }
  else /*not linear*/
    {
      for(Int i=0; i<arc->pwlArc->npts-1; i++)
    {
      Real vert[2][2];
      vert[0][0] = arc->pwlArc->pts[i].param[0];
      vert[0][1] = arc->pwlArc->pts[i].param[1];
      vert[1][0] = arc->pwlArc->pts[i+1].param[0];
      vert[1][1] = arc->pwlArc->pts[i+1].param[1];
      
      sampledLine *sline = new sampledLine(2, vert);
      directedLine *dline = new directedLine(INCREASING, sline);
      if(ret == NULL)
        ret = dline;
      else
        ret->insert(dline);
    }
      return ret;
    }
}

Referenced by arcLoopToDLineLoop().

compInY()

int compInY ( REAL  a[2], REAL  b[2]  )

inline

Definition at line 132 of file slicer.cc.

{
  if(a[1] < b[1])
    return -1;
  else if (a[1] > b[1])
    return 1;
  else if(a[0] > b[0])
    return 1;
  else return -1;
}

Referenced by monoTriangulationLoop().

is_rect()

static Int is_rect ( Arc_ptr  loop )

static

Definition at line 220 of file slicer.cc.

{
  Int nlines =1;
  for(Arc_ptr jarc = loop->next; jarc != loop; jarc = jarc->next)
    {
      nlines++;
      if(nlines == 5)
    break;
    }
  if(nlines != 4)
    return 0;
 
 
/*
printf("here1\n");
printf("loop->tail=(%f,%f)\n", loop->tail()[0], loop->tail()[1]);
printf("loop->head=(%f,%f)\n", loop->head()[0], loop->head()[1]);
printf("loop->next->tail=(%f,%f)\n", loop->next->tail()[0], loop->next->tail()[1]);
printf("loop->next->head=(%f,%f)\n", loop->next->head()[0], loop->next->head()[1]);
if(fglu_abs(loop->tail()[0] - loop->head()[0])<0.000001)
    printf("equal 1\n");
if(loop->next->tail()[1] == loop->next->head()[1])
    printf("equal 2\n");
*/
 
  if( (glu_abs(loop->tail()[0] - loop->head()[0])<=ZERO) && 
      (glu_abs(loop->next->tail()[1] - loop->next->head()[1])<=ZERO) &&
      (glu_abs(loop->prev->tail()[1] - loop->prev->head()[1])<=ZERO) &&
      (glu_abs(loop->prev->prev->tail()[0] - loop->prev->prev->head()[0])<=ZERO)
     )
    return 1;
  else if
    ( (glu_abs(loop->tail()[1] - loop->head()[1]) <= ZERO) && 
      (glu_abs(loop->next->tail()[0] - loop->next->head()[0]) <= ZERO) &&
      (glu_abs(loop->prev->tail()[0] - loop->prev->head()[0]) <= ZERO) &&
      (glu_abs(loop->prev->prev->tail()[1] - loop->prev->prev->head()[1]) <= ZERO)
     )
      return 1;
  else
    return 0;
}

Referenced by Slicer::slice_new().

monoTriangulationLoop()

void monoTriangulationLoop	(	Arc_ptr	loop,
		Backend &	backend,
		primStream *	pStream
	)

Definition at line 143 of file slicer.cc.

{
  int i;
  //find the top, bottom, increasing and decreasing chain
  //then call monoTrianulation
  Arc_ptr jarc, temp;
  Arc_ptr top;
  Arc_ptr bot;
  top = bot = loop;
  if(compInY(loop->tail(), loop->prev->tail()) < 0)
    {
      //first find bot
      for(temp = loop->next; temp != loop; temp = temp->next)
    {
      if(compInY(temp->tail(), temp->prev->tail()) > 0)
        break;
    }
      bot = temp->prev;
      //then find top
      for(temp=loop->prev; temp != loop; temp = temp->prev)
    {
      if(compInY(temp->tail(), temp->prev->tail()) > 0)
        break;
    }
      top = temp;
    }
  else //loop > loop->prev
    {
      for(temp=loop->next; temp != loop; temp = temp->next)
    {
      if(compInY(temp->tail(), temp->prev->tail()) < 0)
        break;
    }
      top = temp->prev;
      for(temp=loop->prev; temp != loop; temp = temp->prev)
    {
      if(compInY(temp->tail(), temp->prev->tail()) < 0)
        break;
    }
      bot = temp;
    }
  //creat increase and decrease chains
  vertexArray inc_chain(50); //this is a dynamci array
  for(i=1; i<=top->pwlArc->npts-2; i++) 
    {
      //the first vertex is the top which doesn't below to inc_chain
      inc_chain.appendVertex(top->pwlArc->pts[i].param);
    }
  for(jarc=top->next; jarc != bot; jarc = jarc->next)
    {
      for(i=0; i<=jarc->pwlArc->npts-2; i++)
    {
      inc_chain.appendVertex(jarc->pwlArc->pts[i].param);
    }
      
    }
  vertexArray dec_chain(50);
  for(jarc = top->prev; jarc != bot; jarc = jarc->prev)
    {
      for(i=jarc->pwlArc->npts-2; i>=0; i--)
    {
      dec_chain.appendVertex(jarc->pwlArc->pts[i].param);
    }
    }
  for(i=bot->pwlArc->npts-2; i>=1; i--)
    {
      dec_chain.appendVertex(jarc->pwlArc->pts[i].param);
    }     
 
  monoTriangulationRec(top->tail(), bot->tail(), &inc_chain, 0,
               &dec_chain, 0, &backend);
 
}

OPT_OUTVERT()

void OPT_OUTVERT ( TrimVertex &  vv, Backend &  backend  )

inline

Definition at line 303 of file slicer.cc.

{
 
#ifdef USE_OPTTT
  glNormal3fv(vv.cache_normal);                         
  glVertex3fv(vv.cache_point);
#else
 
  backend.tmeshvert(&vv);
 
#endif
 
}

Referenced by triangulateRectAux().

triangulateRect()

static void triangulateRect ( Arc_ptr  loop, Backend &  backend, int  TB_or_LR, int  ulinear, int  vlinear  )

static

Definition at line 319 of file slicer.cc.

{
  //we know the loop is a rectangle, but not sure which is top
  Arc_ptr top, bot, left, right;
  if(loop->tail()[1] == loop->head()[1])
    {
      if(loop->tail()[1] > loop->prev->prev->tail()[1])
    {
 
    top = loop;
    }
      else{
 
    top = loop->prev->prev;
    }
    }
  else 
    {
      if(loop->tail()[0] > loop->prev->prev->tail()[0])
    {
      //loop is the right arc
 
      top = loop->next;
    }
      else
    {
 
      top = loop->prev;
    }
    }
  left = top->next;
  bot  = left->next;
  right= bot->next;
 
  //if u, v are both nonlinear, then if the
  //boundary is tessellated dense, we also
  //sample the inside to get a better tesslletant.
  if( (!ulinear) && (!vlinear))
    {
      int nu = top->pwlArc->npts;
      if(nu < bot->pwlArc->npts)
    nu = bot->pwlArc->npts;
      int nv = left->pwlArc->npts;
      if(nv < right->pwlArc->npts)
    nv = right->pwlArc->npts;
/*
      if(nu > 2 && nv > 2)
    {
      triangulateRectGen(top, nu-2,  nv-2, backend);
      return;
    }
*/
    }
 
  if(TB_or_LR == 1)
    triangulateRectAux(top->pwlArc, bot->pwlArc, left->pwlArc, right->pwlArc, backend);
  else if(TB_or_LR == -1)
    triangulateRectAux(left->pwlArc, right->pwlArc, bot->pwlArc, top->pwlArc, backend);    
  else
    {
      Int maxPointsTB = top->pwlArc->npts + bot->pwlArc->npts;
      Int maxPointsLR = left->pwlArc->npts + right->pwlArc->npts;
      
      if(maxPointsTB < maxPointsLR)
    triangulateRectAux(left->pwlArc, right->pwlArc, bot->pwlArc, top->pwlArc, backend);    
      else
    triangulateRectAux(top->pwlArc, bot->pwlArc, left->pwlArc, right->pwlArc, backend);
    }
}

Referenced by Slicer::slice_new().

triangulateRectAux()

static void triangulateRectAux ( PwlArc *  top, PwlArc *  bot, PwlArc *  left, PwlArc *  right, Backend &  backend  )

static

Definition at line 389 of file slicer.cc.

{ //if(maxPointsTB >= maxPointsLR)
    {
 
      Int d, topd_left, topd_right, botd_left, botd_right, i,j;
      d = left->npts /2;
 
#ifdef USE_OPTTT
      evalLineNOGE(top->pts, top->npts, backend);
      evalLineNOGE(bot->pts, bot->npts, backend);
      evalLineNOGE(left->pts, left->npts, backend);
      evalLineNOGE(right->pts, right->npts, backend);
#endif
 
      if(top->npts == 2) {
    backend.bgntfan();
    OPT_OUTVERT(top->pts[0], backend);//the root
    for(i=0; i<left->npts; i++){
      OPT_OUTVERT(left->pts[i], backend);
    }
    for(i=1; i<= bot->npts-2; i++){
      OPT_OUTVERT(bot->pts[i], backend);
    }
    backend.endtfan();
    
    backend.bgntfan();
    OPT_OUTVERT(bot->pts[bot->npts-2], backend);
    for(i=0; i<right->npts; i++){
      OPT_OUTVERT(right->pts[i], backend);
    }
    backend.endtfan();
      }
      else if(bot->npts == 2) {
    backend.bgntfan();
    OPT_OUTVERT(bot->pts[0], backend);//the root
    for(i=0; i<right->npts; i++){
      OPT_OUTVERT(right->pts[i], backend);
    }
    for(i=1; i<= top->npts-2; i++){
      OPT_OUTVERT(top->pts[i], backend);
    }
    backend.endtfan();
    
    backend.bgntfan();
    OPT_OUTVERT(top->pts[top->npts-2], backend);
    for(i=0; i<left->npts; i++){
      OPT_OUTVERT(left->pts[i], backend);
    }
    backend.endtfan();
      }
      else { //both top and bot have >=3 points
    
    backend.bgntfan();
    
    OPT_OUTVERT(top->pts[top->npts-2], backend);
    
    for(i=0; i<=d; i++)
      {
        OPT_OUTVERT(left->pts[i], backend);   
      }
    backend.endtfan();
    
    backend.bgntfan();
    
    OPT_OUTVERT(bot->pts[1], backend);
    
    OPT_OUTVERT(top->pts[top->npts-2], backend);
    
    for(i=d; i< left->npts; i++)
      {      
        OPT_OUTVERT(left->pts[i], backend);      
      }
    backend.endtfan();
 
    d = right->npts/2;
    //output only when d<right->npts-1 and
    //
    if(d<right->npts-1)
      { 
        backend.bgntfan();
        //      backend.tmeshvert(& top->pts[1]);
        OPT_OUTVERT(top->pts[1], backend);
        for(i=d; i< right->npts; i++)
          {
        //    backend.tmeshvert(& right->pts[i]);
        
        OPT_OUTVERT(right->pts[i], backend);
        
          }
        backend.endtfan();
      }
    
    backend.bgntfan();
    //      backend.tmeshvert(& bot->pts[bot->npts-2]);
    OPT_OUTVERT( bot->pts[bot->npts-2], backend);
    for(i=0; i<=d; i++)
      {
        //    backend.tmeshvert(& right->pts[i]);
        OPT_OUTVERT(right->pts[i], backend);
        
      }
    
    //      backend.tmeshvert(& top->pts[1]);
    OPT_OUTVERT(top->pts[1], backend);      
    
    backend.endtfan();
 
 
    topd_left = top->npts-2;
    topd_right = 1; //topd_left>= topd_right
 
    botd_left = 1;
    botd_right = bot->npts-2; //botd_left<= bot_dright
 
    
    if(top->npts < bot->npts)
      {
        int delta=bot->npts - top->npts;
        int u = delta/2;
        botd_left = 1+ u;
        botd_right = bot->npts-2-( delta-u);        
    
        if(botd_left >1)
          {
        backend.bgntfan();
        //    backend.tmeshvert(& top->pts[top->npts-2]);
        OPT_OUTVERT(top->pts[top->npts-2], backend);
        for(i=1; i<= botd_left; i++)
          {
            //        backend.tmeshvert(& bot->pts[i]);
            OPT_OUTVERT(bot->pts[i] , backend);
          }
        backend.endtfan();
          }
        if(botd_right < bot->npts-2)
          {
        backend.bgntfan();
        OPT_OUTVERT(top->pts[1], backend);
        for(i=botd_right; i<= bot->npts-2; i++)
          OPT_OUTVERT(bot->pts[i], backend);
        backend.endtfan();
          }
      }
    else if(top->npts> bot->npts)
      {
        int delta=top->npts-bot->npts;
        int u = delta/2;
        topd_left = top->npts-2 - u;
        topd_right = 1+delta-u;
        
        if(topd_left < top->npts-2)
          {
        backend.bgntfan();
        //    backend.tmeshvert(& bot->pts[1]);
        OPT_OUTVERT(bot->pts[1], backend);
        for(i=topd_left; i<= top->npts-2; i++)
          {
            //        backend.tmeshvert(& top->pts[i]);
            OPT_OUTVERT(top->pts[i], backend);
          }
        backend.endtfan();
          }
        if(topd_right > 1)
          {
        backend.bgntfan();
        OPT_OUTVERT(bot->pts[bot->npts-2], backend);
        for(i=1; i<= topd_right; i++)
          OPT_OUTVERT(top->pts[i], backend);
        backend.endtfan();
          }
      }
    
    if(topd_left <= topd_right) 
      return;
 
    backend.bgnqstrip();
    for(j=botd_left, i=topd_left; i>=topd_right; i--,j++)
      {
        //    backend.tmeshvert(& top->pts[i]);
        //    backend.tmeshvert(& bot->pts[j]);
        OPT_OUTVERT(top->pts[i], backend);
        OPT_OUTVERT(bot->pts[j], backend);
      }
    backend.endqstrip();
    
      }
    }
}

Referenced by triangulateRect().

triangulateRectCenter()

static void triangulateRectCenter ( int  n_ulines, REAL *  u_val, int  n_vlines, REAL *  v_val, Backend &  backend  )

static

Definition at line 579 of file slicer.cc.

{
 
  // XXX this code was patched by Diego Santa Cruz <Diego.SantaCruz@epfl.ch>
  // to fix a problem in which glMapGrid2f() was called with bad parameters.
  // This has beens submitted to SGI but not integrated as of May 1, 2001.
  if(n_ulines>1 && n_vlines>1) {
    backend.surfgrid(u_val[0], u_val[n_ulines-1], n_ulines-1, 
                     v_val[n_vlines-1], v_val[0], n_vlines-1);
    backend.surfmesh(0,0,n_ulines-1,n_vlines-1);
  }
 
  return;
 
  /*
  for(i=0; i<n_vlines-1; i++)
    {
 
      backend.bgnqstrip();
      for(j=0; j<n_ulines; j++)
    {
      trimVert.param[0] = u_val[j];
      trimVert.param[1] = v_val[i+1];
      backend.tmeshvert(& trimVert);      
 
      trimVert.param[1] = v_val[i];
      backend.tmeshvert(& trimVert);      
    }
      backend.endqstrip();
 
    }
    */
}

Referenced by triangulateRectGen().

triangulateRectGen()

static void triangulateRectGen ( Arc_ptr  loop, int  n_ulines, int  n_vlines, Backend &  backend  )

static

Definition at line 778 of file slicer.cc.

{
 
  int i;
  //we know the loop is a rectangle, but not sure which is top
  Arc_ptr top, bot, left, right;
 
  if(equalRect(loop->tail()[1] ,  loop->head()[1]))
    {
 
      if(loop->tail()[1] > loop->prev->prev->tail()[1])
    {
 
    top = loop;
    }
      else{
 
    top = loop->prev->prev;
    }
    }
  else 
    {
      if(loop->tail()[0] > loop->prev->prev->tail()[0])
    {
      //loop is the right arc
 
      top = loop->next;
    }
      else
    {
 
      top = loop->prev;
    }
    }
 
  left = top->next;
  bot  = left->next;
  right= bot->next;
 
#ifdef COUNT_TRIANGLES
  num_triangles += loop->pwlArc->npts + 
                 left->pwlArc->npts + 
                 bot->pwlArc->npts + 
          right->pwlArc->npts 
              + 2*n_ulines + 2*n_vlines 
            -8;
  num_quads += (n_ulines-1)*(n_vlines-1);
#endif
/*
  backend.surfgrid(left->tail()[0], right->tail()[0], n_ulines+1, 
           top->tail()[1], bot->tail()[1], n_vlines+1);
//  if(n_ulines>1 && n_vlines>1)
    backend.surfmesh(0,0,n_ulines+1,n_vlines+1);
return;
*/
  REAL* u_val=(REAL*) malloc(sizeof(REAL)*n_ulines);
  assert(u_val);
  REAL* v_val=(REAL*)malloc(sizeof(REAL) * n_vlines);
  assert(v_val);
  REAL u_stepsize = (right->tail()[0] - left->tail()[0])/( (REAL) n_ulines+1);
  REAL v_stepsize = (top->tail()[1] - bot->tail()[1])/( (REAL) n_vlines+1);
  Real temp=left->tail()[0]+u_stepsize;
  for(i=0; i<n_ulines; i++)
    {
      u_val[i] = temp;
      temp += u_stepsize;
    }
  temp = bot->tail()[1] + v_stepsize;
  for(i=0; i<n_vlines; i++)
    {
      v_val[i] = temp;
      temp += v_stepsize;
    }
 
  triangulateRectTopGen(top, n_ulines, u_val, v_val[n_vlines-1], 1,1, backend);
  triangulateRectTopGen(bot, n_ulines, u_val, v_val[0], 0, 1, backend);
  triangulateRectTopGen(left, n_vlines, v_val, u_val[0], 1, 0, backend);
  triangulateRectTopGen(right, n_vlines, v_val, u_val[n_ulines-1], 0,0, backend);
 
 
 
 
  //triangulate the center
  triangulateRectCenter(n_ulines, u_val, n_vlines, v_val, backend);
 
  free(u_val);
  free(v_val);
  
}

Referenced by Slicer::slice_new().

triangulateRectTopGen()

static void triangulateRectTopGen ( Arc_ptr  arc, int  n_ulines, REAL *  u_val, Real  v, int  dir, int  is_u, Backend &  backend  )

static

Definition at line 616 of file slicer.cc.

{
 
  if(is_u)
    {
      int i,k;
      REAL* upper_val = (REAL*) malloc(sizeof(REAL) * arc->pwlArc->npts);
      assert(upper_val);
      if(dir)
    {
      for(k=0,i=arc->pwlArc->npts-1; i>=0; i--,k++)
        {
          upper_val[k] = arc->pwlArc->pts[i].param[0];
        }   
      backend.evalUStrip(arc->pwlArc->npts, arc->pwlArc->pts[0].param[1],
                 upper_val,
                 n_ulines, v, u_val);
    }
      else
    {
      for(k=0,i=0;  i<arc->pwlArc->npts; i++,k++)
        {
          upper_val[k] = arc->pwlArc->pts[i].param[0];
 
        }         
 
      backend.evalUStrip(
                 n_ulines, v, u_val,
                 arc->pwlArc->npts, arc->pwlArc->pts[0].param[1], upper_val
                 );  
    }
 
      free(upper_val);
      return;
    }
  else //is_v
    {
      int i,k;
      REAL* left_val = (REAL*) malloc(sizeof(REAL) * arc->pwlArc->npts);
      assert(left_val);   
      if(dir)
    {
      for(k=0,i=arc->pwlArc->npts-1; i>=0; i--,k++)
        {
          left_val[k] = arc->pwlArc->pts[i].param[1];
        }
      backend.evalVStrip(arc->pwlArc->npts, arc->pwlArc->pts[0].param[0],
                 left_val,
                 n_ulines, v, u_val);
    }
      else 
    {
      for(k=0,i=0;  i<arc->pwlArc->npts; i++,k++)
        {
          left_val[k] = arc->pwlArc->pts[i].param[1];
        }
       backend.evalVStrip(
                 n_ulines, v, u_val,
                 arc->pwlArc->npts, arc->pwlArc->pts[0].param[0], left_val
                 ); 
    }
      free(left_val);
      return;
    }
    
  //the following is a different version of the above code. If you comment
  //the above code, the following code will still work. The reason to leave
  //the folliwng code here is purely for testing purpose.
  /*
  int i,j;
  PwlArc* parc = arc->pwlArc;
  int d1 = parc->npts-1;
  int d2 = 0;
  TrimVertex trimVert;
  trimVert.nuid = 0;//????
  REAL* temp_u_val = u_val;
  if(dir ==0) //have to reverse u_val
    {
      temp_u_val = (REAL*) malloc(sizeof(REAL) * n_ulines);
      assert(temp_u_val);
      for(i=0; i<n_ulines; i++)
    temp_u_val[i] = u_val[n_ulines-1-i];
    }
  u_val = temp_u_val;
 
  if(parc->npts > n_ulines)
    {
      d1 = n_ulines-1;
 
      backend.bgntfan();
      if(is_u){
    trimVert.param[0] = u_val[0];
    trimVert.param[1] = v;
      }
      else
    {
    trimVert.param[1] = u_val[0];
    trimVert.param[0] = v;
      }
      
      backend.tmeshvert(& trimVert);
      for(i=d1; i< parc->npts; i++)
    backend.tmeshvert(& parc->pts[i]);
      backend.endtfan();
 
 
    }
  else if(parc->npts < n_ulines)
    {
      d2 = n_ulines-parc->npts;
 
 
      backend.bgntfan();
      backend.tmeshvert(& parc->pts[parc->npts-1]);
      for(i=0; i<= d2; i++)
    {
      if(is_u){
        trimVert.param[0] = u_val[i];
        trimVert.param[1] = v;
      }
      else
        {
          trimVert.param[1] = u_val[i];
          trimVert.param[0] = v;
        }
      backend.tmeshvert(&trimVert);
    }
      backend.endtfan();
 
    }
  if(d1>0){
 
 
    backend.bgnqstrip();
    for(i=d1, j=d2; i>=0; i--, j++)
      {
    backend.tmeshvert(& parc->pts[i]);
 
    if(is_u){
      trimVert.param[0] = u_val[j];
      trimVert.param[1] = v;
    }
    else{
      trimVert.param[1] = u_val[j];
      trimVert.param[0] = v;
    }
    backend.tmeshvert(&trimVert);
 
 
    
      }
    backend.endqstrip();
 
 
  }
  if(dir == 0)  //temp_u_val was mallocated
    free(temp_u_val);
 */
}

Referenced by triangulateRectGen().