sampleCompRight.cc [plain text]
#include <stdlib.h>
#include <stdio.h>
#include "gluos.h"
#include "glimports.h"
#include "zlassert.h"
#include "sampleCompRight.h"
#define max(a,b) ((a>b)? a:b)
#define min(a,b) ((a>b)? b:a)
#ifdef NOT_TAKEOUT
void sampleCompRight(Real* topVertex, Real* botVertex,
vertexArray* leftChain,
Int leftStartIndex, Int leftEndIndex,
vertexArray* rightChain,
Int rightStartIndex, Int rightEndIndex,
gridBoundaryChain* rightGridChain,
Int gridIndex1, Int gridIndex2,
Int up_rightCornerWhere,
Int up_rightCornerIndex,
Int down_rightCornerWhere,
Int down_rightCornerIndex,
primStream* pStream)
{
Int midIndex1;
Int midIndex2;
Int gridMidIndex1 = 0, gridMidIndex2 = 0;
midIndex1 = rightChain->findIndexBelowGen(rightGridChain->get_v_value(gridIndex1),
rightStartIndex,
rightEndIndex);
midIndex2 = -1; if(midIndex1 <= rightEndIndex && gridIndex1 < gridIndex2)
if(rightChain->getVertex(midIndex1)[1] >= rightGridChain->get_v_value(gridIndex2))
{
midIndex2 = rightChain->findIndexAboveGen(rightGridChain->get_v_value(gridIndex2),
midIndex1, rightEndIndex);
{
Real temp = rightChain->getVertex(midIndex1)[1];
if(rightGridChain->get_v_value(gridIndex1) == temp)
gridMidIndex1 = gridIndex1;
else
{
gridMidIndex1 = gridIndex1;
while(rightGridChain->get_v_value(gridMidIndex1) > temp)
gridMidIndex1++;
gridMidIndex1--;
}
} {
Real temp = rightChain->getVertex(midIndex2)[1];
for(gridMidIndex2 = gridMidIndex1+1; gridMidIndex2 <= gridIndex2; gridMidIndex2++)
if(rightGridChain->get_v_value(gridMidIndex2) <= temp)
break;
assert(gridMidIndex2 <= gridIndex2);
} }
Real* cornerTop;
Real* cornerBot;
Int cornerRightStart;
Int cornerRightEnd;
Int cornerLeftUpEnd;
Int cornerLeftDownStart;
if(up_rightCornerWhere == 2) {
cornerTop = rightChain->getVertex(up_rightCornerIndex);
cornerRightStart = up_rightCornerIndex+1;
cornerLeftUpEnd = -1; }
else if(up_rightCornerWhere == 1) {
cornerTop = topVertex;
cornerRightStart = rightStartIndex;
cornerLeftUpEnd = -1; }
else {
cornerTop = topVertex;
cornerRightStart = rightStartIndex;
cornerLeftUpEnd = up_rightCornerIndex;
}
if(down_rightCornerWhere == 2) {
cornerBot = rightChain->getVertex(down_rightCornerIndex);
cornerRightEnd = down_rightCornerIndex-1;
cornerLeftDownStart = leftEndIndex+1; }
else if (down_rightCornerWhere == 1) {
cornerBot = botVertex;
cornerRightEnd = rightEndIndex;
cornerLeftDownStart = leftEndIndex+1; }
else {
cornerBot = botVertex;
cornerRightEnd = rightEndIndex;
cornerLeftDownStart = down_rightCornerIndex;
}
if(midIndex2 >= 0) {
sampleRightSingleTrimEdgeRegionGen(cornerTop, rightChain->getVertex(midIndex1),
rightChain,
cornerRightStart,
midIndex1-1,
rightGridChain,
gridIndex1,
gridMidIndex1,
leftChain,
leftStartIndex,
cornerLeftUpEnd,
0, -1,
pStream);
sampleRightSingleTrimEdgeRegionGen(rightChain->getVertex(midIndex2),
cornerBot,
rightChain,
midIndex2+1,
cornerRightEnd,
rightGridChain,
gridMidIndex2,
gridIndex2,
leftChain,
0, -1,
cornerLeftDownStart,
leftEndIndex,
pStream);
sampleRightStripRecF(rightChain,
midIndex1,
midIndex2,
rightGridChain,
gridMidIndex1,
gridMidIndex2,
pStream);
}
else
{
sampleRightSingleTrimEdgeRegionGen(cornerTop, cornerBot,
rightChain,
cornerRightStart,
cornerRightEnd,
rightGridChain,
gridIndex1,
gridIndex2,
leftChain,
leftStartIndex,
cornerLeftUpEnd,
cornerLeftDownStart,
leftEndIndex,
pStream);
}
}
void sampleRightSingleTrimEdgeRegionGen(Real topVertex[2], Real botVertex[2],
vertexArray* rightChain,
Int rightStart,
Int rightEnd,
gridBoundaryChain* gridChain,
Int gridBeginIndex,
Int gridEndIndex,
vertexArray* leftChain,
Int leftUpBegin,
Int leftUpEnd,
Int leftDownBegin,
Int leftDownEnd,
primStream* pStream)
{
Int i,k;
vertexArray vArray(gridEndIndex-gridBeginIndex+1 +
max(0,leftUpEnd - leftUpBegin+1)+
max(0,leftDownEnd - leftDownBegin+1));
for(i=leftUpBegin; i<= leftUpEnd; i++)
vArray.appendVertex(leftChain->getVertex(i));
vArray.appendVertex(gridChain->get_vertex(gridBeginIndex));
for(k=1, i=gridBeginIndex+1; i<= gridEndIndex; i++, k++)
{
vArray.appendVertex(gridChain->get_vertex(i));
gridChain->rightEndFan(i, pStream);
}
for(i=leftDownBegin; i<= leftDownEnd; i++)
vArray.appendVertex(leftChain->getVertex(i));
monoTriangulationRecGen(topVertex, botVertex,
&vArray, 0, vArray.getNumElements()-1,
rightChain, rightStart, rightEnd,
pStream);
}
void sampleRightSingleTrimEdgeRegion(Real upperVert[2], Real lowerVert[2],
gridBoundaryChain* gridChain,
Int beginIndex,
Int endIndex,
primStream* pStream)
{
Int i,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));
gridChain->rightEndFan(i, pStream);
}
monoTriangulation2(upperVert, lowerVert, &vArray, 0, endIndex-beginIndex,
1, pStream);
}
void sampleRightStripRecF(vertexArray* rightChain,
Int topRightIndex,
Int botRightIndex,
gridBoundaryChain* rightGridChain,
Int rightGridChainStartIndex,
Int rightGridChainEndIndex,
primStream* pStream
)
{
if(topRightIndex > botRightIndex)
return;
if(rightGridChainStartIndex >= rightGridChainEndIndex)
return;
assert(rightChain->getVertex(topRightIndex)[1] <= rightGridChain->get_v_value(rightGridChainStartIndex) &&
rightChain->getVertex(botRightIndex)[1] >= rightGridChain->get_v_value(rightGridChainEndIndex));
Real secondGridChainV = rightGridChain->get_v_value(rightGridChainStartIndex+1);
Int index1 = topRightIndex;
while(rightChain->getVertex(index1)[1] >= secondGridChainV){
index1++;
if(index1 > botRightIndex)
break;
}
index1--;
sampleRightOneGridStep(rightChain, topRightIndex, index1, rightGridChain, rightGridChainStartIndex, pStream);
if(rightChain->getVertex(index1)[1] == secondGridChainV)
{
sampleRightStripRecF(rightChain, index1, botRightIndex, rightGridChain, rightGridChainStartIndex+1, rightGridChainEndIndex, pStream);
}
else if(index1 < botRightIndex)
{
Real *uppervert, *lowervert;
uppervert = rightChain->getVertex(index1);
lowervert = rightChain->getVertex(index1+1); Int index2 = rightGridChainStartIndex+1;
while(rightGridChain->get_v_value(index2) > lowervert[1])
{
index2++;
if(index2 > rightGridChainEndIndex)
break;
}
index2--;
sampleRightSingleTrimEdgeRegion(uppervert, lowervert, rightGridChain, rightGridChainStartIndex+1, index2, pStream);
sampleRightStripRecF(rightChain, index1+1, botRightIndex, rightGridChain, index2, rightGridChainEndIndex, pStream);
}
}
void sampleRightOneGridStepNoMiddle(vertexArray* rightChain,
Int beginRightIndex,
Int endRightIndex,
gridBoundaryChain* rightGridChain,
Int rightGridChainStartIndex,
primStream* pStream)
{
rightGridChain->rightEndFan(rightGridChainStartIndex+1, pStream);
monoTriangulation2(rightGridChain->get_vertex(rightGridChainStartIndex),
rightGridChain->get_vertex(rightGridChainStartIndex+1),
rightChain,
beginRightIndex,
endRightIndex,
0, pStream);
}
void sampleRightOneGridStep(vertexArray* rightChain,
Int beginRightIndex,
Int endRightIndex,
gridBoundaryChain* rightGridChain,
Int rightGridChainStartIndex,
primStream* pStream)
{
if(checkMiddle(rightChain, beginRightIndex, endRightIndex,
rightGridChain->get_v_value(rightGridChainStartIndex),
rightGridChain->get_v_value(rightGridChainStartIndex+1))<0)
{
sampleRightOneGridStepNoMiddle(rightChain, beginRightIndex, endRightIndex, rightGridChain, rightGridChainStartIndex, pStream);
return;
}
{
directedLine* poly = NULL;
sampledLine* sline;
directedLine* dline;
gridWrap* grid = rightGridChain->getGrid();
float vert1[2];
float vert2[2];
Int i;
Int innerInd = rightGridChain->getInnerIndex(rightGridChainStartIndex+1);
Int upperInd = rightGridChain->getUlineIndex(rightGridChainStartIndex);
Int lowerInd = rightGridChain->getUlineIndex(rightGridChainStartIndex+1);
Real upperV = rightGridChain->get_v_value(rightGridChainStartIndex);
Real lowerV = rightGridChain->get_v_value(rightGridChainStartIndex+1);
vert1[1]=vert2[1]=upperV;
for(i=upperInd;
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);
if(poly == NULL)
poly = dline;
else
poly->insert(dline);
}
vert1[0]=vert2[0] = grid->get_u_value(innerInd);
vert1[1]=upperV;
vert2[1]=lowerV;
sline=new sampledLine(vert1, vert2);
dline=new directedLine(INCREASING, sline);
if(poly == NULL)
poly = dline;
else
poly->insert(dline);
vert1[1]=vert2[1]=lowerV;
for(i=innerInd; i<lowerInd; 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);
}
vert1[0]=grid->get_u_value(lowerInd);
sline = new sampledLine(vert1, rightChain->getVertex(endRightIndex));
dline = new directedLine(INCREASING, sline);
poly->insert(dline);
for(i=endRightIndex; i>beginRightIndex; i--)
{
sline = new sampledLine(rightChain->getVertex(i), rightChain->getVertex(i-1));
dline = new directedLine(INCREASING, sline);
poly->insert(dline);
}
vert2[1]=upperV;
vert2[0]=grid->get_u_value(upperInd);
sline = new sampledLine(rightChain->getVertex(beginRightIndex), vert2);
dline = new directedLine(INCREASING, sline);
poly->insert(dline);
monoTriangulationOpt(poly, pStream);
poly->deleteSinglePolygonWithSline();
return;
}
Int i;
i=beginRightIndex;
Real prevU = rightChain->getVertex(i)[0];
for(i=beginRightIndex+1; i<= endRightIndex; i++){
Real thisU = rightChain->getVertex(i)[0];
if(thisU < prevU)
prevU = thisU;
else
break;
}
if(i-1 == beginRightIndex && rightChain->getVertex(beginRightIndex)[1] == rightGridChain->get_v_value(rightGridChainStartIndex))
i++;
Int j = endRightIndex -1;
if(rightGridChain->getInnerIndex(rightGridChainStartIndex+1) < rightGridChain->getUlineIndex(rightGridChainStartIndex+1))
{
j = rightChain->findDecreaseChainFromEnd(i-1, endRightIndex);
Int temp = endRightIndex;
if(j+1 == endRightIndex)
{
while(rightChain->getVertex(j+1)[1] == rightGridChain->get_v_value(rightGridChainStartIndex+1))
j--;
monoTriangulation2(rightChain->getVertex(j+1),
rightGridChain->get_vertex(rightGridChainStartIndex+1),
rightChain,
j+2,
endRightIndex,
0, pStream);
temp = j+1;
}
stripOfFanRight(rightChain, temp, j+1, rightGridChain->getGrid(),
rightGridChain->getVlineIndex(rightGridChainStartIndex+1),
rightGridChain->getInnerIndex(rightGridChainStartIndex+1),
rightGridChain->getUlineIndex(rightGridChainStartIndex+1),
pStream,
0 );
}
stripOfFanRight(rightChain, i-1, beginRightIndex, rightGridChain->getGrid(),
rightGridChain->getVlineIndex(rightGridChainStartIndex),
rightGridChain->getInnerIndex(rightGridChainStartIndex+1),
rightGridChain->getUlineIndex(rightGridChainStartIndex),
pStream,
1 );
Real vert[2][2];
vert[0][0] = vert[1][0] = rightGridChain->getInner_u_value(rightGridChainStartIndex+1);
vert[0][1] = rightGridChain->get_v_value(rightGridChainStartIndex);
vert[1][1] = rightGridChain->get_v_value(rightGridChainStartIndex+1);
monoTriangulation2(&vert[0][0],
&vert[1][0],
rightChain,
i-1,
j+1,
0, pStream);
}
#endif
void stripOfFanRight(vertexArray* rightChain,
Int largeIndex,
Int smallIndex,
gridWrap* grid,
Int vlineIndex,
Int ulineSmallIndex,
Int ulineLargeIndex,
primStream* pStream,
Int gridLineUp
)
{
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)
for(k=0, i=smallIndex; i<=largeIndex; i++, k++)
{
trimVerts[k][0] = rightChain->getVertex(i)[0];
trimVerts[k][1] = rightChain->getVertex(i)[1];
}
else
for(k=0, i=largeIndex; i>=smallIndex; i--, k++)
{
trimVerts[k][0] = rightChain->getVertex(i)[0];
trimVerts[k][1] = rightChain->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);
}