Most likely the reason that all the algorithms out there did not satisfy your need, was simply because they are all probably designed to solve for all outer most points in infinite space and not finite space.

Anyway good job.

My algoruthm is called quick quick hull and it has max 8 vertices.
The thing you do is check for the right-most points, from that select the highest and lowest. Then check for bottom-most points, from that select the left-most and right most and so on. If they do not duplicate you’ll end up with max 8 points with a near perfect approximation for my needs.

What may be the best attempt at this, is to use the gift-wrapping algorithm. There are plenty of examples in C++ and C. Then to solve for 5 points (Dark Avenger is in the right direction.. sort of :P):

Supposing, you use an algorithm in which you can store all the found angles and total sum of angles in an array, find the 5 angles that are the least obtuse to more acute. In all cases, 3 will be desirable points. The exception is 2 or more points found with the exact same angle that satisfy the search. We’ll get to fixing that.

Store these points.

Two things can now be done. Using a simpler form of gift-wrapping, you could create a new convex hull based on the 5 points and omit and destroy all the extra points left over. Otherwise, it may be possible to blindly plot a line to the next neighbor that satisfies the search and plot a line, within the existing hull, then destroy the old lines and points.

In such a case that 2 or more satisfying points have the same angle, store all of the equal points along with the rest. Let’s say we have 6 points for simple sake. Create a new hull, based on the 6 lines. The best way to get rid of the 6th point would probably be distance to the neighbors on either sides. Measure the distance of both identical points to their neighbor points on either side. Destroy the identical point that has the shorter distance to its neighbor. Plot a new line, from the left over point to that neighbor.

If I should be able to scrape some more time together this week, I may finally be able to put up some code, pseudo-code or pseudo-pseudo code.

Basically what I have in mind is being able to find and plot the first line, then starting with that line, using a short block that loops with a single equation or short algorithm where n=angle of the 3rd point to the last line. Based on the angle of the last line compared, the program starts sweeping from 180 degrees and inward. So every time, the equation or code runs, it will plot a new line, solve for the next point and check for next greatest angle. A second function within that loop will run and calling on the array that holds the points and angles, checks the total sum of angles/number of points based on 180(n-2).

It’s still a blind way of finding all the points, but should run very quickly. The difficulty in the logic is that, if a new point is to be discovered by sweeping inward 180 and down, scanning parallel to the last line may still yield many points. Obviously the furthest point with the most obtuse angle toward the line is the desired point, however, it must still be possible to omit some points and areas within the equation without having to waste time finding them and ruling them out. This is where the logic is tricky, in order to do it in the shortest amount of time.

Anyway, bedtime. As always good luck and keep up the good work. Things are looking good.

http://www.pms.ifi.lmu.de/lehre/compgeometry/Gosper/convex_hull/convex_hull.html

Also , if necessary , here’s someone who’s pretty well-known to work on these kind of problems , if you’re really stuck on this talk to him http://www.ics.uci.edu/~eppstein/

Good luck Michal , I wanna play the game , do your best !