sampleMonoPoly.cc

Go to the documentation of this file.

/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
** 
** http://oss.sgi.com/projects/FreeB
** 
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
** 
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
** 
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
*/
/*
*/
 
#include "gluos.h"
//#include <stdlib.h>
//#include <stdio.h>
#include <math.h>
 
#ifndef max
#define max(a,b) ((a>b)? a:b)
#endif
#ifndef min
#define min(a,b) ((a>b)? b:a)
#endif
 
#include <GL/gl.h>
 
#include "glimports.h"
#include "zlassert.h"
#include "sampleMonoPoly.h"
#include "sampleComp.h"
#include "polyDBG.h"
#include "partitionX.h"
 
 
#define ZERO 0.00001
 
//#define  MYDEBUG
 
//#define SHORTEN_GRID_LINE
//see work/newtess/internal/test/problems
 
 
/*split a polygon so that each vertex correcpond to one edge
 *the head of the first edge of the returned plygon must be the head of the first
 *edge of the origianl polygon. This is crucial for the code in sampleMonoPoly function
 */
 directedLine*  polygonConvert(directedLine* polygon)
{
  int i;
  directedLine* ret;
  sampledLine* sline;
  sline = new sampledLine(2);
  sline->setPoint(0, polygon->getVertex(0));
  sline->setPoint(1, polygon->getVertex(1));
  ret=new directedLine(INCREASING, sline);
  for(i=1; i<= polygon->get_npoints()-2; i++)
    {
      sline = new sampledLine(2);
      sline->setPoint(0, polygon->getVertex(i));
      sline->setPoint(1, polygon->getVertex(i+1));
      ret->insert(new directedLine(INCREASING, sline));
    }
 
  for(directedLine *temp = polygon->getNext(); temp != polygon; temp = temp->getNext())
    {
      for(i=0; i<= temp->get_npoints()-2; i++)
    {
      sline = new sampledLine(2);
      sline->setPoint(0, temp->getVertex(i));
      sline->setPoint(1, temp->getVertex(i+1));
      ret->insert(new directedLine(INCREASING, sline));
    }
    }
  return ret;
}
 
void triangulateConvexPolyVertical(directedLine* topV, directedLine* botV, primStream *pStream)
{
  Int i,j;
  Int n_leftVerts;
  Int n_rightVerts;
  Real** leftVerts;
  Real** rightVerts;
  directedLine* tempV;
  n_leftVerts = 0;
  for(tempV = topV; tempV != botV; tempV = tempV->getNext())
    {
      n_leftVerts += tempV->get_npoints();
    }
  n_rightVerts=0;
  for(tempV = botV; tempV != topV; tempV = tempV->getNext())
    {
      n_rightVerts += tempV->get_npoints();
    }
 
  Real2* temp_leftVerts = (Real2 *) malloc(sizeof(Real2) * n_leftVerts);
  assert(temp_leftVerts);
  Real2* temp_rightVerts = (Real2 *) malloc(sizeof(Real2) * n_rightVerts);
  assert(temp_rightVerts);
 
  leftVerts = (Real**) malloc(sizeof(Real2*) * n_leftVerts);
  assert(leftVerts);
  rightVerts = (Real**) malloc(sizeof(Real2*) * n_rightVerts);
  assert(rightVerts);
  for(i=0; i<n_leftVerts; i++)
    leftVerts[i] = temp_leftVerts[i];
  for(i=0; i<n_rightVerts; i++)
    rightVerts[i] = temp_rightVerts[i];
 
  i=0;
  for(tempV = topV; tempV != botV; tempV = tempV->getNext())
    {
      for(j=1; j<tempV->get_npoints(); j++)
    {
      leftVerts[i][0] = tempV->getVertex(j)[0];
      leftVerts[i][1] = tempV->getVertex(j)[1];
      i++;
    }
    }
  n_leftVerts = i;
  i=0;
  for(tempV = topV->getPrev(); tempV != botV->getPrev(); tempV = tempV->getPrev())
    {
      for(j=tempV->get_npoints()-1; j>=1; j--)
    {
      rightVerts[i][0] = tempV->getVertex(j)[0];
      rightVerts[i][1] = tempV->getVertex(j)[1];
      i++;
    }
    }
  n_rightVerts = i;
  triangulateXYMonoTB(n_leftVerts, leftVerts, n_rightVerts, rightVerts, pStream);
  free(leftVerts);
  free(rightVerts);
  free(temp_leftVerts);
  free(temp_rightVerts);
}  
 
void triangulateConvexPolyHoriz(directedLine* leftV, directedLine* rightV, primStream *pStream)
{
  Int i,j;
  Int n_lowerVerts;
  Int n_upperVerts;
  Real2 *lowerVerts;
  Real2 *upperVerts;
  directedLine* tempV;
  n_lowerVerts=0;
  for(tempV = leftV; tempV != rightV; tempV = tempV->getNext())
    {
      n_lowerVerts += tempV->get_npoints();
    }
  n_upperVerts=0;
  for(tempV = rightV; tempV != leftV; tempV = tempV->getNext())
    {
      n_upperVerts += tempV->get_npoints();
    }
  lowerVerts = (Real2 *) malloc(sizeof(Real2) * n_lowerVerts);
  assert(n_lowerVerts);
  upperVerts = (Real2 *) malloc(sizeof(Real2) * n_upperVerts);
  assert(n_upperVerts);
  i=0;
  for(tempV = leftV; tempV != rightV; tempV = tempV->getNext())
    {
      for(j=0; j<tempV->get_npoints(); j++)
    {
      lowerVerts[i][0] = tempV->getVertex(j)[0];
      lowerVerts[i][1] = tempV->getVertex(j)[1];
      i++;
    }
    }
  i=0;
  for(tempV = leftV->getPrev(); tempV != rightV->getPrev(); tempV = tempV->getPrev())
    {
      for(j=tempV->get_npoints()-1; j>=0; j--)
    {
      upperVerts[i][0] = tempV->getVertex(j)[0];
      upperVerts[i][1] = tempV->getVertex(j)[1];
      i++;
    }
    }
  triangulateXYMono(n_upperVerts, upperVerts, n_lowerVerts, lowerVerts, pStream);
  free(lowerVerts);
  free(upperVerts);
}  
void triangulateConvexPoly(directedLine* polygon, Int ulinear, Int vlinear, primStream* pStream)
{
  /*find left, right, top , bot
    */
  directedLine* tempV;
  directedLine* topV;
  directedLine* botV;
  directedLine* leftV;
  directedLine* rightV;
  topV = botV = polygon;
 
  for(tempV = polygon->getNext(); tempV != polygon; tempV = tempV->getNext())
    {
      if(compV2InY(topV->head(), tempV->head())<0) {
 
    topV = tempV;
      }
      if(compV2InY(botV->head(), tempV->head())>0) {
 
    botV = tempV;
      }
    }
  //find leftV
  for(tempV = topV; tempV != botV; tempV = tempV->getNext())
    {
      if(tempV->tail()[0] >= tempV->head()[0])
    break;
    }
  leftV = tempV;
  //find rightV
  for(tempV = botV; tempV != topV; tempV = tempV->getNext())
    {
      if(tempV->tail()[0] <= tempV->head()[0])
    break;
    }
  rightV = tempV;
  if(vlinear)
    {
      triangulateConvexPolyHoriz( leftV, rightV, pStream);
    }
  else if(ulinear)
    {
      triangulateConvexPolyVertical(topV, botV, pStream);
    }
  else
    {
      if(DBG_is_U_direction(polygon))
    {
      triangulateConvexPolyHoriz( leftV, rightV, pStream);
    }
      else
    triangulateConvexPolyVertical(topV, botV, pStream);
    }
}         
 
/*for debug purpose*/
void drawCorners(
         Real* topV, Real* botV,         
         vertexArray* leftChain,
         vertexArray* rightChain,
         gridBoundaryChain* leftGridChain,
         gridBoundaryChain* rightGridChain,
         Int gridIndex1,
         Int gridIndex2,
         Int leftCornerWhere,
         Int leftCornerIndex,
         Int rightCornerWhere,
         Int rightCornerIndex,
         Int bot_leftCornerWhere,
         Int bot_leftCornerIndex,
         Int bot_rightCornerWhere,
         Int bot_rightCornerIndex)
{
  Real* leftCornerV;
  Real* rightCornerV;
  Real* bot_leftCornerV;
  Real* bot_rightCornerV;
 
  if(leftCornerWhere == 1)
    leftCornerV = topV;
  else if(leftCornerWhere == 0)
    leftCornerV = leftChain->getVertex(leftCornerIndex);
  else
    leftCornerV = rightChain->getVertex(leftCornerIndex);
 
  if(rightCornerWhere == 1)
    rightCornerV = topV;
  else if(rightCornerWhere == 0)
    rightCornerV = leftChain->getVertex(rightCornerIndex);
  else
    rightCornerV = rightChain->getVertex(rightCornerIndex);
 
  if(bot_leftCornerWhere == 1)
    bot_leftCornerV = botV;
  else if(bot_leftCornerWhere == 0)
    bot_leftCornerV = leftChain->getVertex(bot_leftCornerIndex);
  else
    bot_leftCornerV = rightChain->getVertex(bot_leftCornerIndex);
 
  if(bot_rightCornerWhere == 1)
    bot_rightCornerV = botV;
  else if(bot_rightCornerWhere == 0)
    bot_rightCornerV = leftChain->getVertex(bot_rightCornerIndex);
  else
    bot_rightCornerV = rightChain->getVertex(bot_rightCornerIndex);
 
  Real topGridV = leftGridChain->get_v_value(gridIndex1);
  Real topGridU1 = leftGridChain->get_u_value(gridIndex1);
  Real topGridU2 = rightGridChain->get_u_value(gridIndex1);
  Real botGridV = leftGridChain->get_v_value(gridIndex2);
  Real botGridU1 = leftGridChain->get_u_value(gridIndex2);
  Real botGridU2 = rightGridChain->get_u_value(gridIndex2);
  
  glBegin(GL_LINE_STRIP);
  glVertex2fv(leftCornerV);
  glVertex2f(topGridU1, topGridV);
  glEnd();
 
  glBegin(GL_LINE_STRIP);
  glVertex2fv(rightCornerV);
  glVertex2f(topGridU2, topGridV);
  glEnd();
 
  glBegin(GL_LINE_STRIP);
  glVertex2fv(bot_leftCornerV);
  glVertex2f(botGridU1, botGridV);
  glEnd();
 
  glBegin(GL_LINE_STRIP);
  glVertex2fv(bot_rightCornerV);
  glVertex2f(botGridU2, botGridV);
  glEnd();
 
 
}
         
void toVertexArrays(directedLine* topV, directedLine* botV, vertexArray& leftChain, vertexArray& rightChain)
{  
  Int i;
  directedLine* tempV;
  for(i=1; i<=topV->get_npoints()-2; i++) { /*the first vertex is the top vertex which doesn't belong to inc_chain*/
    leftChain.appendVertex(topV->getVertex(i));
  }
  for(tempV = topV->getNext(); tempV != botV; tempV = tempV->getNext())
    {
      for(i=0; i<=tempV->get_npoints()-2; i++){
    leftChain.appendVertex(tempV->getVertex(i));
      }
    }  
 
  for(tempV = topV->getPrev(); tempV != botV; tempV = tempV->getPrev())
    {
      for(i=tempV->get_npoints()-2; i>=0; i--){
    rightChain.appendVertex(tempV->getVertex(i));
      }
    }
  for(i=botV->get_npoints()-2; i>=1; i--){ 
    rightChain.appendVertex(tempV->getVertex(i));
  }
}
 
 
void findTopAndBot(directedLine* polygon, directedLine*& topV, directedLine*& botV)
{
  assert(polygon);
  directedLine* tempV;
  topV = botV = polygon;
   for(tempV = polygon->getNext(); tempV != polygon; tempV = tempV->getNext())
    {
      if(compV2InY(topV->head(), tempV->head())<0) {
    topV = tempV;
      }
      if(compV2InY(botV->head(), tempV->head())>0) {
    botV = tempV;
      }
    }
}
   
void findGridChains(directedLine* topV, directedLine* botV, 
            gridWrap* grid,
            gridBoundaryChain*& leftGridChain,
            gridBoundaryChain*& rightGridChain)
{
  /*find the first(top) and the last (bottom) grid line which intersect the
   *this polygon
   */
  Int firstGridIndex; /*the index in the grid*/
  Int lastGridIndex;
 
  firstGridIndex = (Int) ((topV->head()[1] - grid->get_v_min()) / (grid->get_v_max() - grid->get_v_min()) * (grid->get_n_vlines()-1));
 
  if(botV->head()[1] < grid->get_v_min())
    lastGridIndex = 0;
  else
    lastGridIndex  = (Int) ((botV->head()[1] - grid->get_v_min()) / (grid->get_v_max() - grid->get_v_min()) * (grid->get_n_vlines()-1)) + 1;
 
  /*find the interval inside  the polygon for each gridline*/
  Int *leftGridIndices = (Int*) malloc(sizeof(Int) * (firstGridIndex - lastGridIndex +1));
  assert(leftGridIndices);
  Int *rightGridIndices = (Int*) malloc(sizeof(Int) * (firstGridIndex - lastGridIndex +1));
  assert(rightGridIndices);
  Int *leftGridInnerIndices = (Int*) malloc(sizeof(Int) * (firstGridIndex - lastGridIndex +1));
  assert(leftGridInnerIndices);
  Int *rightGridInnerIndices = (Int*) malloc(sizeof(Int) * (firstGridIndex - lastGridIndex +1));
  assert(rightGridInnerIndices);
 
  findLeftGridIndices(topV, firstGridIndex, lastGridIndex, grid,  leftGridIndices, leftGridInnerIndices);
 
  findRightGridIndices(topV, firstGridIndex, lastGridIndex, grid,  rightGridIndices, rightGridInnerIndices);
 
  leftGridChain =  new gridBoundaryChain(grid, firstGridIndex, firstGridIndex-lastGridIndex+1, leftGridIndices, leftGridInnerIndices);
 
  rightGridChain = new gridBoundaryChain(grid, firstGridIndex, firstGridIndex-lastGridIndex+1, rightGridIndices, rightGridInnerIndices);
 
  free(leftGridIndices);
  free(rightGridIndices);
  free(leftGridInnerIndices);
  free(rightGridInnerIndices);
}
 
void findDownCorners(Real *botVertex, 
           vertexArray *leftChain, Int leftChainStartIndex, Int leftChainEndIndex,
           vertexArray *rightChain, Int rightChainStartIndex, Int rightChainEndIndex,
           Real v,
           Real uleft,
           Real uright,
           Int& ret_leftCornerWhere, /*0: left chain, 1: topvertex, 2: rightchain*/
           Int& ret_leftCornerIndex, /*useful when ret_leftCornerWhere == 0 or 2*/
           Int& ret_rightCornerWhere, /*0: left chain, 1: topvertex, 2: rightchain*/
           Int& ret_rightCornerIndex /*useful when ret_leftCornerWhere == 0 or 2*/
           )
{
#ifdef MYDEBUG
printf("*************enter find donw corner\n");
printf("finddownCorner: v=%f, uleft=%f, uright=%f\n", v, uleft, uright);
printf("(%i,%i,%i,%i)\n", leftChainStartIndex, leftChainEndIndex,rightChainStartIndex, rightChainEndIndex); 
printf("left chain is\n");
leftChain->print();
printf("right chain is\n");
rightChain->print();
#endif
 
  assert(v > botVertex[1]);
  Real leftGridPoint[2];
  leftGridPoint[0] = uleft;
  leftGridPoint[1] = v;
  Real rightGridPoint[2];
  rightGridPoint[0] = uright;
  rightGridPoint[1] = v;
 
  Int i;
  Int index1, index2;
 
  index1 = leftChain->findIndexBelowGen(v, leftChainStartIndex, leftChainEndIndex);
  index2 = rightChain->findIndexBelowGen(v, rightChainStartIndex, rightChainEndIndex);
 
  if(index2 <= rightChainEndIndex) //index2 was found above
    index2 = rightChain->skipEqualityFromStart(v, index2, rightChainEndIndex);
 
  if(index1>leftChainEndIndex && index2 > rightChainEndIndex) /*no point below v on left chain or right chain*/
    {
 
      /*the botVertex is the only vertex below v*/
      ret_leftCornerWhere = 1;
      ret_rightCornerWhere = 1;
    }
  else if(index1>leftChainEndIndex ) /*index2 <= rightChainEndIndex*/
    {
 
      ret_rightCornerWhere = 2; /*on right chain*/
      ret_rightCornerIndex = index2;
 
 
      Real tempMin = rightChain->getVertex(index2)[0];
      Int tempI = index2;
      for(i=index2+1; i<= rightChainEndIndex; i++)
    if(rightChain->getVertex(i)[0] < tempMin)
      {
        tempI = i;
        tempMin = rightChain->getVertex(i)[0];
      }
 
 
      //we consider whether we can use botVertex as left corner. First check 
      //if (leftGirdPoint, botVertex) interesects right chian or not.
     if(DBG_intersectChain(rightChain, rightChainStartIndex,rightChainEndIndex,
                    leftGridPoint, botVertex))
       {
     ret_leftCornerWhere = 2;//right
     ret_leftCornerIndex = index2; //should use tempI???
       }
     else if(botVertex[0] < tempMin)
       ret_leftCornerWhere = 1; //bot
     else
       {
     ret_leftCornerWhere = 2; //right
     ret_leftCornerIndex = tempI;
       }
    }
  else if(index2> rightChainEndIndex) /*index1<=leftChainEndIndex*/
    {
      ret_leftCornerWhere = 0; /*left chain*/
      ret_leftCornerIndex = index1;
      
      /*find the vertex on the left chain with the maximum u,
       *either this vertex or the botvertex can be used as the right corner
       */
 
      Int tempI;
      //skip those points which are equal to v. (avoid degeneratcy)
      for(tempI = index1; tempI <= leftChainEndIndex; tempI++)
    if(leftChain->getVertex(tempI)[1] < v) 
      break;
      if(tempI > leftChainEndIndex)
    ret_rightCornerWhere = 1;
      else
    {
      Real tempMax = leftChain->getVertex(tempI)[0];
      for(i=tempI; i<= leftChainEndIndex; i++)
        if(leftChain->getVertex(i)[0] > tempMax)
          {
        tempI = i;
        tempMax = leftChain->getVertex(i)[0];
          }
 
 
 
      //we consider whether we can use botVertex as a corner. So first we check 
      //whether (rightGridPoint, botVertex) interescts the left chain or not.
      if(DBG_intersectChain(leftChain, leftChainStartIndex,leftChainEndIndex,
                    rightGridPoint, botVertex))
        {
          ret_rightCornerWhere = 0;
          ret_rightCornerIndex = index1; //should use tempI???
        }
      else if(botVertex[0] > tempMax)
        {
              
              ret_rightCornerWhere = 1;
        }
      else
        {
          ret_rightCornerWhere = 0;
          ret_rightCornerIndex = tempI;
        }
    }
      
    }
  else /*index1<=leftChainEndIndex and index2 <=rightChainEndIndex*/
    {
      if(leftChain->getVertex(index1)[1] >= rightChain->getVertex(index2)[1]) /*left point above right point*/
    {
      ret_leftCornerWhere = 0; /*on left chain*/
      ret_leftCornerIndex = index1;
 
      Real tempMax;
      Int tempI;
 
      tempI = index1;
      tempMax = leftChain->getVertex(index1)[0];
 
      /*find the maximum u for all the points on the left above the right point index2*/
      for(i=index1+1; i<= leftChainEndIndex; i++)
        {
          if(leftChain->getVertex(i)[1] < rightChain->getVertex(index2)[1])
        break;
 
          if(leftChain->getVertex(i)[0]>tempMax)
        {
          tempI = i;
          tempMax = leftChain->getVertex(i)[0];
        }
        }
      //we consider if we can use rightChain(index2) as right corner
      //we check if (rightChain(index2), rightGidPoint) intersecs left chain or not.
      if(DBG_intersectChain(leftChain, leftChainStartIndex,leftChainEndIndex, rightGridPoint, rightChain->getVertex(index2)))
        {
          ret_rightCornerWhere = 0;
          ret_rightCornerIndex = index1; //should use tempI???
        }
      else if(tempMax >= rightChain->getVertex(index2)[0] ||
         tempMax >= uright
         )
        {
 
          ret_rightCornerWhere = 0; /*on left Chain*/
          ret_rightCornerIndex = tempI;
        }
      else
        {
          ret_rightCornerWhere = 2; /*on right chain*/
          ret_rightCornerIndex = index2;
        }
    }
      else /*left below right*/
    {
      ret_rightCornerWhere = 2; /*on the right*/
      ret_rightCornerIndex = index2;
      
      Real tempMin;
      Int tempI;
      
      tempI = index2;
      tempMin = rightChain->getVertex(index2)[0];
      
      /*find the minimum u for all the points on the right above the left poitn index1*/
      for(i=index2+1; i<= rightChainEndIndex; i++)
        {
          if( rightChain->getVertex(i)[1] < leftChain->getVertex(index1)[1])
        break;
          if(rightChain->getVertex(i)[0] < tempMin)
        {
          tempI = i;
          tempMin = rightChain->getVertex(i)[0];
        }
        }
 
      //we consider if we can use leftchain(index1) as left corner. 
      //we check if (leftChain(index1) intersects right chian or not
      if(DBG_intersectChain(rightChain, rightChainStartIndex, rightChainEndIndex, leftGridPoint, leftChain->getVertex(index1)))
        {
          ret_leftCornerWhere = 2;
          ret_leftCornerIndex = index2; //should use tempI???
          }
      else if(tempMin <= leftChain->getVertex(index1)[0] ||
         tempMin <= uleft)              
        {
          ret_leftCornerWhere = 2; /* on right chain*/
          ret_leftCornerIndex = tempI;
        }
      else
        {
          ret_leftCornerWhere = 0; /*on left chain*/
          ret_leftCornerIndex = index1;
        }
    }
    }
 
}
 
 
void findUpCorners(Real *topVertex, 
           vertexArray *leftChain, Int leftChainStartIndex, Int leftChainEndIndex,
           vertexArray *rightChain, Int rightChainStartIndex, Int rightChainEndIndex,
           Real v,
           Real uleft,
           Real uright,
           Int& ret_leftCornerWhere, /*0: left chain, 1: topvertex, 2: rightchain*/
           Int& ret_leftCornerIndex, /*useful when ret_leftCornerWhere == 0 or 2*/
           Int& ret_rightCornerWhere, /*0: left chain, 1: topvertex, 2: rightchain*/
           Int& ret_rightCornerIndex /*useful when ret_leftCornerWhere == 0 or 2*/
           )
{
#ifdef MYDEBUG
printf("***********enter findUpCorners\n");
#endif
 
  assert(v < topVertex[1]);
  Real leftGridPoint[2];
  leftGridPoint[0] = uleft;
  leftGridPoint[1] = v;
  Real rightGridPoint[2];
  rightGridPoint[0] = uright;
  rightGridPoint[1] = v;
 
  Int i;
  Int index1, index2;
 
  index1 = leftChain->findIndexFirstAboveEqualGen(v, leftChainStartIndex, leftChainEndIndex);
 
 
  index2 = rightChain->findIndexFirstAboveEqualGen(v, rightChainStartIndex, rightChainEndIndex);
 
  if(index2>= leftChainStartIndex)  //index2 was found above  
    index2 = rightChain->skipEqualityFromStart(v, index2, rightChainEndIndex);
 
  if(index1<leftChainStartIndex && index2 <rightChainStartIndex) /*no point above v on left chain or right chain*/
    {
      /*the topVertex is the only vertex above v*/
      ret_leftCornerWhere = 1;
      ret_rightCornerWhere = 1;
    }
  else if(index1<leftChainStartIndex ) /*index2 >= rightChainStartIndex*/
    {
      ret_rightCornerWhere = 2; /*on right chain*/
      ret_rightCornerIndex = index2;
 
      //find the minimum u on right top, either that, or top, or right[index2] is the left corner
      Real tempMin = rightChain->getVertex(index2)[0];
      Int tempI = index2;
      for(i=index2-1; i>=rightChainStartIndex; i--)
    if(rightChain->getVertex(i)[0] < tempMin)
      {
        tempMin = rightChain->getVertex(i)[0];
        tempI = i;
      }
      //chech whether (leftGridPoint, top) intersects rightchai,
      //if yes, use right corner as left corner
      //if not, use top or right[tempI] as left corner
      if(DBG_intersectChain(rightChain, rightChainStartIndex, rightChainEndIndex,
            leftGridPoint, topVertex))
    {
      ret_leftCornerWhere = 2; //rightChain
      ret_leftCornerIndex = index2; 
    }
      else if(topVertex[0] < tempMin)
    ret_leftCornerWhere = 1; /*topvertex*/
      else
    {
      ret_leftCornerWhere = 2; //right chain
      ret_leftCornerIndex = tempI;
    }
          
    }
  else if(index2< rightChainStartIndex) /*index1>=leftChainStartIndex*/
    {
      ret_leftCornerWhere = 0; /*left chain*/
      ret_leftCornerIndex = index1;
       
      //find the maximum u on the left top section. either that or topvertex, or left[index1]  is the right corner
      Real tempMax = leftChain->getVertex(index1)[0];
      Int tempI = index1;
 
      for(i=index1-1; i>=leftChainStartIndex; i--){
 
    if(leftChain->getVertex(i)[0] > tempMax)
      {
 
        tempMax = leftChain->getVertex(i)[0];
        tempI = i;
      }
      }
      //check whether (rightGridPoint, top) intersects leftChain or not
      //if yes, we use leftCorner as the right corner
      //if not, we use either top or left[tempI] as the right corner
      if(DBG_intersectChain(leftChain, leftChainStartIndex,leftChainEndIndex,
                rightGridPoint, topVertex))
     {
       ret_rightCornerWhere = 0; //left chan
       ret_rightCornerIndex = index1;
     }
      else if(topVertex[0] > tempMax)
    ret_rightCornerWhere = 1;//topVertex
      else
    {
      ret_rightCornerWhere = 0;//left chain
      ret_rightCornerIndex = tempI;
    }
    }
  else /*index1>=leftChainStartIndex and index2 >=rightChainStartIndex*/
    {
      if(leftChain->getVertex(index1)[1] <= rightChain->getVertex(index2)[1]) /*left point below right point*/
    {
      ret_leftCornerWhere = 0; /*on left chain*/
      ret_leftCornerIndex = index1;
 
      Real tempMax;
      Int tempI;
 
      tempI = index1;
      tempMax = leftChain->getVertex(index1)[0];
 
      /*find the maximum u for all the points on the left below the right point index2*/
      for(i=index1-1; i>= leftChainStartIndex; i--)
        {
          if(leftChain->getVertex(i)[1] > rightChain->getVertex(index2)[1])
        break;
 
          if(leftChain->getVertex(i)[0]>tempMax)
        {
          tempI = i;
          tempMax = leftChain->getVertex(i)[0];
        }
        }
      //chek whether (rightChain(index2), rightGridPoint) intersects leftchian or not
      if(DBG_intersectChain(leftChain, leftChainStartIndex, leftChainEndIndex, rightGridPoint, rightChain->getVertex(index2)))
         {
           ret_rightCornerWhere = 0;
           ret_rightCornerIndex = index1;
         }
      else if(tempMax >= rightChain->getVertex(index2)[0] ||
         tempMax >= uright)
        {
          ret_rightCornerWhere = 0; /*on left Chain*/
          ret_rightCornerIndex = tempI;
        }
      else
        {
          ret_rightCornerWhere = 2; /*on right chain*/
          ret_rightCornerIndex = index2;
        }
    }
      else /*left above right*/
    {
      ret_rightCornerWhere = 2; /*on the right*/
      ret_rightCornerIndex = index2;
      
      Real tempMin;
      Int tempI;
      
      tempI = index2;
      tempMin = rightChain->getVertex(index2)[0];
      
      /*find the minimum u for all the points on the right below the left poitn index1*/
      for(i=index2-1; i>= rightChainStartIndex; i--)
        {
          if( rightChain->getVertex(i)[1] > leftChain->getVertex(index1)[1])
        break;
          if(rightChain->getVertex(i)[0] < tempMin)
        {
          tempI = i;
          tempMin = rightChain->getVertex(i)[0];
        }
        }
          //check whether (leftGRidPoint,left(index1)) interesect right chain 
      if(DBG_intersectChain(rightChain, rightChainStartIndex, rightChainEndIndex,
                leftGridPoint, leftChain->getVertex(index1)))
        {
          ret_leftCornerWhere = 2; //right
          ret_leftCornerIndex = index2;
        }
      else if(tempMin <= leftChain->getVertex(index1)[0] ||
         tempMin <= uleft)
        {
          ret_leftCornerWhere = 2; /* on right chain*/
          ret_leftCornerIndex = tempI;
        }
      else
        {
          ret_leftCornerWhere = 0; /*on left chain*/
          ret_leftCornerIndex = index1;
        }
    }
    }
#ifdef MYDEBUG
printf("***********leave findUpCorners\n");
#endif
}
 
//return 1 if neck exists, 0 othewise
Int findNeckF(vertexArray *leftChain, Int botLeftIndex,
          vertexArray *rightChain, Int botRightIndex,
          gridBoundaryChain* leftGridChain,
          gridBoundaryChain* rightGridChain,
          Int gridStartIndex,
          Int& neckLeft, 
          Int& neckRight)
{
/*
printf("enter findNeckF, botleft, botright=%i,%i,gstartindex=%i\n",botLeftIndex,botRightIndex,gridStartIndex);
printf("leftChain is\n");
leftChain->print();
printf("rightChain is\n");
rightChain->print();
*/
 
  Int lowerGridIndex; //the grid below leftChain and rightChian vertices
  Int i;
  Int n_vlines = leftGridChain->get_nVlines();
  Real v;
  if(botLeftIndex >= leftChain->getNumElements() ||
     botRightIndex >= rightChain->getNumElements())
    return 0; //no neck exists
     
  v=min(leftChain->getVertex(botLeftIndex)[1], rightChain->getVertex(botRightIndex)[1]);  
 
 
 
 
  for(i=gridStartIndex; i<n_vlines; i++)
    if(leftGridChain->get_v_value(i) <= v && 
       leftGridChain->getUlineIndex(i)<= rightGridChain->getUlineIndex(i))
      break;
  
  lowerGridIndex = i;
 
  if(lowerGridIndex == n_vlines) //the two trm vertex are higher than all gridlines
    return 0;
  else 
    {
      Int botLeft2, botRight2;
/*
printf("leftGridChain->get_v_)value=%f\n",leftGridChain->get_v_value(lowerGridIndex), botLeftIndex); 
printf("leftChain->get_vertex(0)=(%f,%f)\n", leftChain->getVertex(0)[0],leftChain->getVertex(0)[1]);
printf("leftChain->get_vertex(1)=(%f,%f)\n", leftChain->getVertex(1)[0],leftChain->getVertex(1)[1]);
printf("leftChain->get_vertex(2)=(%f,%f)\n", leftChain->getVertex(2)[0],leftChain->getVertex(2)[1]);
*/
      botLeft2 = leftChain->findIndexFirstAboveEqualGen(leftGridChain->get_v_value(lowerGridIndex), botLeftIndex, leftChain->getNumElements()-1) -1 ;
 
/*
printf("botLeft2=%i\n", botLeft2);
printf("leftChain->getNumElements=%i\n", leftChain->getNumElements());
*/
 
      botRight2 = rightChain->findIndexFirstAboveEqualGen(leftGridChain->get_v_value(lowerGridIndex), botRightIndex, rightChain->getNumElements()-1) -1;
      if(botRight2 < botRightIndex) botRight2=botRightIndex;
 
      if(botLeft2 < botLeftIndex) botLeft2 = botLeftIndex;
 
      assert(botLeft2 >= botLeftIndex);
      assert(botRight2 >= botRightIndex);
      //find nectLeft so that it is th erightmost vertex on letChain
 
      Int tempI = botLeftIndex;
      Real temp = leftChain->getVertex(tempI)[0];
      for(i=botLeftIndex+1; i<= botLeft2; i++)
    if(leftChain->getVertex(i)[0] > temp)
      {
        temp = leftChain->getVertex(i)[0];
        tempI = i;
      }
      neckLeft = tempI;
 
      tempI = botRightIndex;
      temp = rightChain->getVertex(tempI)[0];
      for(i=botRightIndex+1; i<= botRight2; i++)
    if(rightChain->getVertex(i)[0] < temp)
      {
        temp = rightChain->getVertex(i)[0];
        tempI = i;
      }
      neckRight = tempI;
      return 1;
    }
}
                            
  
              
/*find i>=botLeftIndex,j>=botRightIndex so that
 *(leftChain[i], rightChain[j]) is a neck.
 */
void findNeck(vertexArray *leftChain, Int botLeftIndex, 
          vertexArray *rightChain, Int botRightIndex, 
          Int& leftLastIndex, /*left point of the neck*/
          Int& rightLastIndex /*right point of the neck*/
          )
{
  assert(botLeftIndex < leftChain->getNumElements() &&
     botRightIndex < rightChain->getNumElements());
     
  /*now the neck exists for sure*/
 
  if(leftChain->getVertex(botLeftIndex)[1] <= rightChain->getVertex(botRightIndex)[1]) //left below right
    {
 
      leftLastIndex = botLeftIndex;
      
      /*find i so that rightChain[i][1] >= leftchainbotverte[1], and i+1<
       */
      rightLastIndex=rightChain->findIndexAboveGen(leftChain->getVertex(botLeftIndex)[1], botRightIndex+1, rightChain->getNumElements()-1);    
    }
  else  //left above right
    {
 
      rightLastIndex = botRightIndex;
     
      leftLastIndex = leftChain->findIndexAboveGen(rightChain->getVertex(botRightIndex)[1], 
                          botLeftIndex+1,
                          leftChain->getNumElements()-1);
    }
}
      
      
 
void findLeftGridIndices(directedLine* topEdge, Int firstGridIndex, Int lastGridIndex, gridWrap* grid,  Int* ret_indices, Int* ret_innerIndices)
{
 
  Int i,k,isHoriz = 0;
  Int n_ulines = grid->get_n_ulines();
  Real uMin = grid->get_u_min();
  Real uMax = grid->get_u_max();
  /*
  Real vMin = grid->get_v_min();
  Real vMax = grid->get_v_max();
  */
  Real slop = 0.0, uinterc;
 
#ifdef SHORTEN_GRID_LINE
  //uintercBuf stores all the interction u value for each grid line
  //notice that lastGridIndex<= firstGridIndex
  Real *uintercBuf = (Real *) malloc (sizeof(Real) * (firstGridIndex-lastGridIndex+1));
  assert(uintercBuf);
#endif
 
  /*initialization to make vtail bigger than grid->...*/
  directedLine* dLine = topEdge;
  Real vtail = grid->get_v_value(firstGridIndex) + 1.0; 
  Real tempMaxU = grid->get_u_min();
 
 
  /*for each grid line*/
  for(k=0, i=firstGridIndex; i>=lastGridIndex; i--, k++)
    {
 
      Real grid_v_value = grid->get_v_value(i);
 
      /*check whether this grid line is below the current trim edge.*/
      if(vtail > grid_v_value)
    {
      /*since the grid line is below the trim edge, we 
       *find the trim edge which will contain the trim line
       */
      while( (vtail=dLine->tail()[1]) > grid_v_value){
 
        tempMaxU = max(tempMaxU, dLine->tail()[0]);
        dLine = dLine -> getNext();
      }
 
      if( fabs(dLine->head()[1] - vtail) < ZERO)
        isHoriz = 1;
      else
        {
          isHoriz = 0;
          slop = (dLine->head()[0] - dLine->tail()[0]) / (dLine->head()[1]-vtail);
        }
    }
 
      if(isHoriz)
    {
      uinterc = max(dLine->head()[0], dLine->tail()[0]);
    }
      else
    {
      uinterc = slop * (grid_v_value - vtail) + dLine->tail()[0];
    }
      
      tempMaxU = max(tempMaxU, uinterc);
 
      if(uinterc < uMin && uinterc >= uMin - ZERO)
    uinterc = uMin;
      if(uinterc > uMax && uinterc <= uMax + ZERO)
    uinterc = uMax;
 
#ifdef SHORTEN_GRID_LINE
      uintercBuf[k] = uinterc;
#endif
 
      assert(uinterc >= uMin && uinterc <= uMax);
       if(uinterc == uMax)
         ret_indices[k] = n_ulines-1;
       else
     ret_indices[k] = (Int)(((uinterc-uMin)/(uMax - uMin)) * (n_ulines-1)) + 1;
      if(ret_indices[k] >= n_ulines)
    ret_indices[k] = n_ulines-1;
 
 
      ret_innerIndices[k] = (Int)(((tempMaxU-uMin)/(uMax - uMin)) * (n_ulines-1)) + 1;
 
      /*reinitialize tempMaxU for next grdiLine*/
      tempMaxU = uinterc;
    }
#ifdef SHORTEN_GRID_LINE
  //for each grid line, compare the left grid point with the 
  //intersection point. If the two points are too close, then
  //we should move the grid point one grid to the right
  //and accordingly we should update the inner index.
  for(k=0, i=firstGridIndex; i>=lastGridIndex; i--, k++)
    {
      //check gridLine i
      //check ret_indices[k]
      Real a = grid->get_u_value(ret_indices[k]-1);
      Real b = grid->get_u_value(ret_indices[k]);
      assert(uintercBuf[k] >= a && uintercBuf < b);
      if( (b-uintercBuf[k]) <= 0.2 * (b-a)) //interc is very close to b
    {
      ret_indices[k]++;
    }
 
      //check ret_innerIndices[k]
      if(k>0)
    {
      if(ret_innerIndices[k] < ret_indices[k-1])
        ret_innerIndices[k] = ret_indices[k-1];
      if(ret_innerIndices[k] < ret_indices[k])
        ret_innerIndices[k] = ret_indices[k];
    }
    }
  //clean up
  free(uintercBuf);
#endif
}
 
void findRightGridIndices(directedLine* topEdge, Int firstGridIndex, Int lastGridIndex, gridWrap* grid,  Int* ret_indices, Int* ret_innerIndices)
{
 
  Int i,k;
  Int n_ulines = grid->get_n_ulines();
  Real uMin = grid->get_u_min();
  Real uMax = grid->get_u_max();
  /*
  Real vMin = grid->get_v_min();
  Real vMax = grid->get_v_max();
  */
  Real slop = 0.0, uinterc;
 
#ifdef SHORTEN_GRID_LINE
  //uintercBuf stores all the interction u value for each grid line
  //notice that firstGridIndex >= lastGridIndex
  Real *uintercBuf = (Real *) malloc (sizeof(Real) * (firstGridIndex-lastGridIndex+1));
  assert(uintercBuf);
#endif
 
  /*initialization to make vhead bigger than grid->v_value...*/
  directedLine* dLine = topEdge->getPrev();
  Real vhead = dLine->tail()[1];
  Real tempMinU = grid->get_u_max();
 
  /*for each grid line*/
  for(k=0, i=firstGridIndex; i>=lastGridIndex; i--, k++)
    {
 
      Real grid_v_value = grid->get_v_value(i);
 
 
      /*check whether this grid line is below the current trim edge.*/
      if(vhead >= grid_v_value)
    {
      /*since the grid line is below the tail of the trim edge, we 
       *find the trim edge which will contain the trim line
       */
      while( (vhead=dLine->head()[1]) > grid_v_value){
        tempMinU = min(tempMinU, dLine->head()[0]);
        dLine = dLine -> getPrev();
      }
 
      /*skip the equality in the case of degenerat case: horizontal */
      while(dLine->head()[1] == grid_v_value)
        dLine = dLine->getPrev();
        
      assert( dLine->tail()[1] != dLine->head()[1]);
      slop = (dLine->tail()[0] - dLine->head()[0]) / (dLine->tail()[1]-dLine->head()[1]);
      /*
       if(dLine->tail()[1] == vhead)
         isHoriz = 1;
         else
        {
          isHoriz = 0;
          slop = (dLine->tail()[0] - dLine->head()[0]) / (dLine->tail()[1]-vhead);
        }
        */
    }
    uinterc = slop * (grid_v_value - dLine->head()[1]) + dLine->head()[0];
 
      //in case unterc is outside of the grid due to floating point
      if(uinterc < uMin)
    uinterc = uMin;
      else if(uinterc > uMax)
    uinterc = uMax;
 
#ifdef SHORTEN_GRID_LINE
      uintercBuf[k] = uinterc;
#endif      
 
      tempMinU = min(tempMinU, uinterc);
 
      assert(uinterc >= uMin && uinterc <= uMax);      
 
      if(uinterc == uMin)
    ret_indices[k] = 0;
      else
    ret_indices[k] = (int)ceil((((uinterc-uMin)/(uMax - uMin)) * (n_ulines-1))) -1;
/*
if(ret_indices[k] >= grid->get_n_ulines())
  {
  printf("ERROR3\n");
  exit(0);
}
if(ret_indices[k] < 0)    
  {
  printf("ERROR4\n");
  exit(0);
}
*/
      ret_innerIndices[k] = (int)ceil ((((tempMinU-uMin)/(uMax - uMin)) * (n_ulines-1))) -1;
 
      tempMinU = uinterc;
    }
#ifdef SHORTEN_GRID_LINE
  //for each grid line, compare the left grid point with the 
  //intersection point. If the two points are too close, then
  //we should move the grid point one grid to the right
  //and accordingly we should update the inner index.
  for(k=0, i=firstGridIndex; i>=lastGridIndex; i--, k++)
    {
      //check gridLine i
      //check ret_indices[k]
      Real a = grid->get_u_value(ret_indices[k]);
      Real b = grid->get_u_value(ret_indices[k]+1);
      assert(uintercBuf[k] > a && uintercBuf <= b);
      if( (uintercBuf[k]-a) <= 0.2 * (b-a)) //interc is very close to a
    {
      ret_indices[k]--;
    }
 
      //check ret_innerIndices[k]
      if(k>0)
    {
      if(ret_innerIndices[k] > ret_indices[k-1])
        ret_innerIndices[k] = ret_indices[k-1];
      if(ret_innerIndices[k] > ret_indices[k])
        ret_innerIndices[k] = ret_indices[k];
    }
    }
  //clean up
  free(uintercBuf);
#endif
}
 
 
void sampleMonoPoly(directedLine* polygon, gridWrap* grid, Int ulinear, Int vlinear, primStream* pStream, rectBlockArray* rbArray)
{
/*
{
grid->print();
polygon->writeAllPolygons("zloutputFile");
exit(0);
}
*/
 
if(grid->get_n_ulines() == 2 ||
   grid->get_n_vlines() == 2)
{ 
  if(ulinear && grid->get_n_ulines() == 2)
    {
      monoTriangulationFun(polygon, compV2InY, pStream);   
      return;
    }
  else if(DBG_isConvex(polygon) && polygon->numEdges() >=4)
     {
       triangulateConvexPoly(polygon, ulinear, vlinear, pStream);
       return;
     }
  else if(vlinear || DBG_is_U_direction(polygon))
    {
      Int n_cusps;//num interior cusps
      Int n_edges = polygon->numEdges();
      directedLine** cusps = (directedLine**) malloc(sizeof(directedLine*) * n_edges);
      assert(cusps);
      findInteriorCuspsX(polygon, n_cusps, cusps);
 
      if(n_cusps == 0) //u_monotone
    {
 
      monoTriangulationFun(polygon, compV2InX, pStream);
 
          free(cusps);
          return;          
    }
      else if(n_cusps == 1) //one interior cusp
    {
 
      directedLine* new_polygon = polygonConvert(cusps[0]);
 
      directedLine* other = findDiagonal_singleCuspX( new_polygon);
 
 
 
      //<other> should NOT be null unless there are self-intersecting
          //trim curves. In that case, we don't want to core dump, instead,
          //we triangulate anyway, and print out error message.
      if(other == NULL)
        {
          monoTriangulationFun(polygon, compV2InX, pStream);
          free(cusps);
          return;
        }
 
      directedLine* ret_p1;
      directedLine* ret_p2;
 
      new_polygon->connectDiagonal_2slines(new_polygon, other, 
                       &ret_p1,
                       &ret_p2,
                       new_polygon);
 
      monoTriangulationFun(ret_p1, compV2InX, pStream);
      monoTriangulationFun(ret_p2, compV2InX, pStream);
 
      ret_p1->deleteSinglePolygonWithSline();         
      ret_p2->deleteSinglePolygonWithSline();     
 
          free(cusps);
          return;
         }
     free(cusps);
     }
}
 
  /*find the top and bottom of the polygon. It is supposed to be
   *a V-monotone polygon
   */
 
  directedLine* tempV;
  directedLine* topV;
  directedLine* botV;
  topV = botV = polygon;
 
  for(tempV = polygon->getNext(); tempV != polygon; tempV = tempV->getNext())
    {
      if(compV2InY(topV->head(), tempV->head())<0) {
 
    topV = tempV;
      }
      if(compV2InY(botV->head(), tempV->head())>0) {
 
    botV = tempV;
      }
    }
  
  /*find the first(top) and the last (bottom) grid line which intersect the
   *this polygon
   */
  Int firstGridIndex; /*the index in the grid*/
  Int lastGridIndex;
  firstGridIndex = (Int) ((topV->head()[1] - grid->get_v_min()) / (grid->get_v_max() - grid->get_v_min()) * (grid->get_n_vlines()-1));
  lastGridIndex  = (Int) ((botV->head()[1] - grid->get_v_min()) / (grid->get_v_max() - grid->get_v_min()) * (grid->get_n_vlines()-1)) + 1;
 
 
  /*find the interval inside  the polygon for each gridline*/
  Int *leftGridIndices = (Int*) malloc(sizeof(Int) * (firstGridIndex - lastGridIndex +1));
  assert(leftGridIndices);
  Int *rightGridIndices = (Int*) malloc(sizeof(Int) * (firstGridIndex - lastGridIndex +1));
  assert(rightGridIndices);
  Int *leftGridInnerIndices = (Int*) malloc(sizeof(Int) * (firstGridIndex - lastGridIndex +1));
  assert(leftGridInnerIndices);
  Int *rightGridInnerIndices = (Int*) malloc(sizeof(Int) * (firstGridIndex - lastGridIndex +1));
  assert(rightGridInnerIndices);
 
  findLeftGridIndices(topV, firstGridIndex, lastGridIndex, grid,  leftGridIndices, leftGridInnerIndices);
 
  findRightGridIndices(topV, firstGridIndex, lastGridIndex, grid,  rightGridIndices, rightGridInnerIndices);
 
  gridBoundaryChain leftGridChain(grid, firstGridIndex, firstGridIndex-lastGridIndex+1, leftGridIndices, leftGridInnerIndices);
 
  gridBoundaryChain rightGridChain(grid, firstGridIndex, firstGridIndex-lastGridIndex+1, rightGridIndices, rightGridInnerIndices);
 
 
 
//  leftGridChain.draw();
//  leftGridChain.drawInner();
//  rightGridChain.draw();
//  rightGridChain.drawInner();
  /*(1) determine the grid boundaries (left and right).
   *(2) process polygon  into two monotone chaines: use vertexArray
   *(3) call sampleMonoPolyRec
   */
 
  /*copy the two chains into vertexArray datastructure*/
  Int i;
  vertexArray leftChain(20); /*this is a dynamic array*/
  for(i=1; i<=topV->get_npoints()-2; i++) { /*the first vertex is the top vertex which doesn't belong to inc_chain*/
    leftChain.appendVertex(topV->getVertex(i));
  }
  for(tempV = topV->getNext(); tempV != botV; tempV = tempV->getNext())
    {
      for(i=0; i<=tempV->get_npoints()-2; i++){
    leftChain.appendVertex(tempV->getVertex(i));
      }
    }
  
  vertexArray rightChain(20);
  for(tempV = topV->getPrev(); tempV != botV; tempV = tempV->getPrev())
    {
      for(i=tempV->get_npoints()-2; i>=0; i--){
    rightChain.appendVertex(tempV->getVertex(i));
      }
    }
  for(i=botV->get_npoints()-2; i>=1; i--){ 
    rightChain.appendVertex(tempV->getVertex(i));
  }
 
  sampleMonoPolyRec(topV->head(),
            botV->head(),
            &leftChain,
            0,
            &rightChain,
            0,
            &leftGridChain,
            &rightGridChain,
            0,
            pStream,
            rbArray);
 
 
  /*cleanup space*/
  free(leftGridIndices);
  free(rightGridIndices);
  free(leftGridInnerIndices);
  free(rightGridInnerIndices);
}
 
void sampleMonoPolyRec(
               Real* topVertex,
               Real* botVertex,
               vertexArray* leftChain, 
               Int leftStartIndex,
               vertexArray* rightChain,
               Int rightStartIndex,
               gridBoundaryChain* leftGridChain, 
               gridBoundaryChain* rightGridChain, 
               Int gridStartIndex,
               primStream* pStream,
               rectBlockArray* rbArray)
{
 
  /*find the first connected component, and the four corners.
   */
  Int index1, index2; /*the first and last grid line of the first connected component*/
 
  if(topVertex[1] <= botVertex[1])
    return;
    
  /*find i so that the grid line is below the top vertex*/
  Int i=gridStartIndex;
  while (i < leftGridChain->get_nVlines())
    {
      if(leftGridChain->get_v_value(i) < topVertex[1])
    break;
      i++;
    }
 
  /*find the first connected component starting with i*/
  /*find index1 so that left_uline_index <= right_uline_index, that is, this
   *grid line contains at least one inner grid point
   */
  index1=i;
  int num_skipped_grid_lines=0;
  while(index1 < leftGridChain->get_nVlines())
    {
      if(leftGridChain->getUlineIndex(index1) <= rightGridChain->getUlineIndex(index1))
    break;
      num_skipped_grid_lines++;
      index1++;
    }
 
 
 
  if(index1 >= leftGridChain->get_nVlines()) /*no grid line exists which has inner point*/
    {
      /*stop recursion, ...*/
      /*monotone triangulate it...*/
//      printf("no grid line exists\n");      
/*
      monoTriangulationRecOpt(topVertex, botVertex, leftChain, leftStartIndex,
               rightChain, rightStartIndex, pStream);
*/
 
if(num_skipped_grid_lines <2)
  {
    monoTriangulationRecGenOpt(topVertex, botVertex, leftChain, leftStartIndex,
                   leftChain->getNumElements()-1,
                   rightChain, rightStartIndex, 
                   rightChain->getNumElements()-1,
                   pStream);
  }
else
  {
    //the optimum way to triangulate is top-down since this polygon
    //is narrow-long.
    monoTriangulationRec(topVertex, botVertex, leftChain, leftStartIndex,
             rightChain, rightStartIndex, pStream);
  }
 
/*
      monoTriangulationRec(topVertex, botVertex, leftChain, leftStartIndex,
               rightChain, rightStartIndex, pStream);
*/
 
/*      monoTriangulationRecGenTBOpt(topVertex, botVertex, 
                   leftChain, leftStartIndex, leftChain->getNumElements()-1,
                   rightChain, rightStartIndex, rightChain->getNumElements()-1, 
                   pStream);*/
      
 
 
    }
  else
    {
 
      /*find index2 so that left_inner_index <= right_inner_index holds until index2*/
      index2=index1+1;
      if(index2 < leftGridChain->get_nVlines())
    while(leftGridChain->getInnerIndex(index2) <= rightGridChain->getInnerIndex(index2))
      {
        index2++;
        if(index2 >= leftGridChain->get_nVlines())
          break;
      }
      
      index2--;
      
 
      
      /*the neck*/
      Int neckLeftIndex;
      Int neckRightIndex;
 
      /*the four corners*/
      Int up_leftCornerWhere;
      Int up_leftCornerIndex;
      Int up_rightCornerWhere;
      Int up_rightCornerIndex;
      Int down_leftCornerWhere;
      Int down_leftCornerIndex;
      Int down_rightCornerWhere;
      Int down_rightCornerIndex;
 
      Real* tempBotVertex; /*the bottom vertex for this component*/
      Real* nextTopVertex=NULL; /*for the recursion*/
      Int nextLeftStartIndex=0;
      Int nextRightStartIndex=0;
 
      /*find the points below the grid line index2 on both chains*/
      Int botLeftIndex = leftChain->findIndexStrictBelowGen(
                              leftGridChain->get_v_value(index2),
                              leftStartIndex,
                              leftChain->getNumElements()-1);
      Int botRightIndex = rightChain->findIndexStrictBelowGen(
                            rightGridChain->get_v_value(index2),
                            rightStartIndex,
                            rightChain->getNumElements()-1);
      /*if either botLeftIndex>= numelements,
       *        or botRightIndex >= numelemnet,
       *then there is no neck exists. the bottom vertex is botVertex, 
       */
      if(! findNeckF(leftChain, botLeftIndex, rightChain, botRightIndex,
           leftGridChain, rightGridChain, index2, neckLeftIndex, neckRightIndex))
     /*
      if(botLeftIndex == leftChain->getNumElements() ||
     botRightIndex == rightChain->getNumElements())
     */
    {
#ifdef MYDEBUG
      printf("neck NOT exists, botRightIndex=%i\n", botRightIndex);
#endif
 
      tempBotVertex =  botVertex;
      nextTopVertex = botVertex;
      botLeftIndex = leftChain->getNumElements()-1;
      botRightIndex = rightChain->getNumElements()-1;
    }
      else /*neck exists*/
    {
#ifdef MYDEBUG
      printf("neck exists\n");
#endif
 
          /*
      findNeck(leftChain, botLeftIndex,
           rightChain, botRightIndex,
           neckLeftIndex,
           neckRightIndex);
           */
#ifdef MYDEBUG
printf("neck is found, neckLeftIndex=%i, neckRightIndex=%i\n", neckLeftIndex, neckRightIndex);
glBegin(GL_LINES);
glVertex2fv(leftChain->getVertex(neckLeftIndex));
glVertex2fv(rightChain->getVertex(neckRightIndex));
glEnd();
#endif
 
      if(leftChain->getVertex(neckLeftIndex)[1] <= rightChain->getVertex(neckRightIndex)[1])
        {
          tempBotVertex = leftChain->getVertex(neckLeftIndex);
          botLeftIndex = neckLeftIndex-1;
          botRightIndex = neckRightIndex;
          nextTopVertex = rightChain->getVertex(neckRightIndex);
          nextLeftStartIndex = neckLeftIndex;
          nextRightStartIndex = neckRightIndex+1;
        }
      else
        {
          tempBotVertex = rightChain->getVertex(neckRightIndex);
          botLeftIndex = neckLeftIndex;
          botRightIndex = neckRightIndex-1;       
          nextTopVertex = leftChain->getVertex(neckLeftIndex);
          nextLeftStartIndex = neckLeftIndex+1;
          nextRightStartIndex = neckRightIndex;
        }
    }
 
      findUpCorners(topVertex,
            leftChain,
            leftStartIndex, botLeftIndex,
            rightChain,
            rightStartIndex, botRightIndex,
            leftGridChain->get_v_value(index1),
            leftGridChain->get_u_value(index1),
            rightGridChain->get_u_value(index1),
            up_leftCornerWhere,
            up_leftCornerIndex,
            up_rightCornerWhere,
            up_rightCornerIndex);
 
      findDownCorners(tempBotVertex,
              leftChain,
              leftStartIndex, botLeftIndex,
              rightChain,
              rightStartIndex, botRightIndex,
              leftGridChain->get_v_value(index2),
              leftGridChain->get_u_value(index2),
              rightGridChain->get_u_value(index2),
              down_leftCornerWhere,
              down_leftCornerIndex,
              down_rightCornerWhere,
              down_rightCornerIndex);         
#ifdef MYDEBUG
      printf("find corners done, down_leftwhere=%i, down_righwhere=%i,\n",down_leftCornerWhere, down_rightCornerWhere );
      printf("find corners done, up_leftwhere=%i, up_righwhere=%i,\n",up_leftCornerWhere, up_rightCornerWhere );
      printf("find corners done, up_leftindex=%i, up_righindex=%i,\n",up_leftCornerIndex, up_rightCornerIndex );
      printf("find corners done, down_leftindex=%i, down_righindex=%i,\n",down_leftCornerIndex, down_rightCornerIndex );
#endif
 
/*
      drawCorners(topVertex,
          tempBotVertex,
          leftChain,
          rightChain,
          leftGridChain,
          rightGridChain,
          index1,
          index2,
          up_leftCornerWhere,
          up_leftCornerIndex,
          up_rightCornerWhere,
          up_rightCornerIndex,
          down_leftCornerWhere,
          down_leftCornerIndex,
          down_rightCornerWhere,
          down_rightCornerIndex);
*/
 
 
      sampleConnectedComp(topVertex, tempBotVertex,
              leftChain, 
              leftStartIndex, botLeftIndex,
              rightChain,
              rightStartIndex, botRightIndex,
              leftGridChain,
              rightGridChain,
              index1, index2,
              up_leftCornerWhere,
              up_leftCornerIndex,
              up_rightCornerWhere,
              up_rightCornerIndex,
              down_leftCornerWhere,
              down_leftCornerIndex,
              down_rightCornerWhere,
              down_rightCornerIndex,
              pStream,
              rbArray
              );
 
      /*recursion*/
 
      sampleMonoPolyRec(
            nextTopVertex,
            botVertex,
            leftChain, 
            nextLeftStartIndex,
            rightChain,
            nextRightStartIndex,
            leftGridChain, 
            rightGridChain, 
            index2+1,
            pStream, rbArray);
            
 
    }
 
}
 
void sampleLeftStrip(vertexArray* leftChain,
             Int topLeftIndex,
             Int botLeftIndex,
             gridBoundaryChain* leftGridChain,
             Int leftGridChainStartIndex,
             Int leftGridChainEndIndex,
             primStream* pStream
             )
{
  assert(leftChain->getVertex(topLeftIndex)[1] > leftGridChain->get_v_value(leftGridChainStartIndex));
  assert(leftChain->getVertex(topLeftIndex+1)[1] <= leftGridChain->get_v_value(leftGridChainStartIndex));
  assert(leftChain->getVertex(botLeftIndex)[1] <= leftGridChain->get_v_value(leftGridChainEndIndex));
  assert(leftChain->getVertex(botLeftIndex-1)[1] > leftGridChain->get_v_value(leftGridChainEndIndex));
 
  /*
   *(1)find the last grid line which doesn'; pass below
   * this first edge, sample this region: one trim edge and 
   * possily multiple grid lines.
   */
  Real *upperVert, *lowerVert; /*the end points of the first trim edge*/
  upperVert = leftChain->getVertex(topLeftIndex);
  lowerVert = leftChain->getVertex(topLeftIndex+1);
  
  Int index = leftGridChainStartIndex;
  while(leftGridChain->get_v_value(index) >= lowerVert[1]){
    index++;
    if(index > leftGridChainEndIndex) 
      break;
  }
  index--;
  
  sampleLeftSingleTrimEdgeRegion(upperVert, lowerVert,
                 leftGridChain,
                 leftGridChainStartIndex,
                 index,
                 pStream);
  sampleLeftStripRec(leftChain, topLeftIndex+1, botLeftIndex,
             leftGridChain, index, leftGridChainEndIndex,
             pStream);
 
}
 
void sampleLeftStripRec(vertexArray* leftChain,
             Int topLeftIndex,
             Int botLeftIndex,
             gridBoundaryChain* leftGridChain,
             Int leftGridChainStartIndex,
             Int leftGridChainEndIndex,
            primStream* pStream
             )
{
  /*now top left trim vertex is below the top grid line.
   */
  /*stop condition: if topLeftIndex >= botLeftIndex, then stop.
   */
  if(topLeftIndex >= botLeftIndex) 
    return;
 
  /*find the last trim vertex which is above the second top grid line:
   * index1.
   *and sampleLeftOneGridStep(leftchain, topLeftIndex, index1, leftGridChain,
   * leftGridChainStartIndex).
   * index1 could be equal to topLeftIndex.
   */
  Real secondGridChainV = leftGridChain->get_v_value(leftGridChainStartIndex+1);
  assert(leftGridChainStartIndex < leftGridChainEndIndex);
  Int index1 = topLeftIndex;
  while(leftChain->getVertex(index1)[1] > secondGridChainV)
    index1++;
  index1--;
  
  sampleLeftOneGridStep(leftChain, topLeftIndex, index1, leftGridChain, leftGridChainStartIndex, pStream);
 
 
  /* 
   * Let the next trim vertex be nextTrimVertIndex (which should be  
   *  below the second grid line).
   * Find the last grid line index2 which is above nextTrimVert.
   * sampleLeftSingleTrimEdgeRegion(uppervert[2], lowervert[2], 
   *                      leftGridChain, leftGridChainStartIndex+1, index2).
   */
  Real *uppervert, *lowervert;
  uppervert = leftChain->getVertex(index1);
  lowervert = leftChain->getVertex(index1+1);
  Int index2 = leftGridChainStartIndex+1;
 
  while(leftGridChain->get_v_value(index2) >= lowervert[1])
    {
      index2++;
      if(index2 > leftGridChainEndIndex)
    break;
    }
  index2--;
  sampleLeftSingleTrimEdgeRegion(uppervert, lowervert, leftGridChain, leftGridChainStartIndex+1, index2,  pStream);
 
   /* sampleLeftStripRec(leftChain, 
                        nextTrimVertIndex,
                        botLeftIndex,
                        leftGridChain,
            index2,
                        leftGridChainEndIndex
            )
   *
   */
  sampleLeftStripRec(leftChain, index1+1, botLeftIndex, leftGridChain, index2, leftGridChainEndIndex, pStream);
  
}
 
 
/***************begin RecF***********************/
/* the gridlines from leftGridChainStartIndex to 
 * leftGridChainEndIndex are assumed to form a
 * connected component.
 * the trim vertex of topLeftIndex is assumed to
 * be below the first gridline, and the tim vertex
 * of botLeftIndex is assumed to be above the last
 * grid line.
 * If botLeftIndex < topLeftIndex, then no connected componeent exists, and this funcion returns without
 * outputing any triangles.
 * Otherwise botLeftIndex >= topLeftIndex, there is at least one triangle to output.
 */
void sampleLeftStripRecF(vertexArray* leftChain,
             Int topLeftIndex,
             Int botLeftIndex,
             gridBoundaryChain* leftGridChain,
             Int leftGridChainStartIndex,
             Int leftGridChainEndIndex,
            primStream* pStream
             )
{
  /*now top left trim vertex is below the top grid line.
   */
  /*stop condition: if topLeftIndex > botLeftIndex, then stop.
   */
  if(topLeftIndex > botLeftIndex) 
    return;
 
  /*if there is only one grid Line, return.*/
 
  if(leftGridChainStartIndex>=leftGridChainEndIndex)
    return;
 
 
  assert(leftChain->getVertex(topLeftIndex)[1] <= leftGridChain->get_v_value(leftGridChainStartIndex) &&
     leftChain->getVertex(botLeftIndex)[1] >= leftGridChain->get_v_value(leftGridChainEndIndex));
 
  /*firs find the first trim vertex which is below or equal to the second top grid line:
   * index1.
   */
  Real secondGridChainV = leftGridChain->get_v_value(leftGridChainStartIndex+1);
 
 
  Int index1 = topLeftIndex;
 
  while(leftChain->getVertex(index1)[1] > secondGridChainV){
    index1++;
    if(index1>botLeftIndex)
      break;
  }
 
  /*now leftChain->getVertex(index-1)[1] > secondGridChainV and
   *    leftChain->getVertex(index)[1] <= secondGridChainV
   *If equality holds, then we should include the vertex index1, otherwise we include only index1-1, to
   *perform sampleOneGridStep.
   */
  if(index1>botLeftIndex) 
    index1--;
  else if(leftChain->getVertex(index1)[1] < secondGridChainV)
    index1--;
 
  /*now we have leftChain->getVertex(index1)[1] >= secondGridChainV, and 
   *  leftChain->getVertex(index1+1)[1] <= secondGridChainV
   */
 
 
  sampleLeftOneGridStep(leftChain, topLeftIndex, index1, leftGridChain, leftGridChainStartIndex, pStream);
 
 
  /*if leftChain->getVertex(index1)[1] == secondGridChainV, then we can recursively do the rest.
   */
  if(leftChain->getVertex(index1)[1] == secondGridChainV)
    {
 
      sampleLeftStripRecF(leftChain, index1, botLeftIndex,leftGridChain, leftGridChainStartIndex+1, leftGridChainEndIndex, pStream);
    }
  else if(index1 < botLeftIndex)
    {
 
      /* Otherwise, we have leftChain->getVertex(index1)[1] > secondGridChainV,
       * let the next trim vertex be nextTrimVertIndex (which should be  strictly
       *  below the second grid line).
       * Find the last grid line index2 which is above nextTrimVert.
       * sampleLeftSingleTrimEdgeRegion(uppervert[2], lowervert[2], 
       *                      leftGridChain, leftGridChainStartIndex+1, index2).
       */
      Real *uppervert, *lowervert;
      uppervert = leftChain->getVertex(index1);
      lowervert = leftChain->getVertex(index1+1); //okay since index1<botLeftIndex
      Int index2 = leftGridChainStartIndex+1;
 
      
      while(leftGridChain->get_v_value(index2) >= lowervert[1])
    {
      index2++;
      if(index2 > leftGridChainEndIndex)
        break;
    }
      index2--;
 
      
      sampleLeftSingleTrimEdgeRegion(uppervert, lowervert, leftGridChain, leftGridChainStartIndex+1, index2,  pStream);
      
      /*recursion*/
 
      sampleLeftStripRecF(leftChain, index1+1, botLeftIndex, leftGridChain, index2, leftGridChainEndIndex, pStream);
    }
  
}
 
/***************End RecF***********************/
 
/*sample the left area in between one trim edge and multiple grid lines.
 * all the grid lines should be in between the two end poins of the
 *trim edge.
 */
void sampleLeftSingleTrimEdgeRegion(Real upperVert[2], Real lowerVert[2],
                    gridBoundaryChain* gridChain,
                    Int beginIndex,
                    Int endIndex,
                    primStream* pStream)
{
  Int i,j,k;
 
  vertexArray vArray(endIndex-beginIndex+1);  
  vArray.appendVertex(gridChain->get_vertex(beginIndex));
 
  for(k=1, i=beginIndex+1; i<=endIndex; i++, k++)
    {
      vArray.appendVertex(gridChain->get_vertex(i));
 
      /*output the fan of the grid points of the (i)th and (i-1)th grid line.
       */
      if(gridChain->getUlineIndex(i) < gridChain->getUlineIndex(i-1))
    {
      pStream->begin();   
      pStream->insert(gridChain->get_vertex(i-1));
      for(j=gridChain->getUlineIndex(i); j<= gridChain->getUlineIndex(i-1); j++)
        pStream->insert(gridChain->getGrid()->get_u_value(j), gridChain->get_v_value(i));
      pStream->end(PRIMITIVE_STREAM_FAN);
    }
      else if(gridChain->getUlineIndex(i) > gridChain->getUlineIndex(i-1))
    {
      pStream->begin();
      pStream->insert(gridChain->get_vertex(i));
      for(j=gridChain->getUlineIndex(i); j>= gridChain->getUlineIndex(i-1); j--)
        pStream->insert(gridChain->getGrid()->get_u_value(j), gridChain->get_v_value(i-1));
      pStream->end(PRIMITIVE_STREAM_FAN);
    }
      /*otherwisem, the two are equal, so there is no fan to outout*/     
    }
  
  monoTriangulation2(upperVert, lowerVert, &vArray, 0, endIndex-beginIndex, 
             0, /*decreasing chain*/
             pStream);
}
  
/*return i, such that from begin to i-1 the chain is strictly u-monotone. 
 */              
Int findIncreaseChainFromBegin(vertexArray* chain, Int begin ,Int end)
{
  Int i=begin;
  Real prevU = chain->getVertex(i)[0];
  Real thisU;
  for(i=begin+1; i<=end; i++){
    thisU = chain->getVertex(i)[0];
 
    if(prevU < thisU){
      prevU = thisU;
    }
    else
      break;
  }
  return i;
}
  
/*check whether there is a vertex whose v value is strictly 
 *inbetween vup vbelow
 *if no middle exists return -1, else return the idnex.
 */
Int checkMiddle(vertexArray* chain, Int begin, Int end, 
        Real vup, Real vbelow)
{
  Int i;
  for(i=begin; i<=end; i++)
    {
      if(chain->getVertex(i)[1] < vup && chain->getVertex(i)[1]>vbelow)
    return i;
    }
  return -1;
}
  
/*the degenerat case of sampleLeftOneGridStep*/
void sampleLeftOneGridStepNoMiddle(vertexArray* leftChain,
                   Int beginLeftIndex,
                   Int endLeftIndex,
                   gridBoundaryChain* leftGridChain,
                   Int leftGridChainStartIndex,
                   primStream* pStream)
{
  /*since there is no middle, there is at most one point which is on the 
   *second grid line, there could be multiple points on the first (top)
   *grid line.
   */
 
  leftGridChain->leftEndFan(leftGridChainStartIndex+1, pStream);
 
  monoTriangulation2(leftGridChain->get_vertex(leftGridChainStartIndex),
             leftGridChain->get_vertex(leftGridChainStartIndex+1),
             leftChain,
             beginLeftIndex,
             endLeftIndex,
             1, //is increase chain.
             pStream);
}
 
 
 
/*sampling the left area in between two grid lines.
 */
void sampleLeftOneGridStep(vertexArray* leftChain,
          Int beginLeftIndex,
          Int endLeftIndex,
          gridBoundaryChain* leftGridChain,
          Int leftGridChainStartIndex,
          primStream* pStream
          )
{
  if(checkMiddle(leftChain, beginLeftIndex, endLeftIndex, 
         leftGridChain->get_v_value(leftGridChainStartIndex),
         leftGridChain->get_v_value(leftGridChainStartIndex+1))<0)
    
    {
      
      sampleLeftOneGridStepNoMiddle(leftChain, beginLeftIndex, endLeftIndex, leftGridChain, leftGridChainStartIndex, pStream);
      return;
    }
  
  //copy into a polygon
  {
    directedLine* poly = NULL;
    sampledLine* sline;
    directedLine* dline;
    gridWrap* grid = leftGridChain->getGrid();
    Real vert1[2];
    Real vert2[2];
    Int i;
    
    Int innerInd = leftGridChain->getInnerIndex(leftGridChainStartIndex+1);
    Int upperInd = leftGridChain->getUlineIndex(leftGridChainStartIndex);
    Int lowerInd = leftGridChain->getUlineIndex(leftGridChainStartIndex+1);
    Real upperV = leftGridChain->get_v_value(leftGridChainStartIndex);
    Real lowerV = leftGridChain->get_v_value(leftGridChainStartIndex+1);
 
    //the upper gridline
    vert1[1] = vert2[1] = upperV;
    for(i=innerInd; i>upperInd; i--)
      {
    vert1[0]=grid->get_u_value(i);
    vert2[0]=grid->get_u_value(i-1);
    sline = new sampledLine(vert1, vert2);
    dline = new directedLine(INCREASING, sline);
    if(poly == NULL)
      poly = dline;
    else
      poly->insert(dline);
      }
 
    //the edge connecting upper grid with left chain
    vert1[0] = grid->get_u_value(upperInd);
    vert1[1] = upperV;
    sline = new sampledLine(vert1, leftChain->getVertex(beginLeftIndex));
    dline = new directedLine(INCREASING, sline);
    if(poly == NULL)
      poly = dline;
    else
      poly->insert(dline);    
 
    //the left chain
    for(i=beginLeftIndex; i<endLeftIndex; i++)
      {
    sline = new sampledLine(leftChain->getVertex(i), leftChain->getVertex(i+1));
    dline = new directedLine(INCREASING, sline);
    poly->insert(dline);
      }
 
    //the edge connecting left chain with lower gridline
    vert2[0] = grid->get_u_value(lowerInd);
    vert2[1] = lowerV;
    sline = new sampledLine(leftChain->getVertex(endLeftIndex), vert2);
    dline = new directedLine(INCREASING, sline);
    poly->insert(dline);
 
    //the lower grid line
    vert1[1] = vert2[1] = lowerV;
    for(i=lowerInd; i<innerInd; i++)
      {
    vert1[0] = grid->get_u_value(i);
    vert2[0] = grid->get_u_value(i+1);
    sline = new sampledLine(vert1, vert2);
    dline = new directedLine(INCREASING, sline);
    poly->insert(dline);       
      }
 
    //the vertical grid line segement
    vert1[0]=vert2[0] = grid->get_u_value(innerInd);
    vert2[1]=upperV;
    vert1[1]=lowerV;
    sline=new sampledLine(vert1, vert2);
    dline=new directedLine(INCREASING, sline);
    poly->insert(dline);
    monoTriangulationOpt(poly, pStream);
    //cleanup
    poly->deleteSinglePolygonWithSline();
    return;
  }
 
 
 
 
 
  Int i;
  if(1/*leftGridChain->getUlineIndex(leftGridChainStartIndex) >= 
     leftGridChain->getUlineIndex(leftGridChainStartIndex+1)*/
     ) /*the second grid line is beyond the first one to the left*/
    {
      /*find the maximal U-monotone chain 
       * of endLeftIndex, endLeftIndex-1, ..., 
       */
      i=endLeftIndex;
      Real prevU = leftChain->getVertex(i)[0];
      for(i=endLeftIndex-1; i>=beginLeftIndex; i--){
    Real thisU = leftChain->getVertex(i)[0];
    if( prevU < thisU){
      prevU = thisU;
    }
    else 
      break;
      }
      /*from endLeftIndex to i+1 is strictly U- monotone */
      /*if i+1==endLeftIndex and the vertex and leftchain is on the second gridline, then
       *we should use 2 vertices on the leftchain. If we only use one (endLeftIndex), then we
       *we would output degenerate triangles
       */
      if(i+1 == endLeftIndex && leftChain->getVertex(endLeftIndex)[1] == leftGridChain->get_v_value(1+leftGridChainStartIndex))
    i--;
 
      Int j = beginLeftIndex/*endLeftIndex*/+1;
 
 
      if(leftGridChain->getInnerIndex(leftGridChainStartIndex+1) > leftGridChain->getUlineIndex(leftGridChainStartIndex))
    {
      j = findIncreaseChainFromBegin(leftChain, beginLeftIndex, i+1/*endLeftIndex*/);
 
      Int temp = beginLeftIndex;
      /*now from begin to j-1 is strictly u-monotone*/
      /*if j-1 is on the first grid line, then we want to skip to the vertex which is strictly
       *below the grid line. This vertexmust exist since there is a 'corner turn' inbetween the two grid lines
       */
      if(j-1 == beginLeftIndex)
        {
          while(leftChain->getVertex(j-1)[1] == leftGridChain->get_v_value(leftGridChainStartIndex))
        j++;            
 
          Real vert[2];
          vert[0] = leftGridChain->get_u_value(leftGridChainStartIndex);
          vert[1] = leftGridChain->get_v_value(leftGridChainStartIndex);
 
          monoTriangulation2(
                 vert/*leftChain->getVertex(beginLeftIndex)*/,
                 leftChain->getVertex(j-1),
                 leftChain,
                 beginLeftIndex,
                 j-2,
                 1,
                 pStream //increase chain
                 );
                 
          temp = j-1;
        }
                 
      stripOfFanLeft(leftChain, j-1, temp/*beginLeftIndex*/, leftGridChain->getGrid(),
             leftGridChain->getVlineIndex(leftGridChainStartIndex),
             leftGridChain->getUlineIndex(leftGridChainStartIndex),
             leftGridChain->getInnerIndex(leftGridChainStartIndex+1),
             pStream,
             1 /*the grid line is above the trim line*/
             );
    }
      
      stripOfFanLeft(leftChain, endLeftIndex, i+1, leftGridChain->getGrid(), 
             leftGridChain->getVlineIndex(leftGridChainStartIndex+1),
             leftGridChain->getUlineIndex(leftGridChainStartIndex+1),
             leftGridChain->getInnerIndex(leftGridChainStartIndex+1),
             pStream,
             0 /*the grid line is below the trim lines*/
             );
      
      /*monotone triangulate the remaining left chain togther with the
       *two vertices on the two grid v-lines.
       */
      Real vert[2][2];
      vert[0][0]=vert[1][0] = leftGridChain->getInner_u_value(leftGridChainStartIndex+1);
      vert[0][1] = leftGridChain->get_v_value(leftGridChainStartIndex);      
      vert[1][1] = leftGridChain->get_v_value(leftGridChainStartIndex+1);
 
//      vertexArray right(vert, 2);
 
      monoTriangulation2(
             &vert[0][0], /*top vertex */
             &vert[1][0], /*bottom vertex*/
             leftChain, 
             /*beginLeftIndex*/j-1,
             i+1,
             1, /*an increasing chain*/
             pStream);
    }
  else /*the second one is shorter than the first one to the left*/
    {
      /*find the maximal U-monotone chain of beginLeftIndex, beginLeftIndex+1,...,
       */
      i=beginLeftIndex;
      Real prevU = leftChain->getVertex(i)[0];
      for(i=beginLeftIndex+1; i<=endLeftIndex; i++){
    Real thisU = leftChain->getVertex(i)[0];
 
    if(prevU < thisU){
      prevU = thisU;
    }
    else
      break;
      }
      /*from beginLeftIndex to i-1 is strictly U-monotone*/
 
 
      stripOfFanLeft(leftChain, i-1, beginLeftIndex, leftGridChain->getGrid(),
             leftGridChain->getVlineIndex(leftGridChainStartIndex),
             leftGridChain->getUlineIndex(leftGridChainStartIndex),
             leftGridChain->getUlineIndex(leftGridChainStartIndex+1),
             pStream,
                 1 /*the grid line is above the trim lines*/
             );
      /*monotone triangulate the remaining left chain together with the 
       *two vertices on the two grid v-lines.
       */
      Real vert[2][2];
      vert[0][0]=vert[1][0] = leftGridChain->get_u_value(leftGridChainStartIndex+1);
      vert[0][1] = leftGridChain->get_v_value(leftGridChainStartIndex);      
      vert[1][1] = leftGridChain->get_v_value(leftGridChainStartIndex+1);
 
      vertexArray right(vert, 2);
 
      monoTriangulation2(
             &vert[0][0], //top vertex 
             &vert[1][0], //bottom vertex
             leftChain, 
             i-1,
             endLeftIndex,
             1, /*an increase chain*/
             pStream);
 
    }
}
  
/*n_upper>=1
 *n_lower>=1
 */
void triangulateXYMono(Int n_upper, Real upperVerts[][2],
               Int n_lower, Real lowerVerts[][2],
               primStream* pStream)
{
  Int i,j,k,l;
  Real* leftMostV;
 
  assert(n_upper>=1 && n_lower>=1);
  if(upperVerts[0][0] <= lowerVerts[0][0])
    {
      i=1;
      j=0;
      leftMostV = upperVerts[0];
    }
  else
    {
      i=0;
      j=1;
      leftMostV = lowerVerts[0];
    }
  
  while(1)
    {
      if(i >= n_upper) /*case1: no more in upper*/
    {
 
      if(j<n_lower-1) /*at least two vertices in lower*/
        {
          pStream->begin();
          pStream->insert(leftMostV);
          while(j<n_lower){
        pStream->insert(lowerVerts[j]);
        j++;
          }
          pStream->end(PRIMITIVE_STREAM_FAN);
        }
 
      break;    
    }
      else if(j>= n_lower) /*case2: no more in lower*/
    {
 
      if(i<n_upper-1) /*at least two vertices in upper*/
        {
          pStream->begin();
          pStream->insert(leftMostV);
 
          for(k=n_upper-1; k>=i; k--)
        pStream->insert(upperVerts[k]);
 
          pStream->end(PRIMITIVE_STREAM_FAN);
        }
 
      break;
    }
      else /* case3: neither is empty, plus the leftMostV, there is at least one triangle to output*/
    {
 
      if(upperVerts[i][0] <= lowerVerts[j][0])
        {
          pStream->begin();
          pStream->insert(lowerVerts[j]); /*the origin of this fan*/
 
          /*find the last k>=i such that 
           *upperverts[k][0] <= lowerverts[j][0]
           */
          k=i;
          while(k<n_upper)
        {
          if(upperVerts[k][0] > lowerVerts[j][0])
            break;
          k++;
        }
          k--;
          for(l=k; l>=i; l--)/*the reverse is for two-face lighting*/
        {
          pStream->insert(upperVerts[l]);
        }
          pStream->insert(leftMostV);
 
          pStream->end(PRIMITIVE_STREAM_FAN);
          //update i for next loop
          i = k+1;
          leftMostV = upperVerts[k];
 
        }
      else /*upperVerts[i][0] > lowerVerts[j][0]*/
        {
          pStream->begin();
          pStream->insert(upperVerts[i]);/*the origion of this fan*/
          pStream->insert(leftMostV);
          /*find the last k>=j such that
           *lowerverts[k][0] < upperverts[i][0]*/
          k=j;
          while(k< n_lower)
        {
          if(lowerVerts[k][0] >= upperVerts[i][0])
            break;
          pStream->insert(lowerVerts[k]);
          k++;
        }
          pStream->end(PRIMITIVE_STREAM_FAN);
          j=k;
          leftMostV = lowerVerts[j-1];
        }     
    }
    }
}
               
 
void stripOfFanLeft(vertexArray* leftChain, 
            Int largeIndex,
            Int smallIndex,
            gridWrap* grid,
            Int vlineIndex,
            Int ulineSmallIndex,
            Int ulineLargeIndex,
            primStream* pStream,
            Int gridLineUp /*1 if the grid line is above the trim lines*/
             )
{
  assert(largeIndex >= smallIndex);
 
  Real grid_v_value;
  grid_v_value = grid->get_v_value(vlineIndex);
 
  Real2* trimVerts=(Real2*) malloc(sizeof(Real2)* (largeIndex-smallIndex+1));
  assert(trimVerts);
 
 
  Real2* gridVerts=(Real2*) malloc(sizeof(Real2)* (ulineLargeIndex-ulineSmallIndex+1));
  assert(gridVerts);
 
  Int k,i;
  if(gridLineUp) /*trim line is below grid line, so trim vertices are going right when index increases*/
    for(k=0, i=smallIndex; i<=largeIndex; i++, k++)
      {
      trimVerts[k][0] = leftChain->getVertex(i)[0];
      trimVerts[k][1] = leftChain->getVertex(i)[1];
    }
  else
    for(k=0, i=largeIndex; i>=smallIndex; i--, k++)
      {
    trimVerts[k][0] = leftChain->getVertex(i)[0];
    trimVerts[k][1] = leftChain->getVertex(i)[1];
      }
 
  for(k=0, i=ulineSmallIndex; i<= ulineLargeIndex; i++, k++)
    {
      gridVerts[k][0] = grid->get_u_value(i);
      gridVerts[k][1] = grid_v_value;
    }
 
  if(gridLineUp)
    triangulateXYMono(
              ulineLargeIndex-ulineSmallIndex+1, gridVerts,
              largeIndex-smallIndex+1, trimVerts,
              pStream);
  else
    triangulateXYMono(largeIndex-smallIndex+1, trimVerts,
              ulineLargeIndex-ulineSmallIndex+1, gridVerts,
              pStream);
  free(trimVerts);
  free(gridVerts);
}