Merge pull request #233 from Geodan/copilot/add-explicit-tiling-option

bertt · web-flow · commit b52a801fbe52 · 2025-11-12T13:56:55.000+01:00
Add explicit tiling support for OCTREE subdivision
diff --git a/README.md b/README.md
@@ -330,15 +330,7 @@ When the input geometries are distributed in a flat area (like buildings in a ci
 
 OCTREE is used when the input geometries are distributed in a cube-like area.
 
-OCTREE tiling schema is currently in development.
-
-Most features are supported when using OCTREE subdivsion, except:
-
-- Explicting tiling;
-
-- LOD support;
-
-- Creating multiple subtree files.
+Most features are supported when using OCTREE subdivision, except LOD support;
 
 ## Query parameter
 
diff --git a/src/b3dm.tileset.tests/CesiumTilerTests.cs b/src/b3dm.tileset.tests/CesiumTilerTests.cs
@@ -111,4 +111,43 @@ public void TestCreateExplicitTilesetsJson()
         var json = File.ReadAllText("testExplicit/tileset.json");
         Assert.That(json.Contains("geometricError"));
     }
+
+    [Test]
+    public void TestCreateExplicitTilesetsJson3D()
+    {
+        // Arrange
+        var version = new Version(1, 0);
+        var outputDirectory = "testExplicit3D";
+        var outputDirs = OutputDirectoryCreator.GetFolders(outputDirectory);
+        var translation = new double[] { 0, 0, 0 };
+        var geometricError = 100;
+        var geometricErrorFactor = 2;
+        var refinement = RefinementType.ADD;
+        var rootBoundingVolumeRegion = new double[] { 0, 0, 0, 0, 0, 0 };
+        var createGltf = false;
+        
+        var tile0 = new Tile3D(0, 0, 0, 0);
+        
+        var tile1 = new Tile3D(2, 0, 0, 0);
+        var tile2 = new Tile3D(2, 0, 0, 1);
+        var tile3 = new Tile3D(3, 0, 0, 0) { Available = true };
+
+        var tiles = new List<Tile3D>() { tile0, tile1, tile2, tile3 };
+
+        // Create bounding boxes for the tiles
+        var tileBounds = new Dictionary<string, BoundingBox3D>
+        {
+            { "0_0_0_0", new BoundingBox3D(0, 0, 0, 10, 10, 10) },
+            { "2_0_0_0", new BoundingBox3D(0, 0, 0, 5, 5, 5) },
+            { "2_0_0_1", new BoundingBox3D(0, 0, 5, 5, 5, 10) },
+            { "3_0_0_0", new BoundingBox3D(0, 0, 0, 2.5, 2.5, 2.5) }
+        };
+
+        // Act
+        CesiumTiler.CreateExplicitTilesetsJson3D(version, outputDirectory, translation, geometricError, geometricErrorFactor, refinement, rootBoundingVolumeRegion, tile1, tiles, tileBounds, createGltf);
+
+        // Assert
+        var json = File.ReadAllText("testExplicit3D/tileset.json");
+        Assert.That(json.Contains("geometricError"));
+    }
 }
diff --git a/src/b3dm.tileset.tests/b3dm.tileset.tests.csproj b/src/b3dm.tileset.tests/b3dm.tileset.tests.csproj
@@ -17,7 +17,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/b3dm.tileset/CesiumTiler.cs b/src/b3dm.tileset/CesiumTiler.cs
@@ -52,13 +52,13 @@ public static void CreateExplicitTilesetsJson(Version version, string outputDire
     {
         var splitLevel = (int)Math.Ceiling((tiles.Max((Tile s) => s.Z) + 1.0) / 2.0);
 
-        var rootTiles = TileSelector.Select(tiles, tile, 0, splitLevel);
+        var rootTiles = TileSelector.Select(tiles, tile, 0, splitLevel - 1);
         var rootTileset = TreeSerializer.ToTileset(rootTiles, translation, rootBoundingVolumeRegion, geometricError, geometricErrorFactor, version, refinement, tilesetVersion, crs);
 
         var maxlevel = tiles.Max((Tile s) => s.Z);
 
         var externalTilesets = 0;
-        if (maxlevel > splitLevel) {
+        if (maxlevel >= splitLevel) {
             // now create the tileset.json files on splitLevel
 
             var width = Math.Pow(2, splitLevel);
@@ -113,4 +113,92 @@ private static BoundingBox GetBoundingBox(List<Tile> children)
         return new BoundingBox(minx, miny, maxx, maxy);
     }
 
+    private static BoundingBox3D GetBoundingBox3D(List<Tile3D> children, Dictionary<string, BoundingBox3D> tileBounds)
+    {
+        var keys = children.Select(t => $"{t.Level}_{t.Z}_{t.X}_{t.Y}").ToList();
+        var boxes = keys.Select(k => tileBounds[k]).ToList();
+        
+        var minx = boxes.Min(b => b.XMin);
+        var maxx = boxes.Max(b => b.XMax);
+        var miny = boxes.Min(b => b.YMin);
+        var maxy = boxes.Max(b => b.YMax);
+        var minz = boxes.Min(b => b.ZMin);
+        var maxz = boxes.Max(b => b.ZMax);
+        
+        return new BoundingBox3D(minx, miny, minz, maxx, maxy, maxz);
+    }
+
+    public static List<Tile3D> GetChildren(List<Tile3D> tiles, Tile3D tile)
+    {
+        var res = new List<Tile3D>();
+        var root = tiles.Where(x => x.Equals(tile) && x.Available).FirstOrDefault();
+        if (root != null) {
+            res.Add(root);
+        }
+        var children = tiles.Where(x => tile.HasChild(x) && x.Available);
+        res.AddRange(children);
+
+        return res;
+    }
+
+    public static void CreateExplicitTilesetsJson3D(Version version, string outputDirectory, double[] translation, double geometricError, double geometricErrorFactor, RefinementType refinement, double[] rootBoundingVolumeRegion, Tile3D tile, List<Tile3D> tiles, Dictionary<string, BoundingBox3D> tileBounds, bool createGltf = false, string tilesetVersion = "", string crs = "")
+    {
+        var splitLevel = (int)Math.Ceiling((tiles.Max((Tile3D s) => s.Level) + 1.0) / 2.0);
+
+        var rootTiles = TileSelector3D.Select(tiles, tile, 0, splitLevel - 1);
+        var rootTileset = TreeSerializer.ToTileset3D(rootTiles, tileBounds, translation, rootBoundingVolumeRegion, geometricError, geometricErrorFactor, version, refinement, createGltf, tilesetVersion, crs);
+
+        var maxlevel = tiles.Max((Tile3D s) => s.Level);
+
+        var externalTilesets = 0;
+        if (maxlevel >= splitLevel) {
+            // now create the tileset.json files on splitLevel
+
+            var dimension = Math.Pow(2, splitLevel);
+            Console.WriteLine($"Writing tileset.json files...");
+
+            for (var x = 0; x < dimension; x++) {
+                for (var y = 0; y < dimension; y++) {
+                    for (var z = 0; z < dimension; z++) {
+                        var splitLevelTile = new Tile3D(splitLevel, x, y, z);
+                        var children = GetChildren(tiles, splitLevelTile);
+
+                        if (children.Count > 0) {
+                            var childrenBbox3D = GetBoundingBox3D(children, tileBounds);
+                            var childrenBbox2D = new BoundingBox(childrenBbox3D.XMin, childrenBbox3D.YMin, childrenBbox3D.XMax, childrenBbox3D.YMax);
+                            var childrenBoundingVolumeRegion = childrenBbox2D.ToRadians().ToRegion(childrenBbox3D.ZMin, childrenBbox3D.ZMax);
+                            
+                            // Translation is the same as identity matrix in case of child tileset.
+                            var tileset = TreeSerializer.ToTileset3D(children, tileBounds, null, childrenBoundingVolumeRegion, geometricError, geometricErrorFactor, version, refinement, createGltf, tilesetVersion);
+
+                            var childGeometricError = GeometricErrorCalculator.GetGeometricError(geometricError, geometricErrorFactor, splitLevel);
+                            tileset.geometricError = childGeometricError;
+                            tileset.root.geometricError = GeometricErrorCalculator.GetGeometricError(childGeometricError, geometricErrorFactor, 1);
+                            var detailedJson = JsonConvert.SerializeObject(tileset, Formatting.Indented, new JsonSerializerSettings() { NullValueHandling = NullValueHandling.Ignore });
+                            var filename = $"tileset_{splitLevel}_{z}_{x}_{y}.json";
+                            Console.Write($"\rWriting {filename}...");
+
+                            File.WriteAllText($"{outputDirectory}{Path.AltDirectorySeparatorChar}{filename}", detailedJson);
+                            externalTilesets++;
+                            // add the child tilesets to the root tileset
+                            var child = new Child();
+                            child.boundingVolume = new Boundingvolume() { region = childrenBoundingVolumeRegion };
+                            child.refine = refinement;
+                            child.geometricError = tileset.root.geometricError;
+
+                            child.content = new Content() { uri = filename };
+                            rootTileset.root.children.Add(child);
+                        }
+                    }
+                }
+            }
+        }
+        // write the root tileset
+        Console.WriteLine();
+        Console.WriteLine($"External tileset.json files: {externalTilesets}");
+        Console.WriteLine("Writing root tileset.json...");
+        var rootJson = JsonConvert.SerializeObject(rootTileset, Formatting.Indented, new JsonSerializerSettings() { NullValueHandling = NullValueHandling.Ignore });
+        File.WriteAllText($"{outputDirectory}{Path.AltDirectorySeparatorChar}tileset.json", rootJson);
+    }
+
 }
diff --git a/src/b3dm.tileset/OctreeTiler.cs b/src/b3dm.tileset/OctreeTiler.cs
@@ -27,6 +27,11 @@ public OctreeTiler(NpgsqlConnection conn, InputTable inputTable, TilingSettings
     }
 
     public List<Tile3D> GenerateTiles3D(BoundingBox3D bbox, int level, Tile3D tile, List<Tile3D> tiles)
+    {
+        return GenerateTiles3D(bbox, level, tile, tiles, null);
+    }
+
+    public List<Tile3D> GenerateTiles3D(BoundingBox3D bbox, int level, Tile3D tile, List<Tile3D> tiles, Dictionary<string, BoundingBox3D> tileBounds)
     {
         var where = inputTable.GetQueryClause();
 
@@ -35,6 +40,10 @@ public List<Tile3D> GenerateTiles3D(BoundingBox3D bbox, int level, Tile3D tile,
             var t2 = new Tile3D(level, tile.X, tile.Y, tile.Z);
             t2.Available = false;
             tiles.Add(t2);
+            if (tileBounds != null) {
+                var key = $"{level}_{tile.Z}_{tile.X}_{tile.Y}";
+                tileBounds[key] = bbox;
+            }
         }
         else if (numberOfFeatures > tilingSettings.MaxFeaturesPerTile) {
             level++;
@@ -56,7 +65,7 @@ public List<Tile3D> GenerateTiles3D(BoundingBox3D bbox, int level, Tile3D tile,
                         var bbox3d = new BoundingBox3D(xstart, ystart, z_start, xend, yend, zend);
 
                         var new_tile = new Tile3D(level, tile.X * 2 + x, tile.Y * 2 + y, tile.Z * 2 + z);
-                        GenerateTiles3D(bbox3d, level, new_tile, tiles);
+                        GenerateTiles3D(bbox3d, level, new_tile, tiles, tileBounds);
                     }
                 }
             }
@@ -88,6 +97,10 @@ public List<Tile3D> GenerateTiles3D(BoundingBox3D bbox, int level, Tile3D tile,
             }
 
             tiles.Add(tile);
+            if (tileBounds != null) {
+                var key = $"{tile.Level}_{tile.Z}_{tile.X}_{tile.Y}";
+                tileBounds[key] = bbox;
+            }
         }
 
         return tiles;
diff --git a/src/b3dm.tileset/OutputDirectoryCreator.cs b/src/b3dm.tileset/OutputDirectoryCreator.cs
@@ -5,15 +5,19 @@ namespace pg2b3dm;
 
 public static class OutputDirectoryCreator
 {
-    public static OutputSettings GetFolders(string outputFolder)
+    public static OutputSettings GetFolders(string outputFolder, bool createSubtreeFolder = true)
     {
         if (!Directory.Exists(outputFolder)) {
             Directory.CreateDirectory(outputFolder);
         }
 
-        var subtreesDirectory = $"{outputFolder}{Path.AltDirectorySeparatorChar}subtrees";
-        if (!Directory.Exists(subtreesDirectory)) {
-            Directory.CreateDirectory(subtreesDirectory);
+        string subtreesDirectory = string.Empty;
+
+        if (createSubtreeFolder) {
+            subtreesDirectory = $"{outputFolder}{Path.AltDirectorySeparatorChar}subtrees";
+            if (!Directory.Exists(subtreesDirectory)) {
+                Directory.CreateDirectory(subtreesDirectory);
+            }
         }
 
         var contentDirectory = $"{outputFolder}{Path.AltDirectorySeparatorChar}content";
diff --git a/src/b3dm.tileset/Tile3DWithBounds.cs b/src/b3dm.tileset/Tile3DWithBounds.cs
@@ -0,0 +1,15 @@
+using subtree;
+
+namespace B3dm.Tileset;
+
+public class Tile3DWithBounds
+{
+    public Tile3D Tile { get; set; }
+    public BoundingBox3D BoundingBox { get; set; }
+
+    public Tile3DWithBounds(Tile3D tile, BoundingBox3D boundingBox)
+    {
+        Tile = tile;
+        BoundingBox = boundingBox;
+    }
+}
diff --git a/src/b3dm.tileset/TileSelector3D.cs b/src/b3dm.tileset/TileSelector3D.cs
@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using System.Linq;
+using subtree;
+
+namespace B3dm.Tileset;
+public static class TileSelector3D
+{
+    public static List<Tile3D> Select(List<Tile3D> tiles, Tile3D root, int fromLevel, int toLevel)
+    {
+        if (tiles.Count == 1 && tiles.First().Level == root.Level) {
+            return tiles;
+        }
+        var result = new List<Tile3D>();
+        for (var level = fromLevel; level <= toLevel; level++) {
+            var selected = tiles.FindAll(t => t.Level == level && t.Available && root.HasChild(t));
+            result.AddRange(selected);
+        }
+        return result;
+    }
+}
diff --git a/src/b3dm.tileset/TreeSerializer.cs b/src/b3dm.tileset/TreeSerializer.cs
@@ -147,4 +147,65 @@ public static Child GetChild(Tile tile, double geometricError)
 
         return child;
     }
+
+    public static TileSet ToTileset3D(List<subtree.Tile3D> tiles, Dictionary<string, BoundingBox3D> tileBounds, double[] translate, double[] region, double geometricError, double geometricErrorFactor = 2, Version version = null, RefinementType refine = RefinementType.ADD, bool createGltf = false, string tilesetVersion = "", string crs = "")
+    {
+        var tileset = GetTilesetObject(version, geometricError, tilesetVersion, crs);
+
+        var t = new double[] {   1.0, 0.0, 0.0, 0.0,
+                                     0.0,1.0, 0.0, 0.0,
+                                     0.0, 0.0, 1.0, 0.0,
+            0.0, 0.0, 0.0, 1.0};
+
+        if (translate != null) {
+            t = new double[] {   1.0, 0.0, 0.0, 0.0,
+                                 0.0,1.0, 0.0, 0.0,
+                                 0.0, 0.0, 1.0, 0.0,
+            translate[0], translate[1], translate[2], 1.0};
+        }
+
+        var root = GetRoot(geometricError, t, region, refine);
+        tileset.geometricError = geometricError;
+        root.geometricError = GeometricErrorCalculator.GetGeometricError(geometricError, geometricErrorFactor, 1);
+        var childrenGeometricError = GeometricErrorCalculator.GetGeometricError(geometricError, geometricErrorFactor, 2);
+        var children = GetChildren3D(tiles, tileBounds, childrenGeometricError, geometricErrorFactor, createGltf);
+        root.children = children;
+
+        tileset.root = root;
+        return tileset;
+    }
+
+    private static List<Child> GetChildren3D(List<subtree.Tile3D> tiles, Dictionary<string, BoundingBox3D> tileBounds, double geometricError, double geometricErrorFactor, bool createGltf = false)
+    {
+        var children = new List<Child>();
+        foreach (var tile in tiles) {
+            if (tile.Available) {
+                var ge = GeometricErrorCalculator.GetGeometricError(geometricError, geometricErrorFactor, tile.Level);
+                var child = GetChild3D(tile, tileBounds, ge, createGltf);
+                children.Add(child);
+            }
+        }
+
+        return children;
+    }
+
+    public static Child GetChild3D(subtree.Tile3D tile, Dictionary<string, BoundingBox3D> tileBounds, double geometricError, bool createGltf = false)
+    {
+        var ext = createGltf ? ".glb" : ".b3dm";
+        var child = new Child {
+            geometricError = geometricError,
+            content = new Content()
+        };
+        child.content.uri = $"content{Path.AltDirectorySeparatorChar}{tile.Level}_{tile.Z}_{tile.X}_{tile.Y}{ext}";
+
+        var key = $"{tile.Level}_{tile.Z}_{tile.X}_{tile.Y}";
+        var bbox = tileBounds[key];
+        var boundingBox = new BoundingBox(bbox.XMin, bbox.YMin, bbox.XMax, bbox.YMax);
+        var region = boundingBox.ToRadians().ToRegion(bbox.ZMin, bbox.ZMax);
+        child.boundingVolume = new Boundingvolume {
+            region = region
+        };
+
+        return child;
+    }
 }
diff --git a/src/pg2b3dm.database.tests/pg2b3dm.database.tests.csproj b/src/pg2b3dm.database.tests/pg2b3dm.database.tests.csproj
@@ -9,10 +9,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Configuration" Version="9.0.10" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="9.0.10" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="9.0.10" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageReference Include="NUnit" Version="4.4.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="5.2.0" />
     <PackageReference Include="NUnit.Analyzers" Version="4.11.2">
diff --git a/src/pg2b3dm.sln b/src/pg2b3dm.sln
@@ -1,7 +1,7 @@
 ﻿
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.2.32616.157
+# Visual Studio Version 18
+VisualStudioVersion = 18.0.11201.2 d18.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "b3dm.tileset", "b3dm.tileset\b3dm.tileset.csproj", "{9AF6891B-30D6-4537-BB8C-AD36590A4AB2}"
 EndProject
diff --git a/src/pg2b3dm/Program.cs b/src/pg2b3dm/Program.cs
diff --git a/src/wkb2gltf.core.tests/wkb2gltf.tests.csproj b/src/wkb2gltf.core.tests/wkb2gltf.tests.csproj

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,11 @@ public OctreeTiler(NpgsqlConnection conn, InputTable inputTable, TilingSettings`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`public List<Tile3D> GenerateTiles3D(BoundingBox3D bbox, int level, Tile3D tile, List<Tile3D> tiles)`
	`30`	`+ {`
	`31`	`+ return GenerateTiles3D(bbox, level, tile, tiles, null);`
	`32`	`+ }`
	`33`	`+`
	`34`	`+ public List<Tile3D> GenerateTiles3D(BoundingBox3D bbox, int level, Tile3D tile, List<Tile3D> tiles, Dictionary<string, BoundingBox3D> tileBounds)`
`30`	`35`	`{`
`31`	`36`	`var where = inputTable.GetQueryClause();`
`32`	`37`
`@@ -35,6 +40,10 @@ public List<Tile3D> GenerateTiles3D(BoundingBox3D bbox, int level, Tile3D tile,`
`35`	`40`	`var t2 = new Tile3D(level, tile.X, tile.Y, tile.Z);`
`36`	`41`	`t2.Available = false;`
`37`	`42`	`tiles.Add(t2);`
	`43`	`+ if (tileBounds != null) {`
	`44`	`+ var key = $"{level}_{tile.Z}_{tile.X}_{tile.Y}";`
	`45`	`+ tileBounds[key] = bbox;`
	`46`	`+ }`
`38`	`47`	`}`
`39`	`48`	`else if (numberOfFeatures > tilingSettings.MaxFeaturesPerTile) {`
`40`	`49`	`level++;`
`@@ -56,7 +65,7 @@ public List<Tile3D> GenerateTiles3D(BoundingBox3D bbox, int level, Tile3D tile,`
`56`	`65`	`var bbox3d = new BoundingBox3D(xstart, ystart, z_start, xend, yend, zend);`
`57`	`66`
`58`	`67`	`var new_tile = new Tile3D(level, tile.X * 2 + x, tile.Y * 2 + y, tile.Z * 2 + z);`
`59`		`- GenerateTiles3D(bbox3d, level, new_tile, tiles);`
	`68`	`+ GenerateTiles3D(bbox3d, level, new_tile, tiles, tileBounds);`
`60`	`69`	`}`
`61`	`70`	`}`
`62`	`71`	`}`
`@@ -88,6 +97,10 @@ public List<Tile3D> GenerateTiles3D(BoundingBox3D bbox, int level, Tile3D tile,`
`88`	`97`	`}`
`89`	`98`
`90`	`99`	`tiles.Add(tile);`
	`100`	`+ if (tileBounds != null) {`
	`101`	`+ var key = $"{tile.Level}_{tile.Z}_{tile.X}_{tile.Y}";`
	`102`	`+ tileBounds[key] = bbox;`
	`103`	`+ }`
`91`	`104`	`}`
`92`	`105`
`93`	`106`	`return tiles;`
Original file line number	Diff line number	Diff line change
`@@ -5,15 +5,19 @@ namespace pg2b3dm;`
`5`	`5`
`6`	`6`	`public static class OutputDirectoryCreator`
`7`	`7`	`{`
`8`		`- public static OutputSettings GetFolders(string outputFolder)`
	`8`	`+ public static OutputSettings GetFolders(string outputFolder, bool createSubtreeFolder = true)`
`9`	`9`	`{`
`10`	`10`	`if (!Directory.Exists(outputFolder)) {`
`11`	`11`	`Directory.CreateDirectory(outputFolder);`
`12`	`12`	`}`
`13`	`13`
`14`		`- var subtreesDirectory = $"{outputFolder}{Path.AltDirectorySeparatorChar}subtrees";`
`15`		`- if (!Directory.Exists(subtreesDirectory)) {`
`16`		`- Directory.CreateDirectory(subtreesDirectory);`
	`14`	`+ string subtreesDirectory = string.Empty;`
	`15`	`+`
	`16`	`+ if (createSubtreeFolder) {`
	`17`	`+ subtreesDirectory = $"{outputFolder}{Path.AltDirectorySeparatorChar}subtrees";`
	`18`	`+ if (!Directory.Exists(subtreesDirectory)) {`
	`19`	`+ Directory.CreateDirectory(subtreesDirectory);`
	`20`	`+ }`
`17`	`21`	`}`
`18`	`22`
`19`	`23`	`var contentDirectory = $"{outputFolder}{Path.AltDirectorySeparatorChar}content";`