private IEnumerator RunAlgorithm(List <MyVector2> points)
    {
        //The list with points on the convex hull
        List <MyVector2> pointsOnConvexHull = new List <MyVector2>();


        //Step 0. Normalize the data to range [0, 1] or everything will break at larger sizes :(
        //Make sure the data is already normalized!!!



        //Step 1. Find the vertex with the smallest x coordinate
        //If several points have the same x coordinate, find the one with the smallest y
        MyVector2 startPos = points[0];

        for (int i = 1; i < points.Count; i++)
        {
            MyVector2 testPos = points[i];

            //Because of precision issues, we use a small value to test if they are the same
            if (testPos.x < startPos.x || ((Mathf.Abs(testPos.x - startPos.x) < MathUtility.EPSILON && testPos.y < startPos.y)))
            {
                startPos = points[i];
            }
        }

        //This vertex is always on the convex hull
        pointsOnConvexHull.Add(startPos);


        //VISUALIZE
        ShowHull(pointsOnConvexHull, null);

        yield return(new WaitForSeconds(controller.pauseTime));


        //But we can't remove it from the list of all points because we need it to stop the algorithm
        //points.Remove(startPos);



        //Step 2. Loop to find the other points on the hull
        MyVector2 previousPoint = pointsOnConvexHull[0];

        int counter = 0;

        while (true)
        {
            //We might have colinear points, so we need a list to save all points added this iteration
            List <MyVector2> pointsToAddToTheHull = new List <MyVector2>();


            //Pick next point randomly
            MyVector2 nextPoint = points[Random.Range(0, points.Count)];

            //If we are coming from the first point on the convex hull
            //then we are not allowed to pick it as next point, so we have to try again
            if (previousPoint.Equals(pointsOnConvexHull[0]) && nextPoint.Equals(pointsOnConvexHull[0]))
            {
                counter += 1;

                continue;
            }


            //VISUALIZE
            ShowHull(pointsOnConvexHull, new List <MyVector2>()
            {
                nextPoint
            });
            //ShowActivePoint(nextPoint);

            yield return(new WaitForSeconds(controller.pauseTime));

            //This point is assumed to be on the convex hull
            pointsToAddToTheHull.Add(nextPoint);


            //But this randomly selected point might not be the best next point, so we have to see if we can improve
            //by finding a point that is more to the right
            //We also have to check if this point has colinear points if it happens to be on the hull
            for (int i = 0; i < points.Count; i++)
            {
                MyVector2 testPoint = points[i];

                //Dont test the point we picked randomly
                //Or the point we are coming from which might happen when we move from the first point on the hull
                if (testPoint.Equals(nextPoint) || testPoint.Equals(previousPoint))
                {
                    continue;
                }


                //VISUALIZE
                //ShowHull(pointsOnConvexHull, new List<MyVector2>() { testPoint });
                ShowActivePoint(testPoint);

                yield return(new WaitForSeconds(controller.pauseTime));


                //Where is the test point in relation to the line between the point we are coming from
                //which we know is on the hull, and the point we think is on the hull
                LeftOnRight pointRelation = _Geometry.IsPoint_Left_On_Right_OfVector(previousPoint, nextPoint, testPoint);

                //The test point is on the line, so we have found a colinear point
                if (pointRelation == LeftOnRight.On)
                {
                    pointsToAddToTheHull.Add(testPoint);
                }
                //To the right = better point, so pick it as next point we want to test if it is on the hull
                else if (pointRelation == LeftOnRight.Right)
                {
                    nextPoint = testPoint;

                    //Clear colinear points because they belonged to the old point which was worse
                    pointsToAddToTheHull.Clear();

                    pointsToAddToTheHull.Add(nextPoint);

                    //We dont have to start over because the previous points weve gone through were worse


                    //VISUALIZE
                    ShowHull(pointsOnConvexHull, pointsToAddToTheHull);

                    yield return(new WaitForSeconds(controller.pauseTime));
                }
                //To the left = worse point so do nothing
            }



            //Sort this list, so we can add the colinear points in correct order
            pointsToAddToTheHull = pointsToAddToTheHull.OrderBy(n => MyVector2.SqrMagnitude(n - previousPoint)).ToList();

            pointsOnConvexHull.AddRange(pointsToAddToTheHull);

            //Remove the points that are now on the convex hull, which should speed up the algorithm
            //Or will it be slower because it also takes some time to remove points?
            for (int i = 0; i < pointsToAddToTheHull.Count; i++)
            {
                points.Remove(pointsToAddToTheHull[i]);
            }


            //The point we are coming from in the next iteration
            previousPoint = pointsOnConvexHull[pointsOnConvexHull.Count - 1];


            //Have we found the first point on the hull? If so we have completed the hull
            if (previousPoint.Equals(pointsOnConvexHull[0]))
            {
                //Then remove it because it is the same as the first point, and we want a convex hull with no duplicates
                pointsOnConvexHull.RemoveAt(pointsOnConvexHull.Count - 1);

                //Stop the loop!
                break;
            }


            //Safety
            if (counter > 100000)
            {
                Debug.Log("Stuck in endless loop when generating convex hull with jarvis march");

                break;
            }

            counter += 1;
        }



        //Dont forget to unnormalize the points!

        //VISUALIZE
        ShowHull(pointsOnConvexHull, new List <MyVector2>()
        {
            pointsOnConvexHull[0]
        });

        yield return(null);
    }