Add Watcher

Author: Oleksandr Glagoliev

Sources/FortunesAlgorithm/Beachline.swift

@@ -298,31 +298,7 @@ extension Beachline {
     func updateSweeplineY(_ y: Double) {
         sweeplineY = y
     }
-    
-//    private func arcAbovePoint(_ p: Point) -> Arc {
-//        var x: Arc = root!
-//        var found = false
-//        while !found {
-//            assert(x.point != nil)
-//            let (l, r) = x.bounds(sweeplineY)
-//            if p.x < l {
-//                x = x.left!
-//            } else if p.x > r {
-//                x = x.right!
-//            }
-//            else if abs(p.x - l) < eps {
-//                x = x.prev!
-//                found = true
-//            } else if abs(p.x - r) < eps {
-//                found = true
-//            }
-//            else {
-//                found = true
-//            }
-//        }
-//        return x
-//    }
-    
+        
     func addAsLeftChild(_ x: Arc, _ y: Arc) {
         y.left = x
         x.parent = y

Sources/FortunesAlgorithm/Diagram.swift

@@ -49,13 +49,13 @@ public class Diagram {
         cells.removeAll()
         vertices.removeAll()
     }
-    
 }
 
 
 /// The vertex record of a vertex v stores the coordinates of v.
 /// It also stores a pointer IncidentEdge(v) to an arbitrary half‐edge that has v as its origin
 public typealias Vertex = Site
+public typealias Point = Site
 
 
 /// Stores pointer to:
@@ -79,7 +79,6 @@ public class Cell {
 
 public extension Cell {
 
-    
     /// Returns hell vertices of the cell
     func hullVerticesCCW() -> [Vertex] {
         var vertices: [Vertex] = []

Sources/FortunesAlgorithm/FortuneSweep.swift

@@ -27,20 +27,45 @@ public class FortuneSweep {
     /// Service Data Structures
     private var eventQueue: PriorityQueue<Event>!
     private var beachline: Beachline!
-    private var sweepLineY: Double = 0
+    private var sweepLineY: Double = 0 {
+        didSet {
+            watcher?.updateSweepline(y: sweepLineY)
+        }
+    }
     private var firstSiteY: Double?
 
-    private var container: Rectangle!
+    private var container: Rectangle! {
+        didSet {
+            watcher?.updateContainer(rectangle: container)
+        }
+    }
     private var clipper: Rectangle!
 
     /// Debug Data structures
     private var logger: FortuneSweepLogging?
-    private var currentStep: Int = 0
+    private var watcher: FortuneSweepProgressWatching?
+    private var currentStep: Int = 0 {
+        didSet {
+            watcher?.step = currentStep
+        }
+    }
     /// Result Data Structure
     private(set) var diagram: Diagram!
 
-    public init(logger: FortuneSweepLogging? = nil) {
-        self.logger = logger
+    
+    /// Initialises new FortuneSweep instance
+    /// NB: `logger` and especially `watcher` will affect performance!
+    /// Use them only for debug purposes!
+    ///
+    /// - Parameters:
+    ///   - logger: Optional. Calls `log` function when importand events happen
+    ///   - watcher: Optional. **Affects performance!** Tracks diagram building process. May be used for visualisation as it includes useful scaffolding.
+    public init(
+        logger: FortuneSweepLogging? = nil,
+        intermediate: FortuneSweepProgressWatching? = nil
+    ) {
+        self.logger = nil//logger
+        self.watcher = intermediate
     }
 
     public func compute(
@@ -50,12 +75,15 @@ public class FortuneSweep {
     ) {
         self.diagram = diagram
         self.clipper = clippingRect
-        let filtered = sites
-            .filter { clipper.contains($0) }
-            .map { Event(point: $0) }
-       
+        let filteredSites = sites.filter { clipper.contains($0) }
+            
+        let events = filteredSites.map { Event(point: $0) }
+        
+        /// Intermediate state
+        watcher?.prepare(sites: filteredSites, clipper: clippingRect)
+        
         /// Diagram is a whole plane. Do nothing
-        if filtered.isEmpty {
+        if events.isEmpty {
             logger?.log("Computation done. No sites inside defined area!", level: .info)
             return
         }
@@ -66,10 +94,10 @@ public class FortuneSweep {
 
         eventQueue = PriorityQueue(
             ascending: true,
-            startingValues: filtered
+            startingValues: events
         )
 
-        logger?.log("Computation started!", level: .info)
+        logger?.log("\n\nComputation started!", level: .info)
         var finished = false
         while !finished {
             step()
@@ -85,7 +113,7 @@ public class FortuneSweep {
     /// 2. Check the event type and process the event appropriately
     private func step() {
         currentStep += 1
-        logger?.log("Step: \(currentStep)", level: .info)
+        logger?.log("\nStep: \(currentStep)", level: .info)
 
         if let event = eventQueue.pop() {
             switch event.kind {
@@ -102,6 +130,7 @@ public class FortuneSweep {
     /// - Parameter event: **Site Event** to process
     private func processSiteEvent(_ event: Event) {
         logger?.log("Site Event: \(event.point)", level: .info)
+        watcher?.siteEvent(site: event.point)
 
         /// #Step 1:
         /// Update **Sweepline** position
@@ -125,6 +154,7 @@ public class FortuneSweep {
             /// Create new **Cell** record in **Voronoi Diagram**
             container.expandToContainPoint(event.point)
             diagram.createCell(root)
+            watcher?.createCell(cell: root.cell)
             return
         }
 
@@ -144,6 +174,7 @@ public class FortuneSweep {
 
             /// 1. Create new **Cell** record in **Voronoi Diagram**
             diagram.createCell(arc)
+            watcher?.createCell(cell: arc.cell)
 
             /// 2. Create proper *HalfEdge* records. Arc with the same *y* can only appear
             /// to the right of existing one as in case of *y* coordinate is shared they are sorted by *x*
@@ -172,8 +203,17 @@ public class FortuneSweep {
         /// Create new **Cell** record in **Voronoi Diagram**
         container.expandToContainPoint(event.point)
         diagram.createCell(newArc)
-        
-        
+        watcher?.createCell(cell: newArc.cell)
+        
+        /// Notify `intermediate` if needed
+        if let intermediate = self.watcher {
+            let parabola = Parabola(focus: newArc.prev!.point!, directrixY: sweepLineY)
+            let breakPoint = Point(
+                x: event.point.x,
+                y: parabola.resolve(x: event.point.x)
+            )
+            intermediate.updateCurentBreakpoint(point: breakPoint)
+        }
 
         /// #Step 3:
         /// If the arc we broke has circle event, than this event is false-alarm and has to be removed
@@ -246,6 +286,10 @@ public class FortuneSweep {
             newArc.rightHalfEdge = newArc.leftHalfEdge
             next.leftHalfEdge = prev.rightHalfEdge
         }
+        
+        if let intermediate = self.watcher {
+            intermediate.updateBeachline(arcs: beachline.getArcs())
+        }
     }
 
 
@@ -297,13 +341,16 @@ public class FortuneSweep {
         nextArc.leftHalfEdge = nextLHE
 
         makeTwins(prevArc.rightHalfEdge, nextArc.leftHalfEdge)
+        
+        watcher?.createVertex(vertex: vertex)
     }
 
 
     /// Processes circle event and performs all the necessary actions
     /// - Parameter event: **Circle Event**
     private func processCircleEvent(_ event: Event) {
         logger?.log("Circle Event: \(event.point)", level: .info)
+        watcher?.circleEvent(point: event.point)
 
         guard let arc = event.arc,
               let left = arc.prev,
@@ -350,8 +397,6 @@ public class FortuneSweep {
     ///   - arc: **Beachline** arc to add event
     ///   - circle: Circle represented by three points
     private func createCircleEvent(_ arc: Arc) {
-        logger?.log("Create Circle Event for Arc: \(arc.point!)", level: .info)
-        
         let left = arc.prev
         let right = arc.next
         guard let circle = checkCircleEvent(left: left, mid: arc, right: right) else {
@@ -366,6 +411,9 @@ public class FortuneSweep {
         arc.event = event
 
         eventQueue.push(event)
+        
+        logger?.log("Create Circle Event for Arc: \(arc.point!)", level: .info)
+        watcher?.addUpcomingCircleEvent(circle: event.circle!)
     }
 
     /// Removes circle event from the **Priority Queue** and removes event from the **Arc**
@@ -379,10 +427,11 @@ public class FortuneSweep {
                 return
         }
 
+        watcher?.removeFalseAlarmCircleEvent(circle: event.circle!)
+        logger?.log("Remove Circle Event for Arc: \(arc.point!)", level: .info)
+        
         eventQueue.removeAll(event)
         arc.event = nil
-        
-        logger?.log("Remove Circle Event for Arc: \(arc.point!)", level: .info)
     }
 
 
@@ -714,3 +763,28 @@ extension Vector2D {
         Site(x: dx, y: dy)
     }
 }
+
+public struct BeachlineSegment {
+    let parabola: Parabola
+    let lBoundX: Double
+    let rBoundX: Double
+}
+
+extension Beachline {
+    public func getArcs() -> [BeachlineSegment] {
+        var arcs = [BeachlineSegment]()
+        var arc = minimum
+        while arc != nil {
+            let (lb, rb) = arc!.bounds(sweeplineY)
+            arcs.append(
+                BeachlineSegment(
+                    parabola: Parabola(focus: arc!.point!, directrixY: sweeplineY),
+                    lBoundX: lb,
+                    rBoundX: rb
+                )
+            )
+            arc = arc?.next
+        }
+        return arcs
+    }
+}

Sources/FortunesAlgorithm/FortuneSweepProgressWatching.swift

@@ -0,0 +1,83 @@
+// MIT License
+//
+// Copyright (c) 2020 Oleksandr Glagoliev
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+
+
+import Foundation
+
+public protocol FortuneSweepProgressWatching: class {
+    
+    /// Depicts current step of an algorithm
+    var step: Int { get set }
+    
+    /// Called when algorithm is ready to work
+    /// - Parameter sites: Same as Fortunes Algorithm input
+    /// - Parameter clipper: Clipping rectangle
+    func prepare(sites: Set<Site>, clipper: Rectangle)
+    
+    
+    /// Called when sweepline changes position
+    /// - Parameter y: New sweepline Y position
+    func updateSweepline(y: Double)
+    
+    /// Called when Site Event occured
+    /// - Parameter site: Visited site
+    func siteEvent(site: Site)
+    
+    /// Called when Circle Event occured
+    /// - Parameter site: Visited site
+    func circleEvent(point: Point)
+    
+    
+    /// Called when bounding rectangle is changed
+    /// - Parameter rectangle: New Bounding rectangle
+    func updateContainer(rectangle: Rectangle)
+    
+    
+    /// Called when new breakpoint occured
+    /// - Parameter point: Breakpoint
+    func updateCurentBreakpoint(point: Point?)
+    
+    
+    /// Called when beachline is updated
+    /// - Parameter arcs: Arcs, currently present in the Beachline
+    func updateBeachline(arcs: [BeachlineSegment])
+    
+    
+    /// Called when upcoming circle event is added to the Event Queue
+    /// - Parameter circle: Circle event circle
+    func addUpcomingCircleEvent(circle: Circle)
+    
+    
+    /// Called when Circle event is removed from Event Queue
+    /// - Parameter circle: Circle event circle
+    func removeFalseAlarmCircleEvent(circle: Circle)
+    
+    
+    /// Called when new Vertex is created
+    /// - Parameter vertex: Vertex
+    func createVertex(vertex: Vertex)
+    
+    /// Called when new Cell is added to the diagram
+    /// - Parameter cell: Cell
+    func createCell(cell: Cell)
+}