public static List <Vertices> convexPartition(Vertices vertices, TriangulationAlgorithm algorithm, bool discardAndFixInvalid = true, float tolerance = 0.001f)
        {
            if (vertices.Count <= 3)
            {
                return new List <Vertices> {
                           vertices
                }
            }
            ;

            List <Vertices> results = null;

            switch (algorithm)
            {
            case TriangulationAlgorithm.Earclip:
                if (Settings.skipSanityChecks)
                {
                    Debug.Assert(!vertices.isCounterClockWise(), "The Earclip algorithm expects the polygon to be clockwise.");
                    results = EarclipDecomposer.convexPartition(vertices, tolerance);
                }
                else
                {
                    if (vertices.isCounterClockWise())
                    {
                        var temp = new Vertices(vertices);
                        temp.Reverse();
                        results = EarclipDecomposer.convexPartition(temp, tolerance);
                    }
                    else
                    {
                        results = EarclipDecomposer.convexPartition(vertices, tolerance);
                    }
                }
                break;

            case TriangulationAlgorithm.Bayazit:
                if (Settings.skipSanityChecks)
                {
                    Debug.Assert(vertices.isCounterClockWise(), "The polygon is not counter clockwise. This is needed for Bayazit to work correctly.");
                    results = BayazitDecomposer.ConvexPartition(vertices);
                }
                else
                {
                    if (!vertices.isCounterClockWise())
                    {
                        var temp = new Vertices(vertices);
                        temp.Reverse();
                        results = BayazitDecomposer.ConvexPartition(temp);
                    }
                    else
                    {
                        results = BayazitDecomposer.ConvexPartition(vertices);
                    }
                }
                break;

            case TriangulationAlgorithm.Flipcode:
                if (Settings.skipSanityChecks)
                {
                    Debug.Assert(vertices.isCounterClockWise(), "The polygon is not counter clockwise. This is needed for Bayazit to work correctly.");
                    results = FlipcodeDecomposer.ConvexPartition(vertices);
                }
                else
                {
                    if (!vertices.isCounterClockWise())
                    {
                        var temp = new Vertices(vertices);
                        temp.Reverse();
                        results = FlipcodeDecomposer.ConvexPartition(temp);
                    }
                    else
                    {
                        results = FlipcodeDecomposer.ConvexPartition(vertices);
                    }
                }
                break;

            case TriangulationAlgorithm.Seidel:
                results = SeidelDecomposer.ConvexPartition(vertices, tolerance);
                break;

            case TriangulationAlgorithm.SeidelTrapezoids:
                results = SeidelDecomposer.ConvexPartitionTrapezoid(vertices, tolerance);
                break;

            case TriangulationAlgorithm.Delauny:
                results = CDTDecomposer.ConvexPartition(vertices);
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(algorithm));
            }

            if (discardAndFixInvalid)
            {
                for (int i = results.Count - 1; i >= 0; i--)
                {
                    var polygon = results[i];

                    if (!validatePolygon(polygon))
                    {
                        results.RemoveAt(i);
                    }
                }
            }

            return(results);
        }