/*
* ConvertToBezierForm :
* Given a point and a Bezier curve, generate a 5th-degree
* Bezier-format equation whose solution finds the point on the
* curve nearest the user-defined point.
*/
QPointF *Measurement::ConvertToBezierForm(QPointF P,QPointF* V)
{
int i, j, k, m, n, ub, lb;
int row, column; /* Table indices */
QPointF c[DEGREE+1]; /* V(i)'s - P */
QPointF d[DEGREE]; /* V(i+1) - V(i) */
QPointF *w; /* Ctl pts of 5th-degree curve */
double cdTable[3][4]; /* Dot product of c, d */
double z[3][4] = { /* Precomputed "z" for cubics */
{1.0, 0.6, 0.3, 0.1},
{0.4, 0.6, 0.6, 0.4},
{0.1, 0.3, 0.6, 1.0},
};
/*Determine the c's -- these are vectors created by subtracting*/
/* point P from each of the control points */
for (i = 0; i <= DEGREE; i++) {
V2Sub(&V[i], &P, &c[i]);
}
/* Determine the d's -- these are vectors created by subtracting*/
/* each control point from the next */
for (i = 0; i <= DEGREE - 1; i++) {
d[i] = V2ScaleII(V2Sub(&V[i+1], &V[i], &d[i]), 3.0);
}
/* Create the c,d table -- this is a table of dot products of the */
/* c's and d's */
for (row = 0; row <= DEGREE - 1; row++) {
for (column = 0; column <= DEGREE; column++) {
cdTable[row][column] = V2Dot(&d[row], &c[column]);
}
}
/* Now, apply the z's to the dot products, on the skew diagonal*/
/* Also, set up the x-values, making these "points" */
w = (QPointF *)malloc((unsigned)(W_DEGREE+1) * sizeof(QPointF));
for (i = 0; i <= W_DEGREE; i++) {
w[i].ry() = 0.0;
w[i].rx() = (double)(i) / W_DEGREE;
}
n = DEGREE;
m = DEGREE-1;
for (k = 0; k <= n + m; k++) {
lb = MAX(0, k - m);
ub = MIN(k, n);
for (i = lb; i <= ub; i++) {
j = k - i;
w[i+j].ry() += cdTable[j][i] * z[j][i];
}
}
return (w);
}
/*
* GenerateBezier :
* Use least-squares method to find Bezier control points for region.
*
*/
static BezierCurve GenerateBezier(Point2 *d, int first, int last, double *uPrime,
Vector2 tHat1, Vector2 tHat2)
{
int i;
Vector2 A[MAXPOINTS][2]; /* Precomputed rhs for eqn */
int nPts; /* Number of pts in sub-curve */
double C[2][2]; /* Matrix C */
double X[2]; /* Matrix X */
double det_C0_C1, /* Determinants of matrices */
det_C0_X,
det_X_C1;
double alpha_l, /* Alpha values, left and right */
alpha_r;
Vector2 tmp; /* Utility variable */
BezierCurve bezCurve; /* RETURN bezier curve ctl pts */
bezCurve = (Point2 *)malloc(4 * sizeof(Point2));
nPts = last - first + 1;
/* Compute the A's */
for (i = 0; i < nPts; i++) {
Vector2 v1, v2;
v1 = tHat1;
v2 = tHat2;
V2Scale(&v1, B1(uPrime[i]));
V2Scale(&v2, B2(uPrime[i]));
A[i][0] = v1;
A[i][1] = v2;
}
/* Create the C and X matrices */
C[0][0] = 0.0;
C[0][1] = 0.0;
C[1][0] = 0.0;
C[1][1] = 0.0;
X[0] = 0.0;
X[1] = 0.0;
for (i = 0; i < nPts; i++) {
C[0][0] += V2Dot(&A[i][0], &A[i][0]);
C[0][1] += V2Dot(&A[i][0], &A[i][1]);
/* C[1][0] += V2Dot(&A[i][0], &A[i][1]);*/
C[1][0] = C[0][1];
C[1][1] += V2Dot(&A[i][1], &A[i][1]);
tmp = V2SubII(d[first + i],
V2AddII(
V2ScaleIII(d[first], B0(uPrime[i])),
V2AddII(
V2ScaleIII(d[first], B1(uPrime[i])),
V2AddII(
V2ScaleIII(d[last], B2(uPrime[i])),
V2ScaleIII(d[last], B3(uPrime[i]))))));
X[0] += V2Dot(&A[i][0], &tmp);
X[1] += V2Dot(&A[i][1], &tmp);
}
/* Compute the determinants of C and X */
det_C0_C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1];
det_C0_X = C[0][0] * X[1] - C[1][0] * X[0];
det_X_C1 = X[0] * C[1][1] - X[1] * C[0][1];
/* Finally, derive alpha values */
alpha_l = (det_C0_C1 < ZERO_TOLERANCE) ? 0.0 : det_X_C1 / det_C0_C1;
alpha_r = (det_C0_C1 < ZERO_TOLERANCE) ? 0.0 : det_C0_X / det_C0_C1;
/* If alpha negative, use the Wu/Barsky heuristic (see text) */
/* (if alpha is 0, you get coincident control points that lead to
* divide by zero in any subsequent NewtonRaphsonRootFind() call. */
double segLength = V2DistanceBetween2Points(&d[last], &d[first]);
double epsilon = 1.0e-6 * segLength;
if (alpha_l < epsilon || alpha_r < epsilon)
{
/* fall back on standard (probably inaccurate) formula, and subdivide further if needed. */
double dist = segLength / 3.0;
bezCurve[0] = d[first];
bezCurve[3] = d[last];
V2Add(&bezCurve[0], V2Scale(&tHat1, dist), &bezCurve[1]);
V2Add(&bezCurve[3], V2Scale(&tHat2, dist), &bezCurve[2]);
return (bezCurve);
}
/* First and last control points of the Bezier curve are */
/* positioned exactly at the first and last data points */
/* Control points 1 and 2 are positioned an alpha distance out */
/* on the tangent vectors, left and right, respectively */
bezCurve[0] = d[first];
bezCurve[3] = d[last];
V2Add(&bezCurve[0], V2Scale(&tHat1, alpha_l), &bezCurve[1]);
V2Add(&bezCurve[3], V2Scale(&tHat2, alpha_r), &bezCurve[2]);
return (bezCurve);
}
/*
* GenerateBezier :
* Use least-squares method to find Bezier control points for region.
*
*/
static BezierCurve GenerateBezier(
Point2 *d, /* Array of digitized points */
int first, int last, /* Indices defining region */
double *uPrime, /* Parameter values for region */
Vector2 tHat1, Vector2 tHat2) /* Unit tangents at endpoints */
{
int i;
// Vector2 A[MAXPOINTS][2]; /* Precomputed rhs for eqn */
int nPts; /* Number of pts in sub-curve */
double C[2][2]; /* Matrix C */
double X[2]; /* Matrix X */
double det_C0_C1, /* Determinants of matrices */
det_C0_X,
det_X_C1;
double alpha_l, /* Alpha values, left and right */
alpha_r;
Vector2 tmp; /* Utility variable */
BezierCurve bezCurve; /* RETURN bezier curve ctl pts */
bezCurve = (Point2 *)malloc(4 * sizeof(Point2));
nPts = last - first + 1;
Vector2 (*A)[2];
A = new Vector2[nPts][2]; /* Precomputed rhs for eqn */
/* Compute the A's */
for (i = 0; i < nPts; i++) {
Vector2 v1, v2;
v1 = tHat1;
v2 = tHat2;
V2Scale(&v1, B1(uPrime[i]));
V2Scale(&v2, B2(uPrime[i]));
A[i][0] = v1;
A[i][1] = v2;
}
/* Create the C and X matrices */
C[0][0] = 0.0;
C[0][1] = 0.0;
C[1][0] = 0.0;
C[1][1] = 0.0;
X[0] = 0.0;
X[1] = 0.0;
for (i = 0; i < nPts; i++) {
C[0][0] += V2Dot(&A[i][0], &A[i][0]);
C[0][1] += V2Dot(&A[i][0], &A[i][1]);
/* C[1][0] += V2Dot(&A[i][0], &A[i][1]);*/
C[1][0] = C[0][1];
C[1][1] += V2Dot(&A[i][1], &A[i][1]);
tmp = V2SubII(d[first + i],
V2AddII(
V2ScaleIII(d[first], B0(uPrime[i])),
V2AddII(
V2ScaleIII(d[first], B1(uPrime[i])),
V2AddII(
V2ScaleIII(d[last], B2(uPrime[i])),
V2ScaleIII(d[last], B3(uPrime[i]))))));
X[0] += V2Dot(&A[i][0], &tmp);
X[1] += V2Dot(&A[i][1], &tmp);
}
/* Compute the determinants of C and X */
det_C0_C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1];
det_C0_X = C[0][0] * X[1] - C[0][1] * X[0];
det_X_C1 = X[0] * C[1][1] - X[1] * C[0][1];
/* Finally, derive alpha values */
if (det_C0_C1 == 0.0) {
det_C0_C1 = (C[0][0] * C[1][1]) * 10e-12;
}
alpha_l = det_X_C1 / det_C0_C1;
alpha_r = det_C0_X / det_C0_C1;
/* If alpha negative, use the Wu/Barsky heuristic (see text) */
if (alpha_l < 0.0 || alpha_r < 0.0) {
double dist = V2DistanceBetween2Points(&d[last], &d[first]) /
3.0;
bezCurve[0] = d[first];
bezCurve[3] = d[last];
V2Add(&bezCurve[0], V2Scale(&tHat1, dist), &bezCurve[1]);
V2Add(&bezCurve[3], V2Scale(&tHat2, dist), &bezCurve[2]);
delete[] A;
return (bezCurve);
}
/* First and last control points of the Bezier curve are */
/* positioned exactly at the first and last data points */
/* Control points 1 and 2 are positioned an alpha distance out */
/* on the tangent vectors, left and right, respectively */
bezCurve[0] = d[first];
bezCurve[3] = d[last];
V2Add(&bezCurve[0], V2Scale(&tHat1, alpha_l), &bezCurve[1]);
V2Add(&bezCurve[3], V2Scale(&tHat2, alpha_r), &bezCurve[2]);
delete[] A;
return (bezCurve);
}
