int longestedge(int t)
{
int LE;
int e;
double len;
double maxlen;
if (t==0)
{
return 0;
}
else
{
maxlen=0.0;
for (e=0; e<3; e++)
{
len = edgelen(t,e);
if (maxlen < len)
{
maxlen = len;
LE = e;
}
}
return LE;
}
}
void LEPPdivide(int t, int *NumDiv)
{
int t1;
int t2;
int t3;
int t4;
int e1[3];
int e2[3];
int P;
int i;
t1 = t;
e1[0] = longestedge(t1);
t2 = E[ 3*(t1-1)+e1[0] ];
e2[0] = longestedge(t2);
/* while (t2!=0 && E[ 3*(t2-1)+e2[0] ]!=t1) */
while (t2!=0 && edgelen(t1, e1[0])<edgelen(t2,e2[0]))
{
t1 = t2;
e1[0] = e2[0];
t2 = E[ 3*(t1-1)+e1[0] ];
e2[0] = longestedge(t2);
}
if (t2!=0 && edgelen(t1, e1[0])==edgelen(t2,e2[0]))
{
for (i=0; i<3; i++)
{
if (E[3*(t2-1)+i]==t1)
{
e2[0] = i;
break;
}
}
}
/* ************************************************************************************** */
/* At this point, the following should be true: */
/* */
/* (1) t2 = E[ 3*(t1-1)+e1[0] ]; i.e., t2 is the id of the triangle adjacent to */
/* the longest edge (e1[0] = 0, 1, or 2, whichever is longest) of the triangle */
/* with id t1; */
/* */
/* and */
/* */
/* (2) either: */
/* */
/* (a) t1 = E[ 3*(t2-1)+e2[0] ]; i.e, t1 is the triangle adjacent to the */
/* longest edge of t2 (t1 and t2 share a common longest edge) */
/* */
/* or */
/* */
/* (b) t2=0, i.e., the longest edge of t1 is along a boundary */
/* ************************************************************************************** */
if (t2==0)
{
printf("\n\n Dividing boundary triangle %d.\n", t1);
RefineList[t1-1]=-1;
}
else
{
printf("\n\n Dividing adjacent triangles %d and %d.\n", t1, t2);
RefineList[t1-1]=-1;
RefineList[t2-1]=-1;
}
for (i=1; i<3; i++)
{
if (e1[0]+i>2)
{
e1[i]=e1[0]+i-3;
}
else
{
e1[i]=e1[0]+i;
}
if (e2[0]+i>2)
{
e2[i]=e2[0]+i-3;
}
else
{
e2[i]=e2[0]+i;
}
}
/* insert P at middle of e1[0] */
X = realloc(X, 2*(NUMPTS+1)*sizeof(double));
NUMPTS++;
P = NUMPTS;
X[2*(P-1)+0] = (0.5)*( X[ 2*(V[ 3*(t1-1)+e1[0] ] - 1) ]
+X[ 2*(V[ 3*(t1-1)+e1[1] ] - 1) ] );
X[2*(P-1)+1] = (0.5)*( X[ 2*(V[ 3*(t1-1)+e1[0] ] - 1) + 1 ]
+X[ 2*(V[ 3*(t1-1)+e1[1] ] - 1) + 1 ] );
/* Add triangle t3 */
V = realloc(V, 3*(NUMTRI+1)*sizeof(int));
E = realloc(E, 3*(NUMTRI+1)*sizeof(int));
RefineList = realloc(RefineList, (NUMTRI+1)*sizeof(int));
NUMTRI++;
t3 = NUMTRI;
RefineList[t3-1]=-1;
printf("\n\n Creating triangle %d.\n", t3);
/* Connect vertices of t1 and t3 */
V[3*(t3-1)+0] = P;
V[3*(t3-1)+1] = V[ 3*(t1-1)+e1[1] ];
V[3*(t3-1)+2] = V[ 3*(t1-1)+e1[2] ];
V[3*(t1-1)+e1[1]] = P;
if (t2 == 0)
{
t4=0;
}
else
{
/* Add triangle t4 */
V = realloc(V, 3*(NUMTRI+1)*sizeof(int));
E = realloc(E, 3*(NUMTRI+1)*sizeof(int));
RefineList = realloc(RefineList, (NUMTRI+1)*sizeof(int));
NUMTRI++;
t4 = NUMTRI;
RefineList[t4-1]=-1;
printf("\n\n Creating triangle %d.\n", t4);
/* Connect vertices of t2 and t4 */
V[3*(t4-1)+0] = P;
V[3*(t4-1)+1] = V[ 3*(t2-1)+e2[1] ];
V[3*(t4-1)+2] = V[ 3*(t2-1)+e2[2] ];
V[3*(t2-1)+e2[1]] = P;
}
/* Fix adjacency for t1 and t3 */
E[3*(t3-1)+0] = t2;
E[3*(t3-1)+1] = E[3*(t1-1)+e1[1]];
E[3*(t3-1)+2] = t1;
E[3*(t1-1)+e1[0]] = t4;
E[3*(t1-1)+e1[1]] = t3;
if (t2!=0)
{
E[3*(t4-1)+0] = t1;
E[3*(t4-1)+1] = E[3*(t2-1)+e2[1]];
E[3*(t4-1)+2] = t2;
E[3*(t2-1)+e2[0]] = t3;
E[3*(t2-1)+e2[1]] = t4;
}
/* Fix adjacency for element that was adjacent to t1 and is now adjacent to t3
and for element that was adjacent to t2 and is now adjacent to t4 */
for (i=0; i<3; i++)
{
if ( E[3*( E[3*(t3-1)+1] - 1 ) + i] == t1 )
{
E[3*( E[3*(t3-1)+1] - 1 ) + i] = t3;
}
if (t2!=0)
{
if ( E[3*( E[3*(t4-1)+1] - 1 ) + i] == t2 )
{
E[3*( E[3*(t4-1)+1] - 1 ) + i] = t4;
}
}
}
if (t2==0)
{
*NumDiv++;
}
else
{
*NumDiv = *NumDiv + 2;
}
}
//==========================================================================
bool Path::estimateHoleInfo(vector<ftEdge*> edges, Point& centre,
Point& axis, double& radius)
//==========================================================================
{
centre.resize(edges[0]->geomCurve()->dimension());
centre.setValue(0.0);
// Select four points
// First make parameterization
vector<double> parval(edges.size()+1);
vector<double> edgelen(edges.size()+1);
parval[0] = 0.0;
edgelen[0] = 0.0;
size_t ki;
for (ki=0; ki<edges.size(); ++ki)
{
double tdel = edges[ki]->tMax() - edges[ki]->tMin();
double len = edges[ki]->estimatedCurveLength();
parval[ki+1] = parval[ki]+tdel;
edgelen[ki+1] = edgelen[ki] + len;
centre += edges[ki]->point(edges[ki]->tMin());
}
int nmb_vx = (int)edges.size();
if (edges[edges.size()-1]->next() != edges[0])
{
centre += edges[edges.size()-1]->point(edges[edges.size()-1]->tMax());
nmb_vx++;
}
centre /= nmb_vx;
vector<Point> pnt(4);
int kj;
//double tdel = (parval[parval.size()-1] - parval[0])/(double)4;
double del = (edgelen[edgelen.size()-1] - edgelen[0])/(double)4;
double tpar, len;
for (kj=0, len=edgelen[0]+0.5*del; kj<4; ++kj, len+=del)
{
for (ki=0; ki<edgelen.size()-1; ++ki)
if (len < edgelen[ki+1])
break;
double frac = (len - edgelen[ki])/(edgelen[ki+1] - edgelen[ki]);
tpar = parval[ki] + frac*(parval[ki+1]-parval[ki]);
pnt[kj] = edges[ki]->point(edges[ki]->tMin() + tpar - parval[ki]);
}
Point centre2 = 0.25*(pnt[0] + pnt[1] + pnt[2] + pnt[3]);
// std::ofstream of("hole_pts.g2");
// of << "400 1 0 4 0 155 100 255" << std::endl;
// of << pnt.size() << std::endl;
// for (ki=0; ki<pnt.size(); ++ki)
// of << pnt[ki] << std::endl;
// of << "400 1 0 4 255 0 0 255" << std::endl;
// of << "1" << std::endl;
// of << centre << std::endl;
// of << "400 1 0 4 0 255 0 255" << std::endl;
// of << "1" << std::endl;
// of << centre2 << std::endl;
centre = centre2;
//axis = (pnt[1] - pnt[0]).cross(pnt[3] - pnt[2]);
axis = (pnt[2] - pnt[0]).cross(pnt[3] - pnt[1]);
double axlen = axis.length();
double lentol = 1.0e-10;
if (axlen < lentol)
return false;
axis.normalize();
Point x1 = 0.5*(pnt[0] + pnt[1]);
Point x2 = 0.5*(pnt[1] + pnt[2]);
Point d1 = (pnt[1]-pnt[0]).cross(axis);
d1.normalize();
Point d2 = (pnt[2]-pnt[1]).cross(axis);
d2.normalize();
Point tmp1 = x1 + d1;
Point tmp2 = x2 + d2;
//double d1d2 = d1*d2;
//double tdiv = 1.0 - d1d2*d1d2;
//double t1 = (-x1*d1 + x2*d1 + d1d2*x1*d2 - d1d2*x2*d2)/tdiv;
//centre = x1 + t1*d1;
radius = (centre - pnt[0]).length();
// // Adjust radius relative to bounding box
// vector<Point> pos;
// pos.insert(pos.end(), pnt.begin(), pnt.end());
// for (ki=0; ki<edges.size(); ++ki)
// {
// pos.push_back(edges[ki]->point(edges[ki]->tMin()));
// pos.push_back(edges[ki]->point(edges[ki]->tMax()));
// }
// BoundingBox box;
// box.setFromPoints(pos);
// double len = box.high().dist(box.low());
// radius = std::min(radius, 0.5*len);
return true;
}
