int swapec ( int i, int *top, int *btri, int *bedg, int point_num, double point_xy[], int tri_num, int tri_vert[], int tri_nabe[], int stack[] )
{
int a;
int b;
int c;
int e;
int ee;
int em1;
int ep1;
int f;
int fm1;
int fp1;
int l;
int r;
int s;
int swap;
int t;
int tt;
int u;
double x;
double y;
//
// Determine whether triangles in stack are Delaunay, and swap
// diagonal edge of convex quadrilateral if not.
//
x = point_xy[2*(i-1)+0];
y = point_xy[2*(i-1)+1];
for ( ; ; )
{
if ( *top <= 0 )
{
break;
}
t = stack[(*top)-1];
*top = *top - 1;
if ( tri_vert[3*(t-1)+0] == i )
{
e = 2;
b = tri_vert[3*(t-1)+2];
}
else if ( tri_vert[3*(t-1)+1] == i )
{
e = 3;
b = tri_vert[3*(t-1)+0];
}
else
{
e = 1;
b = tri_vert[3*(t-1)+1];
}
a = tri_vert[3*(t-1)+e-1];
u = tri_nabe[3*(t-1)+e-1];
if ( tri_nabe[3*(u-1)+0] == t )
{
f = 1;
c = tri_vert[3*(u-1)+2];
}
else if ( tri_nabe[3*(u-1)+1] == t )
{
f = 2;
c = tri_vert[3*(u-1)+0];
}
else
{
f = 3;
c = tri_vert[3*(u-1)+1];
}
swap = diaedg ( x, y,
point_xy[2*(a-1)+0], point_xy[2*(a-1)+1],
point_xy[2*(c-1)+0], point_xy[2*(c-1)+1],
point_xy[2*(b-1)+0], point_xy[2*(b-1)+1] );
if ( swap == 1 )
{
em1 = i4_wrap ( e - 1, 1, 3 );
ep1 = i4_wrap ( e + 1, 1, 3 );
fm1 = i4_wrap ( f - 1, 1, 3 );
fp1 = i4_wrap ( f + 1, 1, 3 );
tri_vert[3*(t-1)+ep1-1] = c;
tri_vert[3*(u-1)+fp1-1] = i;
r = tri_nabe[3*(t-1)+ep1-1];
s = tri_nabe[3*(u-1)+fp1-1];
tri_nabe[3*(t-1)+ep1-1] = u;
tri_nabe[3*(u-1)+fp1-1] = t;
tri_nabe[3*(t-1)+e-1] = s;
tri_nabe[3*(u-1)+f-1] = r;
if ( 0 < tri_nabe[3*(u-1)+fm1-1] )
{
*top = *top + 1;
stack[(*top)-1] = u;
}
if ( 0 < s )
{
if ( tri_nabe[3*(s-1)+0] == u )
{
tri_nabe[3*(s-1)+0] = t;
}
else if ( tri_nabe[3*(s-1)+1] == u )
{
tri_nabe[3*(s-1)+1] = t;
}
else
{
tri_nabe[3*(s-1)+2] = t;
}
*top = *top + 1;
if ( point_num < *top )
{
return 8;
}
stack[(*top)-1] = t;
}
else
{
if ( u == *btri && fp1 == *bedg )
{
*btri = t;
*bedg = e;
}
l = - ( 3 * t + e - 1 );
tt = t;
ee = em1;
while ( 0 < tri_nabe[3*(tt-1)+ee-1] )
{
tt = tri_nabe[3*(tt-1)+ee-1];
if ( tri_vert[3*(tt-1)+0] == a )
{
ee = 3;
}
else if ( tri_vert[3*(tt-1)+1] == a )
{
ee = 1;
}
else
{
ee = 2;
}
}
tri_nabe[3*(tt-1)+ee-1] = l;
}
if ( 0 < r )
{
if ( tri_nabe[3*(r-1)+0] == t )
{
tri_nabe[3*(r-1)+0] = u;
}
else if ( tri_nabe[3*(r-1)+1] == t )
{
tri_nabe[3*(r-1)+1] = u;
}
else
{
tri_nabe[3*(r-1)+2] = u;
}
}
else
{
if ( t == *btri && ep1 == *bedg )
{
*btri = u;
*bedg = f;
}
l = - ( 3 * u + f - 1 );
tt = u;
ee = fm1;
while ( 0 < tri_nabe[3*(tt-1)+ee-1] )
{
tt = tri_nabe[3*(tt-1)+ee-1];
if ( tri_vert[3*(tt-1)+0] == b )
{
ee = 3;
}
else if ( tri_vert[3*(tt-1)+1] == b )
{
ee = 1;
}
else
{
ee = 2;
}
}
tri_nabe[3*(tt-1)+ee-1] = l;
}
}
}
return 0;
}
void test005 ( )
/******************************************************************************/
/*
Purpose:
TEST005 tests DIAEDG.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
23 October 2012
Author:
John Burkardt
*/
{
int node_num = 4;
int triangle_num = 2;
int triangle_order = 3;
double alpha_area;
double alpha_ave;
double alpha_min_swapped;
double alpha_min_unswapped;
double node_xy[2*4];
int seed = 123456789;
int swap;
int test;
int test_num = 10;
int triangle_node[3*2];
int value;
printf ( "\n" );
printf ( "TEST005\n" );
printf ( " DIAEDG determines whether two triangles\n" );
printf ( " with a common edge need to \"swap\" diagonals.\n" );
printf ( " If swapping is indicated, then ALPHA_MIN should increase.\n" );
printf ( "\n" );
printf ( " Swap ALPHA_MIN ALPHA_MIN\n" );
printf ( " Unswapped Swapped\n" );
printf ( "\n" );
for ( test = 1; test <= test_num; test++ )
{
/*
Generate a random quadrilateral (1,2,3,4).
*/
quad_convex_random ( &seed, node_xy );
/*
Does it need swapping?
*/
value = diaedg (
node_xy[0+0*2], node_xy[1+0*2],
node_xy[0+1*2], node_xy[1+1*2],
node_xy[0+2*2], node_xy[1+2*2],
node_xy[0+3*2], node_xy[1+3*2] );
if ( value == +1 )
{
swap = 0;
}
else
{
swap = 1;
}
/*
Compute ALPHA_MIN unswapped.
*/
triangle_node[0+0*3] = 1;
triangle_node[1+0*3] = 2;
triangle_node[2+0*3] = 3;
triangle_node[0+1*3] = 1;
triangle_node[1+1*3] = 3;
triangle_node[2+1*3] = 4;
alpha_measure ( node_num, node_xy, triangle_order, triangle_num,
triangle_node, &alpha_min_unswapped, &alpha_ave, &alpha_area );
/*
Compute ALPHA_MIN swapped.
*/
triangle_node[0+0*3] = 1;
triangle_node[1+0*3] = 2;
triangle_node[2+0*3] = 4;
triangle_node[0+1*3] = 2;
triangle_node[1+1*3] = 3;
triangle_node[2+1*3] = 4;
alpha_measure ( node_num, node_xy, triangle_order, triangle_num,
triangle_node, &alpha_min_swapped, &alpha_ave, &alpha_area );
if ( 0 )
{
r8mat_transpose_print ( 2, node_num, node_xy, " Quadrilateral" );
}
printf ( " %1d %10g %10g\n",
swap, alpha_min_unswapped, alpha_min_swapped );
}
return;
}
