mirror of
https://github.com/reactos/reactos.git
synced 2025-01-11 16:51:06 +00:00
c424146e2c
svn path=/branches/cmake-bringup/; revision=48236
2421 lines
70 KiB
C++
2421 lines
70 KiB
C++
/*
|
|
** 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.
|
|
**
|
|
** $Date$ $Revision: 1.1 $
|
|
*/
|
|
/*
|
|
** $Header: /cygdrive/c/RCVS/CVS/ReactOS/reactos/lib/glu32/libnurbs/nurbtess/sampleMonoPoly.cc,v 1.1 2004/02/02 16:39:15 navaraf Exp $
|
|
*/
|
|
|
|
#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 slop = 0.0f, 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 slop = 0.0f, 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);
|
|
}
|
|
|
|
|
|
|
|
|
|
|