ConvexHull | Javascript implementation of Andrew 's Monotone Chain | Learning library

For each corner (x_i, y_i) of the polygon solve quadratic equation for a_i.

y_i*a_i = (a_i^2 + 1)*x_i - 1

You can obtain the equation by putting the point coordinates into the line equation. Next, discard solutions that are not relevant for You (a<1). Once this is done, sort solutions by a. If you also need the index of corresponding vertex, sort function in Matlab gives you indexing array as an additional output. You can then plot the line.

As a corner case, the line may hit two vertices. This is not a problem if you just need a. If you want the vertex id, just discard one arbitrarily, or use some additional rule.

I modified your script a little:

As fmw42 suggested, you need to restrict the problem more. There are way too many variables to build a "works under all circumstances" solution. A possible, very basic, solution would be to try and get the convex hull of the page.

Another, more robust approach, would be to search for the four vertices of the corners and extrapolate lines to approximate the paper edges. That way you don't need perfect, clean edges, because you would reconstruct them using the four (maybe even three) corners.

To find the vertices you can run Hough Line detector or a Corner Detector on the edges and get at least four discernible clusters of end/starting points. From that you can average the four clusters to get a pair of (x, y) points per corner and extrapolate lines using those points.

That solution would be hypothetical and pretty laborious for a Stack Overflow question, so let me try the first proposal - detection via convex hull. Here are the steps:

1. Threshold the input image
2. Get edges from the input
3. Get the external contours of the edges using a minimum area filter
4. Get the convex hull of the filtered image
5. Get the corners of the convex hull

Let's see the code:

With few modifications on your code, this should work:

Some sample code for you:

In comparing these two approaches, both use a least squares approach but ellipsoid_fit_LS is assuming that the major axes of the ellipse align with (x, y, z) whereas the matlab knock-offs don't make this assumption. That is, they are more general and will produce better fits for ellipsoids that are tilted relative to the coordinate axes but therefore have more parameters to fit.

Good but different fits to data are always like this, with similar but not identical results. In general, a good start is to choose a fitting algorithm that has the fewest free parameters as possible but is consistent with the data and your model.

You selected only a subset of the 81 landmarks dlib identifies on a face, and discarded the landmarks associated with the mouth, chin and the outer contour of the face.

You should do an additional selection leaving only the points at the boundary of the region you are interested in. Furthermore, you should order the selected points such that connecting them, in the right order, will form a polygon marking exactly the region you want to crop.

Once you have the polygon you can use this method to crop it:

• Use cv2.fillPoly() to draw mask from the polygon.
• Get only the cropped polygon portion of the mask from the image using cv2.bitwsie_and().
• Get the bounding rect of the cropped region using cv2.boundingRect().

I found a set of similar ALS algorithms here. One of these algorithms, asymmetrically reweighted penalized least squares smoothing (arpls), gives a slightly better fit than als.

I think you might need to draw them separately - basically: