forked from CesiumGS/3d-tiles-tools
-
Notifications
You must be signed in to change notification settings - Fork 0
/
ImplicitToExplicitDemo.ts
117 lines (103 loc) · 3.76 KB
/
ImplicitToExplicitDemo.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
import { TraversedTile } from "../src/traversal/TraversedTile";
import { BasicTilesetProcessor } from "../src/tilesetProcessing/BasicTilesetProcessor";
import { Tileset } from "../src/structure/Tileset";
import { Schema } from "../src/structure/Metadata/Schema";
import { Tile } from "../src/structure/Tile";
import { TilesetEntry } from "../src/tilesetData/TilesetEntry";
import { ContentDataTypes } from "../src/contentTypes/ContentDataTypes";
/**
* Creates an explicit hierarchy of `Tile` objects from the
* given traversed tile.
*
* @param traversedTile - The traversed tile
* @returns A promise to the explicit `Tile` object
*/
async function buildExplicitHierarchy(
traversedTile: TraversedTile
): Promise<Tile> {
const explicitTile = traversedTile.asFinalTile();
// For the root of implicit tilesets, remove the implicitTiling
// and contents (which contains the template URI)
if (traversedTile.isImplicitTilesetRoot()) {
delete explicitTile.implicitTiling;
delete explicitTile.contents;
}
// Build the explicit children, recursively
const explicitChildren: Tile[] = [];
const children = await traversedTile.getChildren();
for (const child of children) {
const explicitChild = await buildExplicitHierarchy(child);
explicitChildren.push(explicitChild);
}
if (explicitChildren.length > 0) {
explicitTile.children = explicitChildren;
}
return explicitTile;
}
async function runConversionDemo(
tilesetSourceName: string,
tilesetTargetName: string
) {
const overwrite = true;
const tilesetProcessor = new BasicTilesetProcessor();
await tilesetProcessor.begin(tilesetSourceName, tilesetTargetName, overwrite);
// Apply a callback to the given input tileset
await tilesetProcessor.forTileset(
// eslint-disable-next-line @typescript-eslint/no-unused-vars
async (tileset: Tileset, schema: Schema | undefined): Promise<Tileset> => {
// Call the traversal function, and build the
// explicit root from the traversed root.
let explicitRoot;
await tilesetProcessor.forEachTile(
async (traversedTile: TraversedTile): Promise<boolean> => {
explicitRoot = await buildExplicitHierarchy(traversedTile);
// The `buildExplicitHierarcy` function already traverses
// all children - so stop the traversal here:
return false;
}
);
if (!explicitRoot) {
console.log("Could not create explicit root");
return tileset;
}
// Create the target tileset, which is a copy of
// the source tileset, but with the explicit root
const targetTileset: Tileset = {
asset: tileset.asset,
properties: tileset.properties,
schema: tileset.schema,
schemaUri: tileset.schemaUri,
statistics: tileset.statistics,
groups: tileset.groups,
metadata: tileset.metadata,
geometricError: tileset.geometricError,
root: explicitRoot,
extensionsUsed: tileset.extensionsUsed,
extensionsRequired: tileset.extensionsRequired,
};
return targetTileset;
}
);
// Process all entries: When their type is CONTENT_TYPE_SUBT,
// then they are omitted in the output.
await tilesetProcessor.processAllEntries(
async (
sourceEntry: TilesetEntry,
type: string | undefined
): Promise<TilesetEntry | undefined> => {
if (type === ContentDataTypes.CONTENT_TYPE_SUBT) {
return undefined;
}
return sourceEntry;
}
);
await tilesetProcessor.end();
}
async function runDemo() {
const tilesetSourceName =
"../3d-tiles-samples/1.1/SparseImplicitQuadtree/tileset.json";
const tilesetTargetName =
"./output/SparseImplicitQuadtree-result/tileset.json";
await runConversionDemo(tilesetSourceName, tilesetTargetName);
}
runDemo();