/* * FindRoots : * Given a 5th-degree equation in Bernstein-Bezier form, find * all of the roots in the interval [0, 1]. Return the number * of roots found. */ static int FindRoots( Geom::Point *w, /* The control points */ int degree, /* The degree of the polynomial */ double *t, /* RETURN candidate t-values */ int depth) /* The depth of the recursion */ { int i; Geom::Point Left[W_DEGREE+1], /* New left and right */ Right[W_DEGREE+1]; /* control polygons */ int left_count, /* Solution count from */ right_count; /* children */ double left_t[W_DEGREE+1], /* Solutions from kids */ right_t[W_DEGREE+1]; switch (CrossingCount(w, degree)) { case 0 : { /* No solutions here */ return 0; break; } case 1 : { /* Unique solution */ /* Stop recursion when the tree is deep enough */ /* if deep enough, return 1 solution at midpoint */ if (depth >= MAXDEPTH) { t[0] = (w[0][Geom::X] + w[W_DEGREE][Geom::X]) / 2.0; return 1; } if (ControlPolygonFlatEnough(w, degree)) { t[0] = ComputeXIntercept(w, degree); return 1; } break; } } /* Otherwise, solve recursively after */ /* subdividing control polygon */ Bez(w, degree, 0.5, Left, Right); left_count = FindRoots(Left, degree, left_t, depth+1); right_count = FindRoots(Right, degree, right_t, depth+1); /* Gather solutions together */ for (i = 0; i < left_count; i++) { t[i] = left_t[i]; } for (i = 0; i < right_count; i++) { t[i+left_count] = right_t[i]; } /* Send back total number of solutions */ return (left_count+right_count); }
/* * FindRoots : * Given a 5th-degree equation in Bernstein-Bezier form, find * all of the roots in the interval [0, 1]. Return the number * of roots found. */ int Measurement::FindRoots(QPointF* w, int degree,double *t,int depth) { int i; QPointF Left[W_DEGREE+1], /* New left and right */ Right[W_DEGREE+1]; /* control polygons */ int left_count, /* Solution count from */ right_count; /* children */ double left_t[W_DEGREE+1], /* Solutions from kids */ right_t[W_DEGREE+1]; switch (CrossingCount(w, degree)) { case 0 : { /* No solutions here */ return 0; } case 1 : { /* Unique solution */ /* Stop recursion when the tree is deep enough */ /* if deep enough, return 1 solution at midpoint */ if (depth >= MAXDEPTH) { t[0] = (w[0].rx() + w[W_DEGREE].rx()) / 2.0; return 1; } if (ControlPolygonFlatEnough(w, degree)) { t[0] = ComputeXIntercept(w, degree); return 1; } break; } } /* Otherwise, solve recursively after */ /* subdividing control polygon */ Bezier(w, degree, 0.5, Left, Right); left_count = FindRoots(Left, degree, left_t, depth+1); right_count = FindRoots(Right, degree, right_t, depth+1); /* Gather solutions together */ for (i = 0; i < left_count; i++) { t[i] = left_t[i]; } for (i = 0; i < right_count; i++) { t[i+left_count] = right_t[i]; } /* Send back total number of solutions */ return (left_count+right_count); }
// FindRoots : // Given a 5th-degree equation in Bernstein-Bezier form, find // all of the roots in the interval [0, 1]. Return the number // of roots found. // Parameters : // w: The control points // degree: The degree of the polynomial // t: output candidate t-values // depth: The depth of the recursion // static int FindRoots(const Point2d* w, int degree, float* t, int depth) { int i; Point2d Left[W_DEGREE+1]; // New left and right Point2d Right[W_DEGREE+1]; // control polygons int left_count; // Solution count from children int right_count; float left_t[W_DEGREE+1]; // Solutions from kids float right_t[W_DEGREE+1]; switch (CrossingCount(w, degree)) { case 0 : // No solutions here return 0; case 1 : // Unique solution // Stop recursion when the tree is deep enough // if deep enough, return 1 solution at midpoint if (depth >= MAXDEPTH) { t[0] = (w[0].x + w[W_DEGREE].x) / 2; return 1; } if (ControlPolygonFlatEnough(w, degree)) { t[0] = ComputeXIntercept(w, degree); return 1; } break; } // Otherwise, solve recursively after subdividing control polygon BezierPoint(w, degree, 0.5f, Left, Right); left_count = FindRoots(Left, degree, left_t, depth+1); right_count = FindRoots(Right, degree, right_t, depth+1); // Gather solutions together for (i = 0; i < left_count; i++) { t[i] = left_t[i]; } for (i = 0; i < right_count; i++) { t[i+left_count] = right_t[i]; } // Send back total number of solutions return (left_count+right_count); }