sync

Author: stefanmaierhofer

src/Aardvark.Geometry.Quadtree/Builder.fs

@@ -111,11 +111,15 @@ module Builder =
                 result |> InMemoryInner
 
     let rec private build'' (config : BuildConfig) (rootCell : Cell2d) (patches : LayerSet[]) =
+    
+        let minSampleExponent = patches |> Seq.map (fun p -> p.SampleExponent) |> Seq.min
 
         if config.Verbose then
-            printfn "[build''] rootCell = %A, %d patches" rootCell patches.Length
-
-        let minSampleExponent = patches |> Seq.map (fun p -> p.SampleExponent) |> Seq.min
+            printfn "[build''] ******** BEGIN ******** %d patches; rootCell = %A; minSampleExponent = %d " patches.Length rootCell minSampleExponent
+            let mutable i = 0
+            for patch in patches do
+                printfn "[build''] | patches[%d] : e=%d origin=%A size=%A" i patch.SampleExponent patch.SampleWindow.Min patch.SampleWindow.Size
+                i <- i + 1
 
         match patches.Length with
 
@@ -156,7 +160,7 @@ module Builder =
                 (fun () -> sprintf "Expected config.SplitLimitPowerOfTwo to be non-negative, but found %d." config.SplitLimitPowerOfTwo)
                 "95c43529-9649-42d6-9b47-c6f8fb6da301"
 
-            let tileSize = 2 <<< config.SplitLimitPowerOfTwo
+            let tileSize = 1 <<< config.SplitLimitPowerOfTwo
             let rootBounds = getBoundsForExponent minSampleExponent rootCell
 
             if rootBounds.Size.X <= tileSize && rootBounds.Size.Y <= tileSize then
@@ -167,41 +171,49 @@ module Builder =
                 //    -> resulting layer has finest resolution of all patches
                 //    -> coarser layers will be subsampled
                 //    -> a mask indicates non-defined samples
-
+                
                 if config.Verbose then
                     printfn "[build''] MERGE %d patches; because reached split limit" n
-                    for patch in patches do
-                        printfn "[build''] | e=%d origin=%A size=%A" patch.SampleExponent patch.SampleWindow.Min patch.SampleWindow.Size
-
-                failwith "TODO"
 
-                let bbWindow = patches |> Seq.map (fun patch -> patch.SampleWindow) |> Box2l
-                
                 //if debugOutput then
+                //    let bbWindow = patches |> Seq.map (fun patch -> patch.SampleWindow) |> Box2l
                 //    for patch in patches do
                 //        printfn "[DEBUG]    %A (exact %A)" (patch.SampleWindow - rootBounds.Min) (bbWindow - rootBounds.Min)
 
                 // adjust root cell for split limit
-                let requiredRootCellSplitLimit = minSampleExponent + config.SplitLimitPowerOfTwo
-
+                let requiredRootCellExponent = minSampleExponent + config.SplitLimitPowerOfTwo
+                
+                if config.Verbose then
+                    printfn "[build''] | requiredRootCellExponent %d = minSampleExponent %d + config.SplitLimitPowerOfTwo %d" requiredRootCellExponent minSampleExponent config.SplitLimitPowerOfTwo
+                    
                 let mutable rootCell = rootCell
+                
+                if requiredRootCellExponent <> rootCell.Exponent then
 
-                if requiredRootCellSplitLimit <> rootCell.Exponent then
-
-                    invariantm (rootCell.Exponent < requiredRootCellSplitLimit) 
-                        (fun () -> sprintf "Expected root cell exponent %d to be smaller than requiredRootCellSplitLimit %d." rootCell.Exponent requiredRootCellSplitLimit)
+                    invariantm (rootCell.Exponent < requiredRootCellExponent) 
+                        (fun () -> sprintf "Expected root cell exponent %d to be smaller than requiredRootCellExponent %d." rootCell.Exponent requiredRootCellExponent)
                         "4911adf3-7b87-4234-9bcc-bc3076df846e"
 
                     if config.Verbose then
-                        printfn "[build''] must adjust root cell %A exponent to %d" rootCell requiredRootCellSplitLimit
+                        printfn "[build''] | must adjust root cell %A exponent to %d ..." rootCell requiredRootCellExponent
 
-                    while rootCell.Exponent < requiredRootCellSplitLimit do rootCell <- rootCell.Parent
+                    while rootCell.Exponent < requiredRootCellExponent do rootCell <- rootCell.Parent
 
                     if config.Verbose then
-                        printfn "[build''] adjusted root cell is %A" rootCell
+                        printfn "[build''] | adjusted root cell is %A" rootCell
+
+                else
+
+                    if config.Verbose then
+                        printfn "[build''] | root cell %A already has requiredRootCellExponent %d" rootCell requiredRootCellExponent
 
                 let merged = LayerSet.Merge patches
-                let qnode = QNode(Guid.NewGuid(), ebb, rootCell, config.SplitLimitPowerOfTwo, merged)
+                
+                let flattended = LayerSet.Flatten patches
+
+                failwith "TODO"
+
+                let qnode = QNode(Guid.NewGuid(), ebb, rootCell, config.SplitLimitPowerOfTwo, flattended)
 
                 if config.Verbose then
                     printfn "[build''] CREATED QNode with split limit = %d" qnode.SplitLimitExponent

src/Aardvark.Geometry.Quadtree/Defs.fs

@@ -22,6 +22,7 @@ module Defs =
     let NodeLeaf               = def "c74fad23-1211-4073-94e5-54b778e0d295" "Quadtree.NodeLeaf" "A quadtree leaf node. DurableMapAligned16." Durable.Primitives.DurableMapAligned16
     let NodeInner              = def "1f7baa27-5bcc-420f-89a3-714b65d93a2d" "Quadtree.NodeInner" "A quadtree inner node. DurableMapAligned16." Durable.Primitives.DurableMapAligned16
     let NodeMerge              = def "2d80c73e-ed3e-442a-a631-4f570ff838fd" "Quadtree.NodeMerge" "A quadtree merge node. DurableMapAligned16." Durable.Primitives.DurableMapAligned16
+    let NodeMultiMerge         = def "26416ce5-891d-4e7e-b29b-1e23a6a99382" "Quadtree.NodeMultiMerge" "A quadtree multi-merge node. DurableMapAligned16." Durable.Primitives.DurableMapAligned16
     let NodeLinked             = def "8628aab6-a416-42ab-9192-bae0d5590f4f" "Quadtree.LinkedNode" "A reference (link) to another quadtree node. DurableMapAligned16" Durable.Primitives.DurableMapAligned16
 
     let NodeId                 = def "e46c4163-dd28-43a4-8254-bc21dc3f766b" "Quadtree.NodeId" "Quadtree. Unique id of a node. Guid." Durable.Primitives.GuidDef

src/Aardvark.Geometry.Quadtree/Layer.fs

@@ -276,13 +276,13 @@ module Layer =
     let private mergeTyped<'a when 'a : equality> (undefinedValue : 'a) (layers : Layer<'a>[]) : Layer<'a> =
         let def = ensureSameDef layers
         if verbose then
-            printfn "[Layer.Merge] .... def = %s" def.Name
+            printfn "[Layer.mergeTyped] .... def = %s" def.Name
 
         let e = layers.[0].SampleExponent
         if not (layers |> Array.forall (fun l -> l.SampleExponent = e)) then 
             failwith "Cannot merge layers with different resolutions."
         if verbose then
-            printfn "[Layer.Merge] .... e = %d" e
+            printfn "[Layer.mergeTyped] .... e = %d" e
 
         let finalWindow = layers |> Seq.map (fun l -> l.SampleWindow) |> Box2l
         let finalOrigin = Cell2d(finalWindow.Min, e)
@@ -291,11 +291,11 @@ module Layer =
         let finalMask = Array.create<byte> (int finalWindow.Size.X * int finalWindow.Size.Y) 255uy
 
         if verbose then
-            for l in layers do printfn "[Layer.Merge] .... [%A-%A]" l.SampleMin l.SampleMaxIncl
-            printfn "[Layer.Merge] .... final mapping"
-            printfn "[Layer.Merge] .... buffer origin: %A" finalOrigin
-            printfn "[Layer.Merge] .... buffer size  : %A" finalWindow.Size
-            printfn "[Layer.Merge] .... window: %A" finalWindow
+            for l in layers do printfn "[Layer.mergeTyped] .... [%A-%A]" l.SampleMin l.SampleMaxIncl
+            printfn "[Layer.mergeTyped] .... final mapping"
+            printfn "[Layer.mergeTyped] .... buffer origin: %A" finalOrigin
+            printfn "[Layer.mergeTyped] .... buffer size  : %A" finalWindow.Size
+            printfn "[Layer.mergeTyped] .... window: %A" finalWindow
 
         let mutable debugCountValues = 0
         let mutable debugCountCollisions = 0
@@ -362,11 +362,107 @@ module Layer =
 
         Layer(def, finalData, finalMapping, if coundOccupiedSamples > 0 then Some finalMask else None)
 
+    let private flattenTyped<'a when 'a : equality> (undefinedValue : 'a) (layers : Layer<'a>[]) : Layer<'a> =
+        let def = ensureSameDef layers
+        if verbose then
+            printfn "[Layer.flattenTyped] .... def = %s" def.Name
+        
+        failwith "TODO"
+
+        let e = layers.[0].SampleExponent
+        if not (layers |> Array.forall (fun l -> l.SampleExponent = e)) then 
+            failwith "Cannot flatten layers with different resolutions."
+
+        if verbose then
+            printfn "[Layer.flattenTyped] .... e = %d" e
+        
+        let finalWindow = layers |> Seq.map (fun l -> l.SampleWindow) |> Box2l
+        let finalOrigin = Cell2d(finalWindow.Min, e)
+        let finalMapping = DataMapping(finalOrigin, V2i finalWindow.Size, finalWindow)
+        let finalData = Array.zeroCreate<'a> (int finalWindow.Size.X * int finalWindow.Size.Y)
+        let finalMask = Array.create<byte> (int finalWindow.Size.X * int finalWindow.Size.Y) 255uy
+
+        if verbose then
+            for l in layers do printfn "[Layer.flattenTyped] .... [%A-%A]" l.SampleMin l.SampleMaxIncl
+            printfn "[Layer.flattenTyped] .... final mapping"
+            printfn "[Layer.flattenTyped] .... buffer origin: %A" finalOrigin
+            printfn "[Layer.flattenTyped] .... buffer size  : %A" finalWindow.Size
+            printfn "[Layer.flattenTyped] .... window: %A" finalWindow
+        
+        let mutable debugCountValues = 0
+        let mutable debugCountCollisions = 0
+        let debugCollisionSamples = HashSet<int>()
+
+        let mutable layerIndex = 0uy
+        for layer in layers do
+            let w = layer.Mapping.Window
+            let xMaxIncl = int w.SizeX - 1
+            let yMaxIncl = int w.SizeY - 1
+            for y = 0 to yMaxIncl do
+                for x = 0 to xMaxIncl do
+                    let c = Cell2d(w.Min.X + int64 x, w.Min.Y + int64 y, e)
+                    let i = finalMapping.GetBufferIndex c
+                    let v = layer.GetSample(Fail, c)
+                    
+                    match finalMask[i] with
+                    | 255uy ->
+                        finalData[i] <- v
+                        finalMask[i] <- layerIndex
+                        debugCountValues <- debugCountValues + 1
+                    | _     ->
+                        if v <> finalData[i] then
+                            if finalData[i] = undefinedValue then
+                                if v <> undefinedValue then
+                                    finalData[i] <- v
+                                    finalMask[i] <- layerIndex
+                                else
+                                    ()
+                            else
+                                if v <> undefinedValue then
+                                    debugCollisionSamples.Add(i) |> ignore
+                                    debugCountCollisions <- debugCountCollisions + 1
+                                    
+                                    if verbose then
+                                        printfn "[DEBUG][Layer.flattenTyped] COLLISION overwriting value %A from layer %d with value %A from layer %d" finalData[i] finalMask[i] v layerIndex
+
+                                else
+                                    ()
+
+                        
+
+
+            layerIndex <- layerIndex + 1uy
+
+        
+        // count occupied samples
+        let coundOccupiedSamples = finalMask |> Array.sumBy (fun x -> if x = 255uy then 1 else 0)
+
+        if verbose && debugCountCollisions > 0 then
+            printfn "[DEBUG][Layer.flattenTyped] debugCountValues = %d" debugCountValues
+            printfn "[DEBUG][Layer.flattenTyped] debugCountCollisions = %d" debugCountCollisions
+            printfn "[DEBUG][Layer.flattenTyped] debugCollisionSamples.Count = %d" debugCollisionSamples.Count
+            printfn "[DEBUG][Layer.flattenTyped] debugCountOccupied.Count = %d / %d ... %5.2f" coundOccupiedSamples finalMask.Length (float coundOccupiedSamples / float finalMask.Length)
+
+        // rewrite mask (1 ... occupied, 0 ... undefined)
+
+        let countOccupied  = finalMask |> Array.filter (fun x -> x <> 255uy) |> Array.length
+        let countUndefined = finalMask |> Array.filter (fun x -> x = 255uy) |> Array.length
+        printfn "[OCCUPANCY][e = %d][%A][%A] countOccupied = %d, countUndefined = %d" e finalWindow finalWindow.Size countOccupied countUndefined
+
+        for i = 0 to finalMask.Length-1 do
+            finalMask[i] <- if finalMask[i] = 255uy then 0uy else 1uy
+
+        Layer(def, finalData, finalMapping, if coundOccupiedSamples > 0 then Some finalMask else None)
+
+
     let private toTyped<'a when 'a : equality> (layers : ILayer[]) : Layer<'a>[] =
         layers |> Array.map (fun x -> x :?> Layer<'a>)
 
     let private mergeUntyped_<'a when 'a : equality> (undefinedValue : 'a) xs : ILayer =
         xs |> toTyped<'a> |> (mergeTyped undefinedValue) :> ILayer
+   
+    let private flattenUntyped_<'a when 'a : equality> (undefinedValue : 'a) xs : ILayer =
+        xs |> toTyped<'a> |> (flattenTyped undefinedValue) :> ILayer
 
     /// Merge layers of same type (def).
     let Merge (layers : ILayer seq) =
@@ -402,6 +498,40 @@ module Layer =
 
             Some mergedLayers
 
+    /// Flatten layers of same type (def).
+    let Flatten (layers : ILayer seq) =
+        let ls = layers |> Array.ofSeq
+        match ls.Length with
+        | 0 ->
+            if verbose then printfn "[Layer.Flatten] 0 layers -> None"
+            None
+        | 1 ->
+            if verbose then printfn "[Layer.Flatten] 1 layer  -> Some ls.[0]"
+            Some (ls |> Array.exactlyOne)
+        | n ->
+            let distinctDefCount = ls |> Seq.distinctBy (fun l -> l.Def) |> Seq.length
+            if distinctDefCount <> 1 then failwith "Can only flatten layers of same type (def). Error 2611c741-c739-4480-8162-2a60d5d34a4f."
+            if verbose then printfn "[Layer.Flatten] %d layers" n
+            let mergedLayers =
+                match ls.[0] with
+                | :? Layer<int>     -> ls |> flattenUntyped_<int>     Int32.MinValue
+                | :? Layer<int64>   -> ls |> flattenUntyped_<int64>   Int64.MinValue    
+                | :? Layer<float>   -> ls |> flattenUntyped_<float>   nan
+                | :? Layer<float32> -> ls |> flattenUntyped_<float32> nanf
+                | :? Layer<V2f>     -> ls |> flattenUntyped_<V2f>     V2f.NaN
+                | :? Layer<V2d>     -> ls |> flattenUntyped_<V2d>     V2d.NaN
+                | :? Layer<V3f>     -> ls |> flattenUntyped_<V3f>     V3f.NaN
+                | :? Layer<V3d>     -> ls |> flattenUntyped_<V3d>     V3d.NaN
+                | :? Layer<V4f>     -> ls |> flattenUntyped_<V4f>     V4f.NaN
+                | :? Layer<V4d>     -> ls |> flattenUntyped_<V4d>     V4d.NaN
+                | :? Layer<C3b>     -> ls |> flattenUntyped_<C3b>     (C3b(0, 0, 0))
+                | :? Layer<C4b>     -> ls |> flattenUntyped_<C4b>     (C4b(0, 0, 0, 0))
+                | :? Layer<C3f>     -> ls |> flattenUntyped_<C3f>     (C3f(0, 0, 0))
+                | :? Layer<C4f>     -> ls |> flattenUntyped_<C4f>     (C4f(0, 0, 0, 0))
+                | _ -> failwith <| sprintf "Unsupported layer type %A. Invariant 0d379726-27dd-4063-9175-8f13ac44ad83." ls.[0]
+
+            Some mergedLayers
+
 type LayerSet(layers : ILayer[]) =
 
     do
@@ -477,8 +607,9 @@ type LayerSet(layers : ILayer[]) =
 
 module LayerSet =
 
-    /// Merges multiple layer sets.
+    /// Merges multiple layer sets with identical resolution.
     /// All layer sets must have identical layers (same number, same semantics, same order).
+    /// TODO: possibly obsolete and replaced by Flatten ?!
     let Merge (layerSets : LayerSet seq) : LayerSet =
 
         let layerSets = layerSets |> Array.ofSeq
@@ -494,5 +625,26 @@ module LayerSet =
                 )
             |> Array.ofList
 
+        let result = LayerSet layers
+        result
+
+    /// Flattens multiple layer sets (different resolutions are allowed) down to a single layer set.
+    /// Holes (which were not covered by any source layerset) are marked by an optional mask.
+    /// All layer sets must have identical layers (same number, same semantics, same order).
+    let Flatten (layerSets : LayerSet seq) : LayerSet =
+
+        let layerSets = layerSets |> Array.ofSeq
+        let layersPerLayerSet = layerSets[0].Layers.Length
+
+        let indices = [0..layersPerLayerSet-1]
+
+        let layers = 
+            indices
+            |> List.choose (fun i ->
+                // merge the i-th layers from all layer sets
+                layerSets |> Array.map (fun x -> x.Layers[i]) |> Layer.Flatten
+                )
+            |> Array.ofList
+
         let result = LayerSet layers
         result