def _loadAssetInfo(self):
"""Load information in <asset> tag"""
assetnode = self.xmlnode.find(self.tag('asset'))
if assetnode is not None:
self.assetInfo = asset.Asset.load(self, {}, assetnode)
else:
self.assetInfo = asset.Asset()
def __init__(self,
filename=None,
ignore=None,
aux_file_loader=None,
zip_filename=None,
validate_output=False):
"""Load collada data from filename or file like object.
:param filename:
String containing path to filename to open or file-like object.
Uncompressed .dae files are supported, as well as zip file archives.
If this is set to ``None``, a new collada instance is created.
:param list ignore:
A list of :class:`common.DaeError` types that should be ignored
when loading the collada document. Instances of these types will
be added to :attr:`errors` after loading but won't be raised.
Only used if `filename` is not ``None``.
:param function aux_file_loader:
Referenced files (e.g. texture images) are loaded from disk when
reading from the local filesystem and from the zip archive when
loading from a zip file. If these files are coming from another source
(e.g. database) and/or you're loading with StringIO, set this to
a function that given a filename, returns the binary data in the file.
If `filename` is ``None``, you must set this parameter if you want to
load auxiliary files.
:param str zip_filename:
If the file being loaded is a zip archive, you can set this parameter
to indicate the file within the archive that should be loaded. If not
set, a file that ends with .dae will be searched.
:param bool validate_output:
If set to True, the XML written when calling :meth:`save` will be
validated against the COLLADA 1.4.1 schema. If validation fails, the
:class:`common.DaeSaveValidationError` exception will be thrown.
"""
self.errors = []
"""List of :class:`common.common.DaeError` objects representing errors encountered while loading collada file"""
self.assetInfo = None
"""Instance of :class:`collada.asset.Asset` containing asset information"""
self._geometries = IndexedList([], ('id', ))
self._controllers = IndexedList([], ('id', ))
self._animations = IndexedList([], ('id', ))
self._lights = IndexedList([], ('id', ))
self._cameras = IndexedList([], ('id', ))
self._images = IndexedList([], ('id', ))
self._effects = IndexedList([], ('id', ))
self._materials = IndexedList([], ('id', ))
self._nodes = IndexedList([], ('id', ))
self._scenes = IndexedList([], ('id', ))
self.scene = None
"""The default scene. This is either an instance of :class:`collada.scene.Scene` or `None`."""
# a function which will apply the namespace
self.tag = tag
if validate_output and schema:
self.validator = schema.ColladaValidator()
else:
self.validator = None
self.maskedErrors = []
if ignore is not None:
self.ignoreErrors(*ignore)
if filename is None:
self.filename = None
self.zfile = None
self.getFileData = self._nullGetFile
if aux_file_loader is not None:
self.getFileData = self._wrappedFileLoader(aux_file_loader)
self.xmlnode = ElementTree.ElementTree(
E.COLLADA(E.library_cameras(),
E.library_controllers(),
E.library_effects(),
E.library_geometries(),
E.library_images(),
E.library_lights(),
E.library_materials(),
E.library_nodes(),
E.library_visual_scenes(),
E.scene(),
version='1.4.1'))
"""ElementTree representation of the collada document"""
self.assetInfo = asset.Asset()
return
if isinstance(filename, basestring):
fdata = open(filename, 'rb')
self.filename = filename
self.getFileData = self._getFileFromDisk
else:
fdata = filename # assume it is a file like object
self.filename = None
self.getFileData = self._nullGetFile
strdata = fdata.read()
try:
self.zfile = zipfile.ZipFile(BytesIO(strdata), 'r')
except:
self.zfile = None
if self.zfile:
self.filename = ''
daefiles = []
if zip_filename is not None:
self.filename = zip_filename
else:
for name in self.zfile.namelist():
if name.upper().endswith('.DAE'):
daefiles.append(name)
for name in daefiles:
if not self.filename:
self.filename = name
elif "MACOSX" in self.filename:
self.filename = name
if not self.filename or self.filename not in self.zfile.namelist():
raise DaeIncompleteError(
'COLLADA file not found inside zip compressed file')
data = self.zfile.read(self.filename)
self.getFileData = self._getFileFromZip
else:
data = strdata
if aux_file_loader is not None:
self.getFileData = self._wrappedFileLoader(aux_file_loader)
etree_parser = ElementTree.XMLParser()
try:
self.xmlnode = ElementTree.ElementTree(element=None,
file=BytesIO(data))
except ElementTree.ParseError as e:
raise DaeMalformedError("XML Parsing Error: %s" % e)
# if we can't get the current namespace
# the tagger from above will use a hardcoded default
try:
# get the root node, same for both etree and lxml
xml_root = self.xmlnode.getroot()
if hasattr(xml_root, 'nsmap'):
# lxml has an nsmap
# use the first value in the namespace map
namespace = next(iter(xml_root.nsmap.values()))
elif hasattr(xml_root, 'tag'):
# for xml.etree we need to extract ns from root tag
namespace = xml_root.tag.split('}')[0].lstrip('{')
# create a tagging function using the extracted namespace
self.tag = tagger(namespace)
except BaseException:
# failed to extract a namespace, using default
traceback.print_exc()
# functions which will load various things into collada object
self._loadAssetInfo()
self._loadImages()
self._loadEffects()
self._loadMaterials()
self._loadAnimations()
self._loadGeometry()
self._loadControllers()
self._loadLights()
self._loadCameras()
self._loadNodes()
self._loadScenes()
self._loadDefaultScene()