Make Raws From a Greed (Generic)

MakeRawsFromGreed.swift

public protocol TwoDimensional {
    associatedtype Measure: SignedNumeric, Comparable
    var xmesure: Measure { get set }
    var ymesure: Measure { get set }
}
 
/// * (0,3)(1,3)(2,3)(3,3)
/// * (0,2)(1,2)(2,2)(3,2)  
/// * (0,1)(1,1)(2,1)(3,1)
/// * (0,0)(1,0)(2,0)(3,0) -> (0,0)(1,0)(2,0)(3,0), (0,1)(1,1)(2,1)(3,1) ...
 
public func makeRawsFromGreed<C: Collection>(collection: C) -> [C.SubSequence]?
    where
    C.Element: TwoDimensional,
    C.Element: Equatable,
    C.SubSequence: RangeReplaceableCollection {
        guard collection.count > 1 else { return nil }
        let first = collection.first!
        var previousY = first.ymesure
        var corners = [C.Element]()
       
        for item in collection {
            let currentY = item.ymesure
            if currentY > previousY {
                corners.append(item)
            }
            previousY = currentY
        }
       
        guard corners.count > 1 else { return nil }
       
        var rest: C.SubSequence?
        var bunches = [C.SubSequence]()
       
        for corner in corners {
           
            let innersplit: [C.SubSequence]
           
            if let rest = rest {
                innersplit = rest.split(separator: corner, maxSplits: 1)
            } else {
                innersplit = collection.split(separator: corner, maxSplits: 1)
            }
           
            let bunch = innersplit.first!
 
            bunches.append(bunch)
            rest = innersplit.last!
        }
        if let rest = rest {
            bunches.append(rest)
        }
       
        var cornersiterator = corners.makeIterator()
        var outbunches = [C.SubSequence]()
        for bunch in bunches.dropFirst() {
            var workbunch = bunch
            if let nextcorner = cornersiterator.next() {
                workbunch.insert(nextcorner, at: bunch.startIndex)
            }
            outbunches.append(workbunch)
        }
       
        outbunches.insert(bunches.first!, at: outbunches.startIndex)
       
        return outbunches
}
 
// Testing
 
struct Greeding {
    func test() {
       
        var vectors = [Vector2D]()
        vectors.append(Vector2D(x: 0, y: 0))
        vectors.append(Vector2D(x: 1, y: 0))
        vectors.append(Vector2D(x: 2, y: 0))
        vectors.append(Vector2D(x: 3, y: 0))
       
        vectors.append(Vector2D(x: 0, y: 1))
        vectors.append(Vector2D(x: 1, y: 1))
        vectors.append(Vector2D(x: 2, y: 1))
        vectors.append(Vector2D(x: 3, y: 1))
       
        vectors.append(Vector2D(x: 0, y: 2))
        vectors.append(Vector2D(x: 1, y: 2))
        vectors.append(Vector2D(x: 2, y: 2))
        vectors.append(Vector2D(x: 3, y: 2))
       
        vectors.append(Vector2D(x: 0, y: 3))
        vectors.append(Vector2D(x: 1, y: 3))
        vectors.append(Vector2D(x: 2, y: 3))
        vectors.append(Vector2D(x: 3, y: 3))
       
        guard let raws = makeRawsFromGreed(collection: vectors) else { return }
        raws.forEach { print("raw: \($0)") }
       
    }
}
 
raw: [[x: 0.0, y: 0.0], [x: 1.0, y: 0.0], [x: 2.0, y: 0.0], [x: 3.0, y: 0.0]]
raw: [[x: 0.0, y: 1.0], [x: 1.0, y: 1.0], [x: 2.0, y: 1.0], [x: 3.0, y: 1.0]]
raw: [[x: 0.0, y: 2.0], [x: 1.0, y: 2.0], [x: 2.0, y: 2.0], [x: 3.0, y: 2.0]]
raw: [[x: 0.0, y: 3.0], [x: 1.0, y: 3.0], [x: 2.0, y: 3.0], [x: 3.0, y: 3.0]]