├── .gitignore
├── LICENSE
├── README.md
├── b3dm.py
├── batchtable.py
├── featuretable.py
├── i3dm.py
├── instancetable.py
├── packcmpt.py
├── packglb.py
├── pnts.py
└── tile3dinfo.py


/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2016, Geopipe, Inc.
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 5 | 
 6 | 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 7 | 
 8 | 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
 9 | 
10 | 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
11 | 
12 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
13 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # gltf2glb
 2 | Tools to manipulate GLTF/GLB-containing files such as .b3dm, .i3dm, .pnts, and .cmpt.
 3 | 
 4 | Created by Christopher Mitchell, Ph.D. et alia of Geopipe, Inc.
 5 | 
 6 | This project was initially intended to provide a GLTF-to-GLB packer, inspired by
 7 | the desire to use https://github.com/Qantas94Heavy/binary-gltf-util without running Javascript
 8 | as a server-side language. It has evolved to remove its first component (gltf2glb.py), instead
 9 | providing the tools shown below to pack and unpack GLTF/GLB files into and out of other containers.
10 | 
11 | Usage
12 | -----
13 | 
14 | ### packcmpt ###
15 | ```
16 | $ ./packcmpt.py -h
17 | usage: packcmpt.py [-h] -o OUTPUT input_files [input_files ...]
18 | 
19 | Packs one or more i3dm and/or b3dm files into a cmpt
20 | 
21 | positional arguments:
22 |   input_files
23 | 
24 | optional arguments:
25 |   -h, --help                    show this help message and exit
26 |   -o OUTPUT, --output OUTPUT    Output cmpt file
27 |   -u                            Unpack the output CMPT file instead of creating it (incomplete)
28 | ```
29 | ### i3dm ###
30 | ```
31 | $ ./i3dm.py -h
32 | usage: usage: i3dm.py [-h] -i I3DM -g GLB -o OUTPUT
33 | 
34 | Generate an i3dm file from JSON describing instances, and a GLB to instance
35 | 
36 | required arguments:
37 |   -i, --i3dm					JSON for instance semantics
38 |   -g, --glb						Path to GLB file to instance
39 |   -o, --output					Path to i3dm file to output
40 | 
41 | optional arguments:
42 |   -h, --help                    show this help message and exit
43 | 
44 | License
45 | -------
46 | (c) 2016-2021 Geopipe, Inc. and licensed under the BSD 3-Clause license. See LICENSE.
47 | 


--------------------------------------------------------------------------------
/b3dm.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | 
  3 | #--------------------------------------------
  4 | # b3dm.py: Component of GLTF to GLB converter
  5 | # (c) 2016 Geopipe, Inc.
  6 | # All rights reserved. See LICENSE.
  7 | #--------------------------------------------
  8 | 
  9 | import struct
 10 | from batchtable import BatchTable
 11 | from featuretable import FeatureTable
 12 | 
 13 | B3DM_MAGIC = 'b3dm'
 14 | B3DM_VERSION = 1
 15 | B3DM_HEADER_LEN = 28
 16 | 
 17 | class B3DM:
 18 | 	def __init__(self):
 19 | 		self.batch_table = BatchTable()
 20 | 		self.feature_table = FeatureTable()
 21 | 		self.gltf_bin = bytearray()
 22 | 
 23 | 	def loadJSONBatch(self, data_in, object_wise = True):
 24 | 		self.batch_table.loadJSONBatch(data_in, object_wise)
 25 | 
 26 | 	def loadJSONFeature(self, data_in, object_wise = True):
 27 | 		self.feature_table.loadJSONBatch(data_in, object_wise)
 28 | 
 29 | 	def writeBinary(self, gltf_bin, num_batch_features = 0, num_feature_features = 0):
 30 | 
 31 | 		# Add the required field BATCH_LENGTH to the feature table,
 32 | 		# as well as any other required globals
 33 | 		num_batch_features = max(num_batch_features, self.batch_table.getNumFeatures())
 34 | 		self.feature_table.addGlobal('BATCH_LENGTH', num_batch_features)
 35 | 		num_feature_features = max(num_feature_features, self.feature_table.getNumFeatures())
 36 | 
 37 | 		self.batch_table.finalize()
 38 | 		self.feature_table.finalize()
 39 | 
 40 | 		# Generate the header
 41 | 		output = self.writeHeader(gltf_bin, num_batch_features, num_feature_features)
 42 | 
 43 | 		# Add the feature table JSON to the output
 44 | 		feature_json = self.feature_table.getFeatureJSON()
 45 | 		output.extend(feature_json)
 46 | 
 47 | 		# Add the feature table binary to the output
 48 | 		feature_bin  = self.feature_table.getFeatureBin()
 49 | 		output.extend(feature_bin)
 50 | 
 51 | 		# Add the batch table JSON to the output
 52 | 		batch_json = self.batch_table.getBatchJSON()
 53 | 		output.extend(batch_json)
 54 | 
 55 | 		# Add the batch table binary to the output
 56 | 		batch_bin  = self.batch_table.getBatchBin()
 57 | 		output.extend(batch_bin)
 58 | 
 59 | 		# Add the GLTF model body to the output
 60 | 		output.extend(gltf_bin)
 61 | 
 62 | 		return output
 63 | 
 64 | 	def writeHeader(self, gltf_bin, num_feature_features, num_batch_features):
 65 | 		len_feature_json = len(self.feature_table.getFeatureJSON())
 66 | 		len_feature_bin  = len(self.feature_table.getFeatureBin())
 67 | 		len_batch_json   = len(self.batch_table.getBatchJSON())
 68 | 		len_batch_bin    = len(self.batch_table.getBatchBin())
 69 | 
 70 | 		length = B3DM_HEADER_LEN + \
 71 | 		         len_feature_json + len_feature_bin + \
 72 | 		         len_batch_json   + len_batch_bin + \
 73 | 		         len(gltf_bin)
 74 | 	
 75 | 		output = bytearray()
 76 | 		output.extend(B3DM_MAGIC.encode('utf-8'))
 77 | 		output.extend(struct.pack('<I', B3DM_VERSION))
 78 | 		output.extend(struct.pack('<I', length))
 79 | 		output.extend(struct.pack('<I', len_feature_json))
 80 | 		output.extend(struct.pack('<I', len_feature_bin))
 81 | 		output.extend(struct.pack('<I', len_batch_json))
 82 | 		output.extend(struct.pack('<I', len_batch_bin))
 83 | 	
 84 | 		# Sanity check
 85 | 		if (len(output) != B3DM_HEADER_LEN):
 86 | 			raise ValueError("Incorrect b3dm header length")
 87 | 	
 88 | 		return output
 89 | 
 90 | 	def readBinary(self, data):
 91 | 		self.offset = 0
 92 | 		self.readHeader(data)			 # What it says on the tin
 93 | 
 94 | 		# Now grab the feature table, batch table, and GLB
 95 | 		self.feature_json = self.unpackString(data, self.len_feature_json)
 96 | 		self.feature_bin =  self.unpackString(data, self.len_feature_bin)
 97 | 		self.batch_json = self.unpackString(data, self.len_batch_json)
 98 | 		self.batch_bin = self.unpackString(data, self.len_batch_bin)
 99 | 
100 | 		self.gltf_bin = self.unpackString(data, self.length - self.offset)
101 | 
102 | 	def readHeader(self, data):
103 | 		self.magic = self.unpack('4s', data).decode('utf-8')
104 | 		self.version = self.unpack('<I', data)
105 | 
106 | 		if self.magic != B3DM_MAGIC or self.version > B3DM_VERSION:
107 | 			raise IOError("Unrecognized magic %s or bad version %d" % (self.magic, self.version))
108 | 
109 | 		self.length           = self.unpack('<I', data)
110 | 		self.len_feature_json = self.unpack('<I', data)
111 | 		self.len_feature_bin  = self.unpack('<I', data)
112 | 		self.len_batch_json   = self.unpack('<I', data)
113 | 		self.len_batch_bin    = self.unpack('<I', data)
114 | 
115 | 	def getGLTFBin(self):
116 | 		return self.gltf_bin
117 | 
118 | 	def unpackString(self, data, length):
119 | 		self.offset += length
120 | 		return data[self.offset - length : self.offset]
121 | 
122 | 	def unpack(self, fmt, data):
123 | 		calc_len = struct.calcsize(fmt)
124 | 		self.offset += calc_len
125 | 		return struct.unpack(fmt, data[self.offset - calc_len : self.offset])[0]
126 | 
127 | def main():
128 | 	raise NotImplementedError("This file cannot be used directly!")
129 | 
130 | if __name__ == "__main__":
131 | 	main()
132 | 


--------------------------------------------------------------------------------
/batchtable.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | 
  3 | #--------------------------------------------------
  4 | # batchtable.py: Component of GLTF to GLB converter
  5 | # (c) 2016 - 2019 Geopipe, Inc.
  6 | # All rights reserved. See LICENSE.
  7 | #--------------------------------------------------
  8 | 
  9 | import struct
 10 | import json
 11 | import numpy as np
 12 | 
 13 | class BatchTable:
 14 | 	def __init__(self):
 15 | 		self.batch_in = {}
 16 | 		self.batch_json = bytearray()
 17 | 		self.batch_bin = bytearray()
 18 | 		self.num_features = 0
 19 | 
 20 | 	def loadJSONBatch(self, data_in, object_wise = True):
 21 | 		""" Load object batch data from a dict/object. The data could,
 22 | 			for example, have been decoded from a JSON string.
 23 | 	
 24 | 			If object_wise is True, then the JSON should be
 25 | 			formatted as an array of batched objects, each
 26 | 			of which has a series of keys and values. This
 27 | 			method will transpose the data to map keys to
 28 | 			arrays of values, one for each object. It handles
 29 | 			keys that only exist for a subset of the batched
 30 | 			obhects.
 31 | 	
 32 | 			If object_wise is False, then it is assumed that
 33 | 			the input data already maps keys to arrays of
 34 | 			values, one for each object, with the necessary
 35 | 			null/None/placeholder values for keys that don't
 36 | 			have a real value for that particular object.
 37 | 		"""
 38 | 		if object_wise:
 39 | 			n_objs = len(data_in)
 40 | 			# Find all the fields for all the objects
 41 | 			if type(data_in) is list:
 42 | 				data_in = {i: data_in[i] for i in range(len(data_in))}
 43 | 			for obj, objval in data_in.items():
 44 | 				obj = int(obj)
 45 | 
 46 | 				# Add this object's key-vals
 47 | 				for key, val in objval.items():
 48 | 					if not key in self.batch_in:
 49 | 						self.batch_in[key] = [None] * n_objs
 50 | 
 51 | 					self.batch_in[key][obj] = val
 52 | 
 53 | 				n_objs += 1
 54 | 
 55 | 		else:
 56 | 			self.batch_in = data_in
 57 | 		if len(self.batch_in):
 58 | 			first_key = next(iter(self.batch_in))
 59 | 			self.num_features = len(self.batch_in[first_key])
 60 | 
 61 | 	def writeOutput(self):
 62 | 		data_out = {}
 63 | 		# TODO: Add proper encoding to JSON + binary, rather than just
 64 | 		# punting to the naive method
 65 | 		data_out = self.batch_in
 66 | 		self.batch_json = bytearray(json.dumps(data_out, separators=(',', ':'), sort_keys=True), encoding='utf8')
 67 | 
 68 | 		# TODO: Why do we clear this?
 69 | 		self.batch_in = bytearray()
 70 | 		self.num_features = 0
 71 | 
 72 | 	def finalize(self):
 73 | 		# Create the actual batch JSON (and binary)
 74 | 		self.writeOutput()
 75 | 
 76 | 		# Pad with spaces to a multiple of 4 bytes
 77 | 		padded_batch_json_len = len(self.batch_json) + 3 & ~3
 78 | 		self.batch_json.extend([ord(' ')] * (padded_batch_json_len - len(self.batch_json)))
 79 | 
 80 | 		padded_batch_bin_len = len(self.batch_bin) + 3 & ~3
 81 | 		self.batch_bin.extend([ord(' ')] * (padded_batch_bin_len - len(self.batch_bin)))
 82 | 
 83 | 	"""
 84 | 	Returns a bytearray of the JSON for the batch, ready to embed in another binary stream
 85 | 	"""
 86 | 	def getBatchJSON(self):
 87 | 		return self.batch_json
 88 | 
 89 | 	def getBatchBin(self):
 90 | 		return self.batch_bin
 91 | 
 92 | 	def getNumFeatures(self):
 93 | 		return self.num_features
 94 | 
 95 | 	""" A few utilities """
 96 | 	def nestedListToBin(self, val, val_type):
 97 | 		val_codes = {'f32' : 'f', 'u16' : 'H', 'u8' : 'B'}
 98 | 		if val_type not in val_codes:
 99 | 			raise TypeError("Don't know how to pack type '%s'" % val_type)
100 | 		else:
101 | 			val_code = val_codes[val_type]
102 | 		if type(val) is list:
103 | 			output = bytearray()
104 | 			for item in val:
105 | 				output.extend(self.nestedListToBin(item, val_type))
106 | 			return output
107 | 		elif type(val) is np.ndarray:
108 | 			return bytearray(val.astype(val_code).tobytes())
109 | 		else:
110 | 			return struct.pack('<%s' % val_code, val)	
111 | 
112 | 	
113 | 


--------------------------------------------------------------------------------
/featuretable.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | #--------------------------------------------------
 4 | # featuretable.py: Component of GLTF to GLB converter
 5 | # Currently a placeholder copy of BatchTable
 6 | # (c) 2017 - 2019 Geopipe, Inc.
 7 | # All rights reserved. See LICENSE.
 8 | #--------------------------------------------------
 9 | 
10 | import struct
11 | import json
12 | from batchtable import BatchTable
13 | 
14 | class FeatureTable(BatchTable):
15 | 	def __init__(self):
16 | 		BatchTable.__init__(self)
17 | 		self.features_global = {}
18 | 		self.features_json = bytearray()
19 | 		self.features_bin  = bytearray()
20 | 		self.num_global_features = 0
21 | 
22 | 	def addGlobal(self, key, value):
23 | 		self.features_global[key] = value
24 | 		self.num_global_features += 1
25 | 
26 | 	def writeOutput(self):
27 | 		data_out = {}
28 | 		# TODO: Add proper encoding to JSON + binary, rather than just
29 | 		# punting to the naive method
30 | 		data_out = self.features_global
31 | 		data_out.update(self.batch_in)
32 | 		self.features_json = bytearray(json.dumps(data_out, separators=(',', ':'), sort_keys=True), encoding='utf-8')
33 | 		
34 | 		# TODO: Why do we clear these?
35 | 		self.batch_in = bytearray()
36 | 		self.features_global = bytearray()
37 | 		self.num_features = 0
38 | 		self.num_global_features = 0
39 | 
40 | 	def finalize(self):
41 | 		# Create the actual features JSON (and binary)
42 | 		self.writeOutput()
43 | 
44 | 		# Pad with spaces to a multiple of 4 bytes
45 | 		padded_features_json_len = len(self.features_json) + 3 & ~3
46 | 		self.features_json.extend([ord(' ')] * (padded_features_json_len - len(self.features_json)))
47 | 
48 | 		padded_features_bin_len = len(self.features_bin) + 3 & ~3
49 | 		self.features_bin.extend([ord(' ')] * (padded_features_bin_len - len(self.features_bin)))
50 | 
51 | 	"""
52 | 	Returns a bytearray of the JSON for the features, ready to embed in another binary stream
53 | 	"""
54 | 	def getFeatureJSON(self):
55 | 		return self.features_json
56 | 
57 | 	def getFeatureBin(self):
58 | 		return self.features_bin
59 | 
60 | class InstanceFeatureTable(FeatureTable):
61 | 	def __init__(self, instance_semantics):
62 | 		FeatureTable.__init__(self)
63 | 		self.instance_semantics = instance_semantics
64 | 		
65 | 	def finalize(self):
66 | 		new_batch_in = {}
67 | 		for key, val in self.batch_in.items():
68 | 			offset = len(self.features_bin)
69 | 			
70 | 			buf_bin = None
71 | 			if key in self.instance_semantics:
72 | 				buf_bin = self.nestedListToBin(val, self.instance_semantics[key])
73 | 			else:
74 | 				raise KeyError("'%s' is not a valid instance semantic" % key)
75 | 
76 | 			new_batch_in[key] = {'byteOffset': offset}
77 | 			self.features_bin.extend(buf_bin)
78 | 			
79 | 		self.batch_in = new_batch_in
80 | 
81 | 		FeatureTable.finalize(self)
82 | 


--------------------------------------------------------------------------------
/i3dm.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | 
  3 | #--------------------------------------------------------
  4 | # i3dm.py: Component of GLTF to GLB converter
  5 | # (c) 2016 - 2019 Geopipe, Inc.
  6 | # All rights reserved. See LICENSE.
  7 | #
  8 | # Source spec: see
  9 | # https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/
 10 | #       master/specification/TileFormats/Instanced3DModel
 11 | # - Feature table: contains the actual information about
 12 | #   the instances to be created.
 13 | # - Batch table: may contain information about separate
 14 | #   units that can be declaratively styled within the
 15 | #   single model that is instanced, but we expect this to
 16 | #   be used in a relative minority of the use cases.
 17 | #---------------------------------------------------------
 18 | 
 19 | import struct
 20 | import argparse
 21 | import json
 22 | 
 23 | from batchtable import BatchTable
 24 | from featuretable import InstanceFeatureTable
 25 | 
 26 | I3DM_MAGIC = 'i3dm'
 27 | I3DM_VERSION = 1
 28 | I3DM_HEADER_LEN = 32
 29 | 
 30 | I3DM_SEMANTICS = {
 31 | 	'POSITION' : 'f32',
 32 | 	'NORMAL_UP' : 'f32',
 33 | 	'NORMAL_RIGHT' : 'f32',
 34 | 	'SCALE' : 'f32',
 35 | 	'SCALE_NON_UNIFORM' : 'f32',
 36 | 	'POSITION_QUANTIZED' : 'u16',
 37 | 	'NORMAL_UP_OCT32P' : 'u16',
 38 | 	'NORMAL_RIGHT_OCT32P' : 'u16',
 39 | 	'BATCH_ID' : 'u16'
 40 | }
 41 | 
 42 | class I3DM(object):
 43 | 	def __init__(self):
 44 | 		self.batch_table = BatchTable()
 45 | 		self.feature_table = InstanceFeatureTable(I3DM_SEMANTICS)
 46 | 		self.gltf_bin = bytearray()
 47 | 
 48 | 	def loadJSONBatch(self, data_in, object_wise = True):
 49 | 		self.batch_table.loadJSONBatch(data_in, object_wise)
 50 | 
 51 | 	def loadJSONInstances(self, i3dm_json, object_wise = True):
 52 | 		self.loadJSONFeatures(i3dm_json, object_wise)
 53 | 
 54 | 	def loadJSONFeatures(self, data_in, object_wise = True):
 55 | 		self.feature_table.loadJSONBatch(data_in, object_wise)
 56 | 
 57 | 	# If embed_gltf is false, gltf_bin is a URI string instead of GLTF data
 58 | 	def writeBinary(self, gltf_bin, embed_gltf = True, num_batches = 0, num_feature_features = 0):
 59 | 		self.embed_gltf = embed_gltf
 60 | 
 61 | 		# Make sure that it's a byte array, not a string
 62 | 		gltf_bin = gltf_bin if embed_gltf else gltf_bin.encode('utf-8')
 63 | 
 64 | 		# Add the required field BATCH_LENGTH to the feature table,
 65 | 		# as well as any other required globals
 66 | 		num_batch_features = max(num_batches, self.batch_table.getNumFeatures())
 67 | 		self.feature_table.addGlobal('BATCH_LENGTH', num_batch_features)
 68 | 		num_feature_features = max(num_feature_features, self.feature_table.getNumFeatures())
 69 | 		self.feature_table.addGlobal('INSTANCES_LENGTH', num_feature_features)
 70 | 
 71 | 		self.batch_table.finalize()
 72 | 		self.feature_table.finalize()
 73 | 
 74 | 		# Generate the header
 75 | 		output = self.writeHeader(gltf_bin, num_batch_features, num_feature_features)
 76 | 
 77 | 		# Add the feature table JSON to the output
 78 | 		feature_json = self.feature_table.getFeatureJSON()
 79 | 		output.extend(feature_json)
 80 | 
 81 | 		# Add the feature table binary to the output
 82 | 		feature_bin  = self.feature_table.getFeatureBin()
 83 | 		output.extend(feature_bin)
 84 | 
 85 | 		# Add the batch table JSON to the output
 86 | 		batch_json = self.batch_table.getBatchJSON()
 87 | 		output.extend(batch_json)
 88 | 
 89 | 		# Add the batch table binary to the output
 90 | 		batch_bin  = self.batch_table.getBatchBin()
 91 | 		output.extend(batch_bin)
 92 | 
 93 | 		# Add the GLTF model body to the output
 94 | 		output.extend(gltf_bin)
 95 | 
 96 | 		return output
 97 | 
 98 | 	# If embed_gltf is false, gltf_bin is a URI string instead of GLTF data
 99 | 	def writeHeader(self, gltf_bin, num_batch_features, num_feature_features):
100 | 		len_feature_json = len(self.feature_table.getFeatureJSON())
101 | 		len_feature_bin  = len(self.feature_table.getFeatureBin())
102 | 		len_batch_json   = len(self.batch_table.getBatchJSON())
103 | 		len_batch_bin    = len(self.batch_table.getBatchBin())
104 | 
105 | 		length = I3DM_HEADER_LEN + \
106 | 		         len_feature_json + len_feature_bin + \
107 | 		         len_batch_json   + len_batch_bin + \
108 | 		         len(gltf_bin)
109 | 	
110 | 		output = bytearray()
111 | 		output.extend(I3DM_MAGIC.encode('utf-8'))
112 | 		output.extend(struct.pack('<I', I3DM_VERSION))
113 | 		output.extend(struct.pack('<I', length))
114 | 		output.extend(struct.pack('<I', len_feature_json))
115 | 		output.extend(struct.pack('<I', len_feature_bin))
116 | 		output.extend(struct.pack('<I', len_batch_json))
117 | 		output.extend(struct.pack('<I', len_batch_bin))
118 | 		output.extend(struct.pack('<I', 1 if self.embed_gltf else 0))
119 | 	
120 | 		# Sanity check
121 | 		if (len(output) != I3DM_HEADER_LEN):
122 | 			raise ValueError("Incorrect i3dm header length")
123 | 	
124 | 		return output
125 | 
126 | 	def readBinary(self, data):
127 | 		self.offset = 0
128 | 		self.readHeader(data)			 # What it says on the tin
129 | 
130 | 		# Now grab the feature table, batch table, and GLB
131 | 		self.feature_json = self.unpackString(data, self.len_feature_json)
132 | 		self.feature_bin  = self.unpackString(data, self.len_feature_bin)
133 | 		self.batch_json = self.unpackString(data, self.len_batch_json)
134 | 		self.batch_bin  = self.unpackString(data, self.len_batch_bin)
135 | 
136 | 		self.gltf_bin = self.unpackString(data, self.length - self.offset)
137 | 
138 | 	def readHeader(self, data):
139 | 		self.magic = self.unpack('4s', data).decode('utf-8')
140 | 		self.version = self.unpack('<I', data)
141 | 
142 | 		if self.magic != I3DM_MAGIC or self.version > I3DM_VERSION:
143 | 			raise IOError("Unrecognized magic %s or bad version %d" % (self.magic, self.version))
144 | 
145 | 		self.length           = self.unpack('<I', data)
146 | 		self.len_feature_json = self.unpack('<I', data)
147 | 		self.len_feature_bin  = self.unpack('<I', data)
148 | 		self.len_batch_json   = self.unpack('<I', data)
149 | 		self.len_batch_bin    = self.unpack('<I', data)
150 | 		self.embed_gltf       = self.unpack('<I', data)
151 | 
152 | 	def getGLTFBin(self):
153 | 		return self.gltf_bin
154 | 
155 | 	def unpackString(self, data, length):
156 | 		self.offset += length
157 | 		return data[self.offset - length : self.offset]
158 | 
159 | 	def unpack(self, fmt, data):
160 | 		calc_len = struct.calcsize(fmt)
161 | 		self.offset += calc_len
162 | 		return struct.unpack(fmt, data[self.offset - calc_len : self.offset])[0]
163 | 
164 | def main():
165 | 	""" Generates an i3dm file from a glb plus JSON"""
166 | 
167 | 	# Parse options and get results
168 | 	parser = argparse.ArgumentParser(description='Converts GLTF to GLB')
169 | 	parser.add_argument("-i", "--i3dm", type=str, required=True, \
170 | 	                    help="Export i3dm, with required path to input JSON instance table data. Supports only embedded GLBs")
171 | 	parser.add_argument("-b", "--batch", type=str, required=False, \
172 | 	                    help="Optional path to batch table JSON")
173 | 	parser.add_argument("-g", "--glb", type=str, required=True, \
174 | 	                    help="GLB file to instance and embed in/link from the output i3dm file")
175 | 	parser.add_argument("-e", "--embed", action="store_true", \
176 | 	                    help="Specify to embed the GLB file instead of referencing it")
177 | 	parser.add_argument("-o", "--output", required=True, \
178 | 	                    help="Output i3dm path")
179 | 	args = parser.parse_args()
180 | 	
181 | 	i3dm_encoder = I3DM()
182 | 	if not(len(args.i3dm)):
183 | 		raise ValueError("-i/--i3dm requires a JSON instance table")
184 | 	else:
185 | 		with open(args.i3dm, 'r') as f:
186 | 			i3dm_json = json.loads(f.read())
187 | 		i3dm_encoder.loadJSONInstances(i3dm_json)
188 | 		if len(args.batch):
189 | 			with open(args.batch, 'r') as f:
190 | 				batch_json = json.loads(f.read())
191 | 			i3dm_encoder.loadJSONBatch(batch_json, False)
192 | 
193 | 	with open(args.output, 'wb') as f:
194 | 		if args.embed:
195 | 			with open(args.glb, 'rb') as glb:
196 | 				f.write(i3dm_encoder.writeBinary(glb.read(), True))		# Second arg: embed gltf
197 | 		else:
198 | 			while len(args.glb) % 8:
199 | 				args.glb += ' '
200 | 			f.write(i3dm_encoder.writeBinary(args.glb, False))
201 | 
202 | if __name__ == "__main__":
203 | 	main()
204 | 


--------------------------------------------------------------------------------
/instancetable.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | #--------------------------------------------------
 4 | # instancetable.py: Component of GLTF to GLB converter
 5 | # Currently a placeholder copy of BatchTable
 6 | # (c) 2017 Geopipe, Inc.
 7 | # All rights reserved. See LICENSE.
 8 | #--------------------------------------------------
 9 | 
10 | import struct
11 | import json
12 | from batchtable import BatchTable
13 | 
14 | class InstanceTable(BatchTable):
15 | 	def __init__(self):
16 | 		BatchTable.__init__(self)
17 | 


--------------------------------------------------------------------------------
/packcmpt.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | #---------------------------------------------------------------------
  3 | # packcmpt.py: CMPT file creator, to pack multiple Tile3D files into a
  4 | # single package. Component of gltf2glb.
  5 | # (c) 2016-2020 Geopipe, Inc.
  6 | # All rights reserved. See LICENSE.
  7 | #---------------------------------------------------------------------
  8 | 
  9 | import sys, os
 10 | import argparse
 11 | import struct
 12 | 
 13 | CMPT_EXT = '.cmpt'
 14 | CMPT_MAGIC = 'cmpt'
 15 | CMPT_VERSION = 1
 16 | CMPT_HEADER_LEN = 16
 17 | VALID_INTERIOR_TILES = {'b3dm', 'i3dm', 'cmpt', 'pnts'}
 18 | 
 19 | class CmptEncoder:
 20 | 	""" Pack multiple Tile3D file(s) into a single unit """
 21 | 	def __init__(self):
 22 | 		self.header = bytearray()
 23 | 		self.body = bytearray()
 24 | 		self.tile_count = 0
 25 | 
 26 | 	def add(self, filename):
 27 | 		with open(filename, 'rb') as f:
 28 | 			content = f.read()
 29 | 		# All interior tiles have a four-character extension
 30 | 		_, ext = os.path.splitext(filename)		# Get the extension
 31 | 		ext = ext[1:]							# Remove the .
 32 | 		if len(ext) != 4:
 33 | 			print("Invalid extension ('%s') for file '%s'" % (ext, filename))
 34 | 			raise NameError
 35 | 
 36 | 		# Make sure it's a known extension
 37 | 		if ext not in VALID_INTERIOR_TILES:
 38 | 			print("Extension '%s' ('%s') not recognized as valid tile type" % (ext, filename))
 39 | 			raise NameError
 40 | 		
 41 | 		return self.add_content(content)
 42 | 		
 43 | 	def add_content(self, content):
 44 | 		self.body.extend(content)							# Tile contents
 45 | 
 46 | 		self.tile_count += 1
 47 | 
 48 | 	def composeHeader(self):
 49 | 		header = bytearray() # start with a fresh header!
 50 | 		header.extend(CMPT_MAGIC.encode('utf-8'))		# Magic
 51 | 		header.extend(struct.pack('<I', 1))				# Version
 52 | 		header.extend(struct.pack('<I', CMPT_HEADER_LEN + len(self.body)))
 53 | 		header.extend(struct.pack('<I', self.tile_count))	# Number of tiles
 54 | 
 55 | 		if len(header) != CMPT_HEADER_LEN:
 56 | 			raise ArithmeticError("Unexpected header size!")
 57 | 		else:
 58 | 			self.header = header
 59 | 
 60 | 	def export(self, filename):
 61 | 		with open(filename, 'wb') as f:
 62 | 			self.export_to_handle(f)
 63 | 			
 64 | 	def export_to_handle(self, handle):
 65 | 		self.composeHeader()
 66 | 		handle.write(self.header)
 67 | 		handle.write(self.body)
 68 | 
 69 | class CmptDecoder:
 70 | 	""" Pack multiple Tile3D file(s) into a single unit """
 71 | 	def __init__(self):
 72 | 		self.data = ""
 73 | 		self.tiles = []
 74 | 
 75 | 	def add(self, filename = None, data = None):
 76 | 		if filename:
 77 | 			with open(filename, 'rb') as f:
 78 | 				self.data = f.read()
 79 | 		elif data:
 80 | 			self.data = data
 81 | 		else:
 82 | 			print("Both filename and data cannot be None!")
 83 | 			raise IOError
 84 | 
 85 | 	def decode(self):
 86 | 		# Grab the header
 87 | 		self.offset = 0;
 88 | 		magic = self.unpack('4s', self.data).decode('utf-8')
 89 | 		version = self.unpack('<I', self.data)
 90 | 
 91 | 		if magic != CMPT_MAGIC or version > CMPT_VERSION:
 92 | 			raise IOError("Unrecognized magic string %s or bad version %d" % (magic, version))
 93 | 
 94 | 		self.length = self.unpack('<I', self.data)
 95 | 		self.count = self.unpack('<I', self.data)
 96 | 
 97 | 		# Now grab all the body items
 98 | 		self.tiles = []
 99 | 		for i in range(self.count):
100 | 			start_idx = self.offset
101 | 
102 | 			# All the possible inner tile items have a byte count in the same place.
103 | 			inner_magic = self.unpack('4s', self.data).decode('utf-8')
104 | 			if inner_magic not in VALID_INTERIOR_TILES:
105 | 				print("Unrecognized interior tile magic %s" % (inner_magic))
106 | 			inner_version = self.unpack('<I', self.data)
107 | 			inner_length = self.unpack('<I', self.data)
108 | 
109 | 			self.tiles.append({ \
110 | 				'magic': inner_magic, \
111 | 				'version': inner_version, \
112 | 				'length': inner_length, \
113 | 				'data': self.data[start_idx : start_idx + inner_length] \
114 | 			});
115 | 			self.offset = start_idx + inner_length
116 | 
117 | 		del self.data
118 | 
119 | 	def getTiles(self):
120 | 		return self.tiles
121 | 			
122 | 	def unpack(self, fmt, data):
123 | 		calc_len = struct.calcsize(fmt)
124 | 		self.offset += calc_len
125 | 		return struct.unpack(fmt, data[self.offset - calc_len : self.offset])[0]
126 | 
127 | def main():
128 | 	""" Pack one or more i3dm and/or b3dm files into a cmpt"""
129 | 
130 | 	# Parse options and get results
131 | 	parser = argparse.ArgumentParser(description='Packs one or more i3dm and/or b3dm files into a cmpt')
132 | 	parser.add_argument("-o", "--output", type=str, required='True', \
133 | 						help="Output cmpt file")
134 | 	parser.add_argument("-u", "--unpack", action='store_true', \
135 | 	                    help="Unpack, rather than pack. Give input cmpt file as -o, output dir as input file")
136 | 	parser.add_argument('input_files', nargs='*')
137 | 	args = parser.parse_args()
138 | 
139 | 	if args.unpack:
140 | 		decoder = CmptDecoder()
141 | 		decoder.add(filename = args.output)
142 | 		decoder.decode()
143 | 
144 | 		tiles = decoder.getTiles()
145 | 		idx = 0
146 | 		for tile in tiles:
147 | 			output_fname = os.path.basename(args.output) + '-' + str(idx) + '.' + tile['magic']
148 | 			with open(os.path.join(args.input_files[0], output_fname), 'wb') as f:
149 | 				f.write(tile['data'])
150 | 	else:
151 | 		if not len(args.input_files):
152 | 			print("At least one input tile file must be specified!")
153 | 
154 | 		else:
155 | 			encoder = CmptEncoder()
156 | 			for fname in args.input_files:
157 | 				encoder.add(fname)
158 | 			encoder.export(args.output + ('' if args.output.endswith(CMPT_EXT) else CMPT_EXT))
159 | 
160 | if __name__ == "__main__":
161 | 	main()
162 | 


--------------------------------------------------------------------------------
/packglb.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | 
  3 | #------------------------------------
  4 | # packglb.py: GLB to I3DM/B3DM converter
  5 | # (c) 2018 - 2021 Geopipe, Inc.
  6 | # All rights reserved. See LICENSE.
  7 | #------------------------------------
  8 | 
  9 | import sys, os
 10 | import argparse
 11 | import base64
 12 | import json
 13 | import re
 14 | import struct
 15 | 
 16 | import b3dm, i3dm
 17 | 
 18 | def main():
 19 | 	""" Pack GLB into another container, with optional additional I3DM or B3DM encoding"""
 20 | 
 21 | 	# Parse options and get results
 22 | 	parser = argparse.ArgumentParser(description='Converts GLTF to GLB')
 23 | 	parser.add_argument("-i", "--i3dm", type=str, \
 24 | 	                    help="Export i3dm, with required path to input JSON instance table data. Supports only embedded GLTFs")
 25 | 	parser.add_argument("-b", "--b3dm", type=str, \
 26 | 	                    help="Export b3dm, with optional path to input JSON batch table data")
 27 | 	parser.add_argument("--objectwise", action='store_true', \
 28 | 	                    help="If b3dm is specified and this is set, assume list of dicts. Defaults otherwise to dict of lists")
 29 | 	parser.add_argument("-o", "--output", required=False, default=None, \
 30 | 	                    help="Optional output path (defaults to the path of the input file")
 31 | 	parser.add_argument("-u", "--unpack", action='store_true', \
 32 | 	                    help="Unpack rather than create b3dm file")
 33 | 	parser.add_argument("filename")
 34 | 	args = parser.parse_args()
 35 | 
 36 | 	if args.unpack and args.filename:
 37 | 		if args.b3dm:
 38 | 			b3dm_decoder = b3dm.B3DM()
 39 | 			with open(args.filename, 'rb') as f:
 40 | 				data = f.read()
 41 | 				b3dm_decoder.readBinary(data)
 42 | 			with open(args.filename + '.glb', 'wb') as f:
 43 | 				output_data = b3dm_decoder.getGLTFBin()
 44 | 				f.write(output_data)
 45 | 		elif args.i3dm:
 46 | 			i3dm_decoder = i3dm.I3DM()
 47 | 			with open(args.filename, 'rb') as f:
 48 | 				data = f.read()
 49 | 				i3dm_decoder.readBinary(data)
 50 | 			with open(args.filename + '.glb', 'wb') as f:
 51 | 				output_data = i3dm_decoder.getGLTFBin()
 52 | 				f.write(output_data)
 53 | 		else:
 54 | 			raise ValueError('Must specify -b (--b3dm) or -i (--i3dm) to unpack')
 55 | 		sys.exit(0)
 56 | 
 57 | 	# Make sure the input file is *.glb
 58 | 	if not args.filename.endswith('.glb'):
 59 | 		print("Failed to create packed binary GLB file: input is not *.glb")
 60 | 		sys.exit(-1)
 61 | 
 62 | 	with open(args.filename, 'rb') as f:
 63 | 		glb = f.read()
 64 | 
 65 | 	if args.b3dm != None:
 66 | 		ext = 'b3dm'
 67 | 	elif args.i3dm != None:
 68 | 		ext = 'i3dm'
 69 | 	else:
 70 | 		ext = 'glb'
 71 | 
 72 | 	fname_out = os.path.splitext(os.path.basename(args.filename))[0] + '.' + ext
 73 | 	if None != args.output:
 74 | 		if "" == os.path.basename(args.output):
 75 | 			fname_out = os.path.join(fname_out, fname_out)
 76 | 		else:
 77 | 			fname_out = args.output
 78 | 	else:
 79 | 		fname_out = os.path.join(os.path.dirname(args.filename), fname_out)
 80 | 
 81 | 	if args.b3dm != None:
 82 | 		b3dm_encoder = b3dm.B3DM()
 83 | 		if len(args.b3dm):
 84 | 			with open(args.b3dm, 'r') as f:
 85 | 				b3dm_json = json.loads(f.read())
 86 | 				#print b3dm_json
 87 | 				b3dm_encoder.loadJSONBatch(b3dm_json, args.objectwise)
 88 | 
 89 | 		with open(fname_out, 'wb') as f:
 90 | 			f.write(b3dm_encoder.writeBinary(glb))
 91 | 
 92 | 	elif args.i3dm != None:
 93 | 		i3dm_encoder = i3dm.I3DM()
 94 | 		if not(len(args.i3dm)):
 95 | 			raise ValueError("-i/--i3dm requires a JSON instance table")
 96 | 		else:
 97 | 			with open(args.i3dm, 'r') as f:
 98 | 				i3dm_json = json.loads(f.read())
 99 | 			i3dm_encoder.loadJSONInstances(i3dm_json, False)
100 | 
101 | 		with open(fname_out, 'wb') as f:
102 | 			f.write(i3dm_encoder.writeBinary(glb, True))		# Second arg: embed gltf
103 | 
104 | 	else:
105 | 		# This is kinda pointless
106 | 		with open(fname_out, 'wb') as f:
107 | 			f.write(glb)
108 | 
109 | if __name__ == "__main__":
110 | 	main()
111 | 


--------------------------------------------------------------------------------
/pnts.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | 
  3 | #--------------------------------------------
  4 | # pnts.py: Component of GLTF to GLB converter
  5 | # (c) 2020 - 2021 Geopipe, Inc.
  6 | # All rights reserved. See LICENSE.
  7 | #--------------------------------------------
  8 | 
  9 | import struct
 10 | from batchtable import BatchTable
 11 | from featuretable import InstanceFeatureTable
 12 | 
 13 | PNTS_MAGIC = 'pnts'
 14 | PNTS_VERSION = 1
 15 | PNTS_HEADER_LEN = 28
 16 | 
 17 | PNTS_SEMANTICS = {
 18 | 	'POSITION' : 'f32',
 19 | 	'NORMAL' : 'f32',
 20 | 	
 21 | 	'POSITION_QUANTIZED' : 'u16',
 22 | 	# this might get us in to trouble since it can actually also be u8 or u32
 23 | 	'BATCH_ID' : 'u16',
 24 | 	'RGB565' : 'u16',
 25 | 	
 26 | 	'NORMAL_OCT16P' : 'u8',
 27 | 	'RGBA' : 'u8',
 28 | 	'RGB' : 'u8'	
 29 | }
 30 | 
 31 | class PNTS(object):
 32 | 	def __init__(self):
 33 | 		self.batch_table = BatchTable()
 34 | 		self.feature_table = InstanceFeatureTable(PNTS_SEMANTICS)
 35 | 
 36 | 	def loadJSONBatch(self, data_in, object_wise = True):
 37 | 		self.batch_table.loadJSONBatch(data_in, object_wise)
 38 | 
 39 | 	def loadJSONFeature(self, data_in, object_wise = True):
 40 | 		self.feature_table.loadJSONBatch(data_in, object_wise)
 41 | 
 42 | 	def writeBinary(self, num_batch_features = 0, num_feature_features = 0):
 43 | 
 44 | 		# Add the required field BATCH_LENGTH to the feature table,
 45 | 		# as well as any other required globals
 46 | 		num_batch_features = max(num_batch_features, self.batch_table.getNumFeatures())
 47 | 		self.feature_table.addGlobal('BATCH_LENGTH', num_batch_features)
 48 | 		num_feature_features = max(num_feature_features, self.feature_table.getNumFeatures())
 49 | 		self.feature_table.addGlobal('POINTS_LENGTH', num_feature_features)
 50 | 
 51 | 		self.batch_table.finalize()
 52 | 		self.feature_table.finalize()
 53 | 
 54 | 		# Generate the header
 55 | 		output = self.writeHeader(num_batch_features, num_feature_features)
 56 | 
 57 | 		# Add the feature table JSON to the output
 58 | 		feature_json = self.feature_table.getFeatureJSON()
 59 | 		output.extend(feature_json)
 60 | 
 61 | 		# Add the feature table binary to the output
 62 | 		feature_bin  = self.feature_table.getFeatureBin()
 63 | 		output.extend(feature_bin)
 64 | 
 65 | 		# Add the batch table JSON to the output
 66 | 		batch_json = self.batch_table.getBatchJSON()
 67 | 		output.extend(batch_json)
 68 | 
 69 | 		# Add the batch table binary to the output
 70 | 		batch_bin  = self.batch_table.getBatchBin()
 71 | 		output.extend(batch_bin)
 72 | 
 73 | 		return output
 74 | 
 75 | 	def writeHeader(self, num_feature_features, num_batch_features):
 76 | 		len_feature_json = len(self.feature_table.getFeatureJSON())
 77 | 		len_feature_bin  = len(self.feature_table.getFeatureBin())
 78 | 		len_batch_json   = len(self.batch_table.getBatchJSON())
 79 | 		len_batch_bin    = len(self.batch_table.getBatchBin())
 80 | 
 81 | 		length = PNTS_HEADER_LEN + \
 82 | 		         len_feature_json + len_feature_bin + \
 83 | 		         len_batch_json   + len_batch_bin
 84 | 	
 85 | 		output = bytearray()
 86 | 		output.extend(PNTS_MAGIC.encode('utf-8'))
 87 | 		output.extend(struct.pack('<I', PNTS_VERSION))
 88 | 		output.extend(struct.pack('<I', length))
 89 | 		output.extend(struct.pack('<I', len_feature_json))
 90 | 		output.extend(struct.pack('<I', len_feature_bin))
 91 | 		output.extend(struct.pack('<I', len_batch_json))
 92 | 		output.extend(struct.pack('<I', len_batch_bin))
 93 | 	
 94 | 		# Sanity check
 95 | 		if (len(output) != PNTS_HEADER_LEN):
 96 | 			raise ValueError("Incorrect pnts header length")
 97 | 	
 98 | 		return output
 99 | 
100 | 	def readBinary(self, data):
101 | 		self.offset = 0
102 | 		self.readHeader(data)			 # What it says on the tin
103 | 
104 | 		# Now grab the feature table, batch table, and GLB
105 | 		self.feature_json = self.unpackString(data, self.len_feature_json)
106 | 		self.feature_bin =  self.unpackString(data, self.len_feature_bin)
107 | 		self.batch_json = self.unpackString(data, self.len_batch_json)
108 | 		self.batch_bin = self.unpackString(data, self.len_batch_bin)
109 | 
110 | 	def readHeader(self, data):
111 | 		self.magic = self.unpack('4s', data)
112 | 		self.version = self.unpack('<I', data)
113 | 
114 | 		if self.magic != PNTS_MAGIC or self.version > PNTS_VERSION:
115 | 			raise IOError("Unrecognized magic %s or bad version %d" % (self.magic, self.version))
116 | 
117 | 		self.length           = self.unpack('<I', data)
118 | 		self.len_feature_json = self.unpack('<I', data)
119 | 		self.len_feature_bin  = self.unpack('<I', data)
120 | 		self.len_batch_json   = self.unpack('<I', data)
121 | 		self.len_batch_bin    = self.unpack('<I', data)
122 | 
123 | 	def unpackString(self, data, length):
124 | 		self.offset += length
125 | 		return data[self.offset - length : self.offset]
126 | 
127 | 	def unpack(self, fmt, data):
128 | 		calc_len = struct.calcsize(fmt)
129 | 		self.offset += calc_len
130 | 		return struct.unpack(fmt, data[self.offset - calc_len : self.offset])[0]
131 | 
132 | def main():
133 | 	raise NotImplementedError("This file cannot be used directly!")
134 | 
135 | if __name__ == "__main__":
136 | 	main()
137 | 


--------------------------------------------------------------------------------
/tile3dinfo.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | #--------------------------------------------------------------------------
 3 | # tile3dinfo.py: Parse a CMPT, B3DM, or I3DM file (recursively) and deliver
 4 | # information about what it contains. Component of gltf2glb.
 5 | # (c) 2016-2021 Geopipe, Inc.
 6 | # All rights reserved. See LICENSE.
 7 | #--------------------------------------------------------------------------
 8 | 
 9 | import sys, os
10 | import argparse
11 | import struct
12 | 
13 | import packcmpt as cmpt
14 | import packglb
15 | import b3dm
16 | import i3dm
17 | 
18 | def printFeatureBatch(decoder, s_indent):
19 |     print("%s\tFeature JSON length: %d" % (s_indent, decoder.len_feature_json))
20 |     print("%s\tFeature binary length: %d" % (s_indent, decoder.len_feature_bin))
21 |     print("%s\tBatch JSON length: %d" % (s_indent, decoder.len_batch_json))
22 |     print("%s\tBatch binary length: %d" % (s_indent, decoder.len_batch_bin))
23 |     print("%s\tGLTF binary length: %d" % (s_indent, len(decoder.gltf_bin)))
24 | 
25 | def parseB3DM(data, indent = 0):
26 |     s_indent = '\t' * indent
27 |     b3dm_decoder = b3dm.B3DM()
28 |     b3dm_decoder.readBinary(data)
29 | 
30 |     print("%sB3DM File:" % (s_indent))
31 |     printFeatureBatch(b3dm_decoder, s_indent)
32 | 
33 | def parseI3DM(data, indent = 0):
34 |     s_indent = '\t' * indent
35 |     i3dm_decoder = i3dm.I3DM()
36 |     i3dm_decoder.readBinary(data)
37 | 
38 |     print("%sI3DM File:" % (s_indent))
39 |     printFeatureBatch(i3dm_decoder, s_indent)
40 | 
41 | def parseCMPT(data, indent = 0):
42 |     print("%sCMPT File:" % ('\t' * indent))
43 |     decoder = cmpt.CmptDecoder()
44 |     decoder.add(data = data)
45 |     decoder.decode()
46 | 
47 |     for tile in decoder.getTiles():
48 |         parseFile(tile['data'], indent + 1)
49 | 
50 | def parseFile(data, indent = 0):
51 |     if len(data) < 4:
52 |         raise ValueError('Binary is fewer than 4 bytes; no magic fits')
53 |     if data[0:4] == cmpt.CMPT_MAGIC:
54 |         parseCMPT(data, indent)
55 |     elif data[0:4] == b3dm.B3DM_MAGIC:
56 |         parseB3DM(data, indent)
57 |     elif data[0:4] == i3dm.I3DM_MAGIC:
58 |         parseI3DM(data, indent)
59 |     else:
60 |         raise ValueError('Unknown magic "%s"' % (data[0:4]))
61 | 
62 | def main():
63 |     """ Pack one or more i3dm and/or b3dm files into a cmpt"""
64 | 
65 |     # Parse options and get results
66 |     parser = argparse.ArgumentParser(description='Parses a cmpt, b3dm, i3dm, or glb file, and prints info about it')
67 |     parser.add_argument('input_file')
68 |     args = parser.parse_args()
69 | 
70 |     with open(args.input_file, 'rb') as f:
71 |         parseFile(f.read(), indent = 0)
72 | 
73 | if __name__ == '__main__':
74 |     main()
75 | 


--------------------------------------------------------------------------------