Merge pull request #236 from vykrum/updates

Updates

Author: vykrum

src/Hywe.Core/Goxel.fs

@@ -79,46 +79,51 @@ module Goxel =
 
     /// <summary> Removes aliasing/sawtooth artifacts from a sequence of hex coordinates. </summary>
     let removeSawtooth (sqn : Sqn) (arr : (int*int)[]) : (int*int)[] =
-        if arr.Length = 0 then [||] else
-        let (primary, secondary) = 
-            match sqn with
-            | Vertical   -> (fst, snd)
-            | Horizontal -> (snd, fst)
+        match arr.Length with
+        | 0 -> [||]
+        | n ->
+            let (primary, secondary) = 
+                match sqn with
+                | Vertical   -> (fst, snd)
+                | Horizontal -> (snd, fst)
 
-        let result = ResizeArray<int*int>()
-        let mutable i = 0
-        let n = arr.Length
-        while i < n do
-            let mutable j = i
-            while j + 1 < n && abs(primary arr.[j+1] - primary arr.[j]) = 2 do
-                j <- j + 1
-                
-            let groupLen = j - i + 1
-            if groupLen > 3 then
-                let mutable isOscillating = true
-                for k = i to j - 1 do
-                    if abs(secondary arr.[k+1] - secondary arr.[k]) <> 1 then
-                        isOscillating <- false
-                
-                if isOscillating then
-                    let f = arr.[i]
-                    let l = arr.[j]
-                    let low = min (secondary f) (secondary l)
-                    match sqn with
-                    | Vertical   -> 
-                        result.Add((low, snd f))
-                        result.Add((low, snd l))
-                    | Horizontal -> 
-                        result.Add((fst f, low))
-                        result.Add((fst l, low))
-                else
-                    for k = i to j do
-                        result.Add(arr.[k])
-            else
-                for k = i to j do
-                    result.Add(arr.[k])
-            i <- j + 1
-        result.ToArray()
+            let rec processGroups i acc =
+                match i < n with
+                | false -> acc |> List.rev |> Array.concat
+                | true ->
+                    let rec findGroupEnd j =
+                        match j + 1 < n && abs(primary arr.[j+1] - primary arr.[j]) = 2 with
+                        | true -> findGroupEnd (j + 1)
+                        | false -> j
+                    
+                    let j = findGroupEnd i
+                    let groupLen = j - i + 1
+                    
+                    match groupLen > 3 with
+                    | false -> 
+                        processGroups (j + 1) (arr.[i..j] :: acc)
+                    | true ->
+                        let rec checkOscillating k =
+                            match k < j with
+                            | false -> true
+                            | true ->
+                                match abs(secondary arr.[k+1] - secondary arr.[k]) <> 1 with
+                                | true -> false
+                                | false -> checkOscillating (k + 1)
+                        
+                        match checkOscillating i with
+                        | false -> processGroups (j + 1) (arr.[i..j] :: acc)
+                        | true ->
+                            let f = arr.[i]
+                            let l = arr.[j]
+                            let low = min (secondary f) (secondary l)
+                            let newPts =
+                                match sqn with
+                                | Vertical   -> [| (low, snd f); (low, snd l) |]
+                                | Horizontal -> [| (fst f, low); (fst l, low) |]
+                            processGroups (j + 1) (newPts :: acc)
+            
+            processGroups 0 []
 
     /// <summary> Deduplicates sequential points. </summary>
     let dedupeSequential (pts: (int * int)[]) =
@@ -163,9 +168,9 @@ module Goxel =
 
     /// <summary> Bounding box of a polygon in grid coordinates. </summary>
     let bounds (pts: (int * int)[]) =
-        if Array.isEmpty pts then
-            (0, 0, 0, 0)
-        else
+        match Array.isEmpty pts with
+        | true -> (0, 0, 0, 0)
+        | false ->
             let xs = pts |> Array.map fst
             let ys = pts |> Array.map snd
             (Array.min xs, Array.min ys, Array.max xs, Array.max ys)
@@ -230,18 +235,17 @@ module Goxel =
             let vt1 = Array.concat [| [|xx, yy|]; Array.tail vtx |]
             let verts = cleanPolygon sqn vt1
 
-            verts |> Array.fold (fun (acc: ResizeArray<Hxl>, lastOpt) pt ->
+            verts |> Array.fold (fun (acc: Hxl list, lastOpt) pt ->
                 let (ix, iy) = pt
                 let current = hxlVld sqn (RV(ix, iy, elv))
                 match lastOpt with
                 | None -> 
-                    acc.Add(current)
-                    (acc, Some current)
+                    (current :: acc, Some current)
                 | Some last ->
                     let seg = hxlLin sqn elv last current
-                    acc.AddRange(seg)
-                    (acc, Some (Array.last seg))
-            ) (ResizeArray<Hxl>(), None) |> fst |> (fun ra -> ra.ToArray())
+                    let newAcc = seg |> Array.fold (fun a c -> c :: a) acc
+                    (newAcc, Some (Array.last seg))
+            ) ([], None) |> fst |> List.rev |> List.toArray
 
     // --- Geometry Parsing ---