12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250 |
- import copy
- import io
- import json
- import os.path
- import sys
- from typing import Any, Dict, List, Optional, Tuple, cast, Set
- import xml.etree.ElementTree as ET
- from UM.Resources import Resources
- from UM.Logger import Logger
- import UM.Dictionary
- from UM.Settings.InstanceContainer import InstanceContainer
- from UM.Settings.ContainerRegistry import ContainerRegistry
- from UM.ConfigurationErrorMessage import ConfigurationErrorMessage
- from cura.CuraApplication import CuraApplication
- from cura.Machines.VariantType import VariantType
- from .XmlMaterialValidator import XmlMaterialValidator
- class XmlMaterialProfile(InstanceContainer):
- CurrentFdmMaterialVersion = "1.3"
- Version = 1
- def __init__(self, container_id, *args, **kwargs):
- super().__init__(container_id, *args, **kwargs)
- self._inherited_files = []
-
-
-
-
-
-
-
-
-
- @classmethod
- def xmlVersionToSettingVersion(cls, xml_version: str) -> int:
- if xml_version == "1.3":
- return CuraApplication.SettingVersion
- return 0
- def getInheritedFiles(self):
- return self._inherited_files
-
-
-
-
-
-
-
-
- def setMetaDataEntry(self, key, value, apply_to_all = True):
- registry = ContainerRegistry.getInstance()
- if registry.isReadOnly(self.getId()):
- Logger.log("w", "Can't change metadata {key} of material {material_id} because it's read-only.".format(key = key, material_id = self.getId()))
- return
-
-
- new_setting_values_dict = {}
- if key == "properties":
- for k, v in value.items():
- if k in self.__material_properties_setting_map:
- new_setting_values_dict[self.__material_properties_setting_map[k]] = v
-
- if not apply_to_all:
- super().setMetaDataEntry(key, value)
- for k, v in new_setting_values_dict.items():
- self.setProperty(k, "value", v)
- return
-
- material_manager = CuraApplication.getInstance().getMaterialManager()
- root_material_id = self.getMetaDataEntry("base_file")
- material_group = material_manager.getMaterialGroup(root_material_id)
- if not material_group:
- super().setMetaDataEntry(key, value)
- for k, v in new_setting_values_dict.items():
- self.setProperty(k, "value", v)
- return
-
- root_material_container = material_group.root_material_node.getContainer()
- if root_material_container is not None:
- root_material_container.setMetaDataEntry(key, value, apply_to_all = False)
- for k, v in new_setting_values_dict.items():
- root_material_container.setProperty(k, "value", v)
-
- for node in material_group.derived_material_node_list:
- container = node.getContainer()
- if container is not None:
- container.setMetaDataEntry(key, value, apply_to_all = False)
- for k, v in new_setting_values_dict.items():
- container.setProperty(k, "value", v)
-
-
-
- def setName(self, new_name):
- registry = ContainerRegistry.getInstance()
- if registry.isReadOnly(self.getId()):
- return
-
- if self.getName() == new_name:
- return
- super().setName(new_name)
- basefile = self.getMetaDataEntry("base_file", self.getId())
-
-
- containers = registry.findInstanceContainers(base_file = basefile)
- for container in containers:
- container.setName(new_name)
-
- def setDirty(self, dirty):
- super().setDirty(dirty)
- base_file = self.getMetaDataEntry("base_file", None)
- registry = ContainerRegistry.getInstance()
- if base_file is not None and base_file != self.getId() and not registry.isReadOnly(base_file):
- containers = registry.findContainers(id = base_file)
- if containers:
- containers[0].setDirty(dirty)
-
-
-
- def serialize(self, ignored_metadata_keys: Optional[Set[str]] = None):
- registry = ContainerRegistry.getInstance()
- base_file = self.getMetaDataEntry("base_file", "")
- if base_file and self.getId() != base_file:
-
-
-
- raise NotImplementedError("Ignoring serializing non-root XML materials, the data is contained in the base material")
- builder = ET.TreeBuilder()
- root = builder.start("fdmmaterial",
- {"xmlns": "http://www.ultimaker.com/material",
- "xmlns:cura": "http://www.ultimaker.com/cura",
- "version": self.CurrentFdmMaterialVersion})
-
- builder.start("metadata")
- metadata = copy.deepcopy(self.getMetaData())
-
- if ignored_metadata_keys is None:
- ignored_metadata_keys = set()
- ignored_metadata_keys |= {"setting_version", "definition", "status", "variant", "type", "base_file", "approximate_diameter", "id", "container_type", "name", "compatible"}
-
- for key in ignored_metadata_keys:
- if key in metadata:
- del metadata[key]
- properties = metadata.pop("properties", {})
-
- builder.start("name")
- builder.start("brand")
- builder.data(metadata.pop("brand", ""))
- builder.end("brand")
- builder.start("material")
- builder.data(metadata.pop("material", ""))
- builder.end("material")
- builder.start("color")
- builder.data(metadata.pop("color_name", ""))
- builder.end("color")
- builder.start("label")
- builder.data(self.getName())
- builder.end("label")
- builder.end("name")
-
- for key, value in metadata.items():
- key_to_use = key
- if key in self._metadata_tags_that_have_cura_namespace:
- key_to_use = "cura:" + key_to_use
- builder.start(key_to_use)
- if value is not None:
-
-
- value = str(value)
- builder.data(value)
- builder.end(key_to_use)
- builder.end("metadata")
-
-
- builder.start("properties")
- for key, value in properties.items():
- builder.start(key)
- builder.data(value)
- builder.end(key)
- builder.end("properties")
-
-
- builder.start("settings")
- if self.getMetaDataEntry("definition") == "fdmprinter":
- for instance in self.findInstances():
- self._addSettingElement(builder, instance)
- machine_container_map = {}
- machine_variant_map = {}
- variant_manager = CuraApplication.getInstance().getVariantManager()
- root_material_id = self.getMetaDataEntry("base_file")
- all_containers = registry.findInstanceContainers(base_file = root_material_id)
- for container in all_containers:
- definition_id = container.getMetaDataEntry("definition")
- if definition_id == "fdmprinter":
- continue
- if definition_id not in machine_container_map:
- machine_container_map[definition_id] = container
- if definition_id not in machine_variant_map:
- machine_variant_map[definition_id] = {}
- variant_name = container.getMetaDataEntry("variant_name")
- if variant_name:
- variant_dict = {"variant_node": variant_manager.getVariantNode(definition_id, variant_name),
- "material_container": container}
- machine_variant_map[definition_id][variant_name] = variant_dict
- continue
- machine_container_map[definition_id] = container
-
- product_id_map = self.getProductIdMap()
- for definition_id, container in machine_container_map.items():
- definition_id = container.getMetaDataEntry("definition")
- definition_metadata = registry.findDefinitionContainersMetadata(id = definition_id)[0]
- product = definition_id
- for product_name, product_id_list in product_id_map.items():
- if definition_id in product_id_list:
- product = product_name
- break
- builder.start("machine")
- builder.start("machine_identifier", {
- "manufacturer": container.getMetaDataEntry("machine_manufacturer",
- definition_metadata.get("manufacturer", "Unknown")),
- "product": product
- })
- builder.end("machine_identifier")
- for instance in container.findInstances():
- if self.getMetaDataEntry("definition") == "fdmprinter" and self.getInstance(instance.definition.key) and self.getProperty(instance.definition.key, "value") == instance.value:
-
- continue
- self._addSettingElement(builder, instance)
-
- buildplate_dict = {}
- for variant_name, variant_dict in machine_variant_map[definition_id].items():
- variant_type = variant_dict["variant_node"].getMetaDataEntry("hardware_type", str(VariantType.NOZZLE))
- variant_type = VariantType(variant_type)
- if variant_type == VariantType.NOZZLE:
-
- builder.start("hotend", {"id": variant_name})
-
- material_container = variant_dict["material_container"]
- compatible = material_container.getMetaDataEntry("compatible")
- if compatible is not None:
- builder.start("setting", {"key": "hardware compatible"})
- if compatible:
- builder.data("yes")
- else:
- builder.data("no")
- builder.end("setting")
- for instance in material_container.findInstances():
- if container.getInstance(instance.definition.key) and container.getProperty(instance.definition.key, "value") == instance.value:
-
- continue
- self._addSettingElement(builder, instance)
- if material_container.getMetaDataEntry("buildplate_compatible") and not buildplate_dict:
- buildplate_dict["buildplate_compatible"] = material_container.getMetaDataEntry("buildplate_compatible")
- buildplate_dict["buildplate_recommended"] = material_container.getMetaDataEntry("buildplate_recommended")
- buildplate_dict["material_container"] = material_container
- builder.end("hotend")
- if buildplate_dict:
- for variant_name in buildplate_dict["buildplate_compatible"]:
- builder.start("buildplate", {"id": variant_name})
- material_container = buildplate_dict["material_container"]
- buildplate_compatible_dict = material_container.getMetaDataEntry("buildplate_compatible")
- buildplate_recommended_dict = material_container.getMetaDataEntry("buildplate_recommended")
- if buildplate_compatible_dict:
- compatible = buildplate_compatible_dict[variant_name]
- recommended = buildplate_recommended_dict[variant_name]
- builder.start("setting", {"key": "hardware compatible"})
- builder.data("yes" if compatible else "no")
- builder.end("setting")
- builder.start("setting", {"key": "hardware recommended"})
- builder.data("yes" if recommended else "no")
- builder.end("setting")
- builder.end("buildplate")
- builder.end("machine")
- builder.end("settings")
-
- builder.end("fdmmaterial")
- root = builder.close()
- _indent(root)
- stream = io.BytesIO()
- tree = ET.ElementTree(root)
-
- tree.write(stream, encoding = "utf-8", xml_declaration=True)
- return stream.getvalue().decode("utf-8")
-
- def _resolveInheritance(self, file_name):
- xml = self._loadFile(file_name)
- inherits = xml.find("./um:inherits", self.__namespaces)
- if inherits is not None:
- inherited = self._resolveInheritance(inherits.text)
- xml = self._mergeXML(inherited, xml)
- return xml
- def _loadFile(self, file_name):
- path = Resources.getPath(CuraApplication.getInstance().ResourceTypes.MaterialInstanceContainer, file_name + ".xml.fdm_material")
- with open(path, encoding = "utf-8") as f:
- contents = f.read()
- self._inherited_files.append(path)
- return ET.fromstring(contents)
-
-
-
- def _expandMachinesXML(self, element):
- settings_element = element.find("./um:settings", self.__namespaces)
- machines = settings_element.iterfind("./um:machine", self.__namespaces)
- machines_to_add = []
- machines_to_remove = []
- for machine in machines:
- identifiers = list(machine.iterfind("./um:machine_identifier", self.__namespaces))
- has_multiple_identifiers = len(identifiers) > 1
- if has_multiple_identifiers:
-
- for identifier in identifiers:
- new_machine = copy.deepcopy(machine)
-
- other_identifiers = [self._createKey(other_identifier) for other_identifier in identifiers if other_identifier is not identifier]
-
- new_machine_identifiers = list(new_machine.iterfind("./um:machine_identifier", self.__namespaces))
- for new_machine_identifier in new_machine_identifiers:
- key = self._createKey(new_machine_identifier)
-
- if key in other_identifiers:
- new_machine.remove(new_machine_identifier)
- machines_to_add.append(new_machine)
- machines_to_remove.append(machine)
- else:
- pass
-
- for machine_to_remove in machines_to_remove:
- settings_element.remove(machine_to_remove)
- for machine_to_add in machines_to_add:
- settings_element.append(machine_to_add)
- return element
- def _mergeXML(self, first, second):
- result = copy.deepcopy(first)
- self._combineElement(self._expandMachinesXML(result), self._expandMachinesXML(second))
- return result
- def _createKey(self, element):
- key = element.tag.split("}")[-1]
- if "key" in element.attrib:
- key += " key:" + element.attrib["key"]
- if "manufacturer" in element.attrib:
- key += " manufacturer:" + element.attrib["manufacturer"]
- if "product" in element.attrib:
- key += " product:" + element.attrib["product"]
- if key == "machine":
- for item in element:
- if "machine_identifier" in item.tag:
- key += " " + item.attrib["product"]
- return key
-
-
- def _combineElement(self, first, second):
-
- mapping = {}
- for element in first:
- key = self._createKey(element)
- mapping[key] = element
- for element in second:
- key = self._createKey(element)
- if len(element):
- try:
- if "setting" in element.tag and not "settings" in element.tag:
-
- for child in list(mapping[key]):
- mapping[key].remove(child)
- for child in element:
- mapping[key].append(child)
- else:
- self._combineElement(mapping[key], element)
- except KeyError:
- mapping[key] = element
- first.append(element)
- else:
- try:
- mapping[key].text = element.text
- except KeyError:
- mapping[key] = element
- first.append(element)
- def clearData(self):
- self._metadata = {
- "id": self.getId(),
- "name": ""
- }
- self._definition = None
- self._instances = {}
- self._read_only = False
- self._dirty = False
- self._path = ""
- @classmethod
- def getConfigurationTypeFromSerialized(cls, serialized: str) -> Optional[str]:
- return "materials"
- @classmethod
- def getVersionFromSerialized(cls, serialized: str) -> Optional[int]:
- data = ET.fromstring(serialized)
- version = XmlMaterialProfile.Version
-
- if "version" in data.attrib:
- setting_version = cls.xmlVersionToSettingVersion(data.attrib["version"])
- else:
- setting_version = cls.xmlVersionToSettingVersion("1.2")
- return version * 1000000 + setting_version
-
- def deserialize(self, serialized, file_name = None):
- containers_to_add = []
-
- from UM.Settings.Interfaces import ContainerInterface
- serialized = ContainerInterface.deserialize(self, serialized, file_name)
- try:
- data = ET.fromstring(serialized)
- except:
- Logger.logException("e", "An exception occurred while parsing the material profile")
- return
-
- old_id = self.getId()
- self.clearData()
- meta_data = {}
- meta_data["type"] = "material"
- meta_data["base_file"] = self.getId()
- meta_data["status"] = "unknown"
- meta_data["id"] = old_id
- meta_data["container_type"] = XmlMaterialProfile
- common_setting_values = {}
- inherits = data.find("./um:inherits", self.__namespaces)
- if inherits is not None:
- inherited = self._resolveInheritance(inherits.text)
- data = self._mergeXML(inherited, data)
-
- if "version" in data.attrib:
- meta_data["setting_version"] = self.xmlVersionToSettingVersion(data.attrib["version"])
- else:
- meta_data["setting_version"] = self.xmlVersionToSettingVersion("1.2")
- meta_data["name"] = "Unknown Material"
- for entry in data.iterfind("./um:metadata/*", self.__namespaces):
- tag_name = _tag_without_namespace(entry)
- if tag_name == "name":
- brand = entry.find("./um:brand", self.__namespaces)
- material = entry.find("./um:material", self.__namespaces)
- color = entry.find("./um:color", self.__namespaces)
- label = entry.find("./um:label", self.__namespaces)
- if label is not None and label.text is not None:
- meta_data["name"] = label.text
- else:
- meta_data["name"] = self._profile_name(material.text, color.text)
- meta_data["brand"] = brand.text if brand.text is not None else "Unknown Brand"
- meta_data["material"] = material.text if material.text is not None else "Unknown Type"
- meta_data["color_name"] = color.text if color.text is not None else "Unknown Color"
- continue
-
- if tag_name == "setting_version":
- continue
- meta_data[tag_name] = entry.text
- if tag_name in self.__material_metadata_setting_map:
- common_setting_values[self.__material_metadata_setting_map[tag_name]] = entry.text
- if "description" not in meta_data:
- meta_data["description"] = ""
- if "adhesion_info" not in meta_data:
- meta_data["adhesion_info"] = ""
- validation_message = XmlMaterialValidator.validateMaterialMetaData(meta_data)
- if validation_message is not None:
- ConfigurationErrorMessage.getInstance().addFaultyContainers(self.getId())
- Logger.log("e", "Not a valid material profile: {message}".format(message = validation_message))
- return
- property_values = {}
- properties = data.iterfind("./um:properties/*", self.__namespaces)
- for entry in properties:
- tag_name = _tag_without_namespace(entry)
- property_values[tag_name] = entry.text
- if tag_name in self.__material_properties_setting_map:
- common_setting_values[self.__material_properties_setting_map[tag_name]] = entry.text
- meta_data["approximate_diameter"] = str(round(float(property_values.get("diameter", 2.85))))
- meta_data["properties"] = property_values
- meta_data["definition"] = "fdmprinter"
- common_compatibility = True
- settings = data.iterfind("./um:settings/um:setting", self.__namespaces)
- for entry in settings:
- key = entry.get("key")
- if key in self.__material_settings_setting_map:
- if key == "processing temperature graph":
- graph_nodes = entry.iterfind("./um:point", self.__namespaces)
- graph_points = []
- for graph_node in graph_nodes:
- flow = float(graph_node.get("flow"))
- temperature = float(graph_node.get("temperature"))
- graph_points.append([flow, temperature])
- common_setting_values[self.__material_settings_setting_map[key]] = str(graph_points)
- else:
- common_setting_values[self.__material_settings_setting_map[key]] = entry.text
- elif key in self.__unmapped_settings:
- if key == "hardware compatible":
- common_compatibility = self._parseCompatibleValue(entry.text)
-
- settings = data.iterfind("./um:settings/cura:setting", self.__namespaces)
- for entry in settings:
- value = entry.text
- if value.lower() == "yes":
- value = True
- elif value.lower() == "no":
- value = False
- key = entry.get("key")
- common_setting_values[key] = value
- self._cached_values = common_setting_values
- meta_data["compatible"] = common_compatibility
- self.setMetaData(meta_data)
- self._dirty = False
-
- product_id_map = self.getProductIdMap()
- machines = data.iterfind("./um:settings/um:machine", self.__namespaces)
- for machine in machines:
- machine_compatibility = common_compatibility
- machine_setting_values = {}
- settings = machine.iterfind("./um:setting", self.__namespaces)
- for entry in settings:
- key = entry.get("key")
- if key in self.__material_settings_setting_map:
- if key == "processing temperature graph":
- graph_nodes = entry.iterfind("./um:point", self.__namespaces)
- graph_points = []
- for graph_node in graph_nodes:
- flow = float(graph_node.get("flow"))
- temperature = float(graph_node.get("temperature"))
- graph_points.append([flow, temperature])
- machine_setting_values[self.__material_settings_setting_map[key]] = str(graph_points)
- else:
- machine_setting_values[self.__material_settings_setting_map[key]] = entry.text
- elif key in self.__unmapped_settings:
- if key == "hardware compatible":
- machine_compatibility = self._parseCompatibleValue(entry.text)
- else:
- Logger.log("d", "Unsupported material setting %s", key)
-
- settings = machine.iterfind("./cura:setting", self.__namespaces)
- for entry in settings:
- value = entry.text
- if value.lower() == "yes":
- value = True
- elif value.lower() == "no":
- value = False
- key = entry.get("key")
- machine_setting_values[key] = value
- cached_machine_setting_properties = common_setting_values.copy()
- cached_machine_setting_properties.update(machine_setting_values)
- identifiers = machine.iterfind("./um:machine_identifier", self.__namespaces)
- for identifier in identifiers:
- machine_id_list = product_id_map.get(identifier.get("product"), [])
- if not machine_id_list:
- machine_id_list = self.getPossibleDefinitionIDsFromName(identifier.get("product"))
- for machine_id in machine_id_list:
- definitions = ContainerRegistry.getInstance().findDefinitionContainersMetadata(id = machine_id)
- if not definitions:
- continue
- definition = definitions[0]
- machine_manufacturer = identifier.get("manufacturer", definition.get("manufacturer", "Unknown"))
-
-
- new_material_id = self.getId() + "_" + machine_id
-
-
-
-
- if ContainerRegistry.getInstance().isLoaded(new_material_id):
- new_material = ContainerRegistry.getInstance().findContainers(id = new_material_id)[0]
- is_new_material = False
- else:
- new_material = XmlMaterialProfile(new_material_id)
- is_new_material = True
- new_material.setMetaData(copy.deepcopy(self.getMetaData()))
- new_material.getMetaData()["id"] = new_material_id
- new_material.getMetaData()["name"] = self.getName()
- new_material.setDefinition(machine_id)
-
- new_material.getMetaData()["compatible"] = machine_compatibility
- new_material.getMetaData()["machine_manufacturer"] = machine_manufacturer
- new_material.getMetaData()["definition"] = machine_id
- new_material.setCachedValues(cached_machine_setting_properties)
- new_material._dirty = False
- if is_new_material:
- containers_to_add.append(new_material)
-
- buildplates = machine.iterfind("./um:buildplate", self.__namespaces)
- buildplate_map = {}
- buildplate_map["buildplate_compatible"] = {}
- buildplate_map["buildplate_recommended"] = {}
- for buildplate in buildplates:
- buildplate_id = buildplate.get("id")
- if buildplate_id is None:
- continue
- variant_manager = CuraApplication.getInstance().getVariantManager()
- variant_node = variant_manager.getVariantNode(machine_id, buildplate_id,
- variant_type = VariantType.BUILD_PLATE)
- if not variant_node:
- continue
- _, buildplate_unmapped_settings_dict = self._getSettingsDictForNode(buildplate)
- buildplate_compatibility = buildplate_unmapped_settings_dict.get("hardware compatible",
- machine_compatibility)
- buildplate_recommended = buildplate_unmapped_settings_dict.get("hardware recommended",
- machine_compatibility)
- buildplate_map["buildplate_compatible"][buildplate_id] = buildplate_compatibility
- buildplate_map["buildplate_recommended"][buildplate_id] = buildplate_recommended
- hotends = machine.iterfind("./um:hotend", self.__namespaces)
- for hotend in hotends:
-
- hotend_name = hotend.get("id")
- if hotend_name is None:
- continue
- variant_manager = CuraApplication.getInstance().getVariantManager()
- variant_node = variant_manager.getVariantNode(machine_id, hotend_name, VariantType.NOZZLE)
- if not variant_node:
- continue
- hotend_mapped_settings, hotend_unmapped_settings = self._getSettingsDictForNode(hotend)
- hotend_compatibility = hotend_unmapped_settings.get("hardware compatible", machine_compatibility)
-
- new_hotend_specific_material_id = self.getId() + "_" + machine_id + "_" + hotend_name.replace(" ", "_")
-
- if ContainerRegistry.getInstance().isLoaded(new_hotend_specific_material_id):
- new_hotend_material = ContainerRegistry.getInstance().findContainers(id = new_hotend_specific_material_id)[0]
- is_new_material = False
- else:
- new_hotend_material = XmlMaterialProfile(new_hotend_specific_material_id)
- is_new_material = True
- new_hotend_material.setMetaData(copy.deepcopy(self.getMetaData()))
- new_hotend_material.getMetaData()["id"] = new_hotend_specific_material_id
- new_hotend_material.getMetaData()["name"] = self.getName()
- new_hotend_material.getMetaData()["variant_name"] = hotend_name
- new_hotend_material.setDefinition(machine_id)
-
- new_hotend_material.getMetaData()["compatible"] = hotend_compatibility
- new_hotend_material.getMetaData()["machine_manufacturer"] = machine_manufacturer
- new_hotend_material.getMetaData()["definition"] = machine_id
- if buildplate_map["buildplate_compatible"]:
- new_hotend_material.getMetaData()["buildplate_compatible"] = buildplate_map["buildplate_compatible"]
- new_hotend_material.getMetaData()["buildplate_recommended"] = buildplate_map["buildplate_recommended"]
- cached_hotend_setting_properties = cached_machine_setting_properties.copy()
- cached_hotend_setting_properties.update(hotend_mapped_settings)
- new_hotend_material.setCachedValues(cached_hotend_setting_properties)
- new_hotend_material._dirty = False
- if is_new_material:
- containers_to_add.append(new_hotend_material)
-
-
-
- buildplates = hotend.iterfind("./um:buildplate", self.__namespaces)
- for buildplate in buildplates:
-
- buildplate_name = buildplate.get("id")
- if buildplate_name is None:
- continue
- variant_manager = CuraApplication.getInstance().getVariantManager()
- variant_node = variant_manager.getVariantNode(machine_id, buildplate_name, VariantType.BUILD_PLATE)
- if not variant_node:
- continue
- buildplate_mapped_settings, buildplate_unmapped_settings = self._getSettingsDictForNode(buildplate)
- buildplate_compatibility = buildplate_unmapped_settings.get("hardware compatible",
- buildplate_map["buildplate_compatible"])
- buildplate_recommended = buildplate_unmapped_settings.get("hardware recommended",
- buildplate_map["buildplate_recommended"])
-
- new_hotend_and_buildplate_specific_material_id = new_hotend_specific_material_id + "_" + buildplate_name.replace(" ", "_")
-
- if ContainerRegistry.getInstance().isLoaded(new_hotend_and_buildplate_specific_material_id):
- new_hotend_and_buildplate_material = ContainerRegistry.getInstance().findContainers(id = new_hotend_and_buildplate_specific_material_id)[0]
- is_new_material = False
- else:
- new_hotend_and_buildplate_material = XmlMaterialProfile(new_hotend_and_buildplate_specific_material_id)
- is_new_material = True
- new_hotend_and_buildplate_material.setMetaData(copy.deepcopy(new_hotend_material.getMetaData()))
- new_hotend_and_buildplate_material.getMetaData()["id"] = new_hotend_and_buildplate_specific_material_id
- new_hotend_and_buildplate_material.getMetaData()["name"] = self.getName()
- new_hotend_and_buildplate_material.getMetaData()["variant_name"] = hotend_name
- new_hotend_and_buildplate_material.getMetaData()["buildplate_name"] = buildplate_name
- new_hotend_and_buildplate_material.setDefinition(machine_id)
-
- new_hotend_and_buildplate_material.getMetaData()["compatible"] = buildplate_compatibility
- new_hotend_and_buildplate_material.getMetaData()["machine_manufacturer"] = machine_manufacturer
- new_hotend_and_buildplate_material.getMetaData()["definition"] = machine_id
- new_hotend_and_buildplate_material.getMetaData()["buildplate_compatible"] = buildplate_compatibility
- new_hotend_and_buildplate_material.getMetaData()["buildplate_recommended"] = buildplate_recommended
- cached_hotend_and_buildplate_setting_properties = cached_hotend_setting_properties.copy()
- cached_hotend_and_buildplate_setting_properties.update(buildplate_mapped_settings)
- new_hotend_and_buildplate_material.setCachedValues(cached_hotend_and_buildplate_setting_properties)
- new_hotend_and_buildplate_material._dirty = False
- if is_new_material:
- containers_to_add.append(new_hotend_and_buildplate_material)
-
-
- break
- for container_to_add in containers_to_add:
- ContainerRegistry.getInstance().addContainer(container_to_add)
- @classmethod
- def _getSettingsDictForNode(cls, node) -> Tuple[dict, dict]:
- node_mapped_settings_dict = dict()
- node_unmapped_settings_dict = dict()
-
- um_settings = node.iterfind("./um:setting", cls.__namespaces)
- for um_setting_entry in um_settings:
- setting_key = um_setting_entry.get("key")
-
- if setting_key in cls.__material_settings_setting_map:
- if setting_key == "processing temperature graph":
- graph_nodes = um_setting_entry.iterfind("./um:point", cls.__namespaces)
- graph_points = []
- for graph_node in graph_nodes:
- flow = float(graph_node.get("flow"))
- temperature = float(graph_node.get("temperature"))
- graph_points.append([flow, temperature])
- node_mapped_settings_dict[cls.__material_settings_setting_map[setting_key]] = str(
- graph_points)
- else:
- node_mapped_settings_dict[cls.__material_settings_setting_map[setting_key]] = um_setting_entry.text
-
- elif setting_key in cls.__unmapped_settings:
- if setting_key in ("hardware compatible", "hardware recommended"):
- node_unmapped_settings_dict[setting_key] = cls._parseCompatibleValue(um_setting_entry.text)
-
- else:
- Logger.log("w", "Unsupported material setting %s", setting_key)
-
- cura_settings = node.iterfind("./cura:setting", cls.__namespaces)
- for cura_setting_entry in cura_settings:
- value = cura_setting_entry.text
- if value.lower() == "yes":
- value = True
- elif value.lower() == "no":
- value = False
- key = cura_setting_entry.get("key")
-
- node_mapped_settings_dict[key] = value
- return node_mapped_settings_dict, node_unmapped_settings_dict
- @classmethod
- def deserializeMetadata(cls, serialized: str, container_id: str) -> List[Dict[str, Any]]:
- result_metadata = []
-
- serialized = cls._updateSerialized(serialized)
- base_metadata = {
- "type": "material",
- "status": "unknown",
- "container_type": XmlMaterialProfile,
- "id": container_id,
- "base_file": container_id
- }
- try:
- data = ET.fromstring(serialized)
- except:
- Logger.logException("e", "An exception occurred while parsing the material profile")
- return []
-
- if "version" in data.attrib:
- base_metadata["setting_version"] = cls.xmlVersionToSettingVersion(data.attrib["version"])
- else:
- base_metadata["setting_version"] = cls.xmlVersionToSettingVersion("1.2")
- for entry in data.iterfind("./um:metadata/*", cls.__namespaces):
- tag_name = _tag_without_namespace(entry)
- if tag_name == "name":
- brand = entry.find("./um:brand", cls.__namespaces)
- material = entry.find("./um:material", cls.__namespaces)
- color = entry.find("./um:color", cls.__namespaces)
- label = entry.find("./um:label", cls.__namespaces)
- if label is not None and label.text is not None:
- base_metadata["name"] = label.text
- else:
- if material is not None and color is not None:
- base_metadata["name"] = cls._profile_name(material.text, color.text)
- else:
- base_metadata["name"] = "Unknown Material"
- base_metadata["brand"] = brand.text if brand is not None and brand.text is not None else "Unknown Brand"
- base_metadata["material"] = material.text if material is not None and material.text is not None else "Unknown Type"
- base_metadata["color_name"] = color.text if color is not None and color.text is not None else "Unknown Color"
- continue
-
- if tag_name == "setting_version":
- continue
- base_metadata[tag_name] = entry.text
- if "description" not in base_metadata:
- base_metadata["description"] = ""
- if "adhesion_info" not in base_metadata:
- base_metadata["adhesion_info"] = ""
- property_values = {}
- properties = data.iterfind("./um:properties/*", cls.__namespaces)
- for entry in properties:
- tag_name = _tag_without_namespace(entry)
- property_values[tag_name] = entry.text
- base_metadata["approximate_diameter"] = str(round(float(cast(float, property_values.get("diameter", 2.85)))))
- base_metadata["properties"] = property_values
- base_metadata["definition"] = "fdmprinter"
- compatible_entries = data.iterfind("./um:settings/um:setting[@key='hardware compatible']", cls.__namespaces)
- try:
- common_compatibility = cls._parseCompatibleValue(next(compatible_entries).text)
- except StopIteration:
- common_compatibility = True
- base_metadata["compatible"] = common_compatibility
- result_metadata.append(base_metadata)
-
- product_id_map = cls.getProductIdMap()
- for machine in data.iterfind("./um:settings/um:machine", cls.__namespaces):
- machine_compatibility = common_compatibility
- for entry in machine.iterfind("./um:setting[@key='hardware compatible']", cls.__namespaces):
- if entry.text is not None:
- machine_compatibility = cls._parseCompatibleValue(entry.text)
- for identifier in machine.iterfind("./um:machine_identifier", cls.__namespaces):
- machine_id_list = product_id_map.get(identifier.get("product", ""), [])
- if not machine_id_list:
- machine_id_list = cls.getPossibleDefinitionIDsFromName(identifier.get("product"))
- for machine_id in machine_id_list:
- definition_metadatas = ContainerRegistry.getInstance().findDefinitionContainersMetadata(id = machine_id)
- if not definition_metadatas:
- continue
- definition_metadata = definition_metadatas[0]
- machine_manufacturer = identifier.get("manufacturer", definition_metadata.get("manufacturer", "Unknown"))
-
-
- new_material_id = container_id + "_" + machine_id
-
-
-
-
- new_material_metadata = {}
- new_material_metadata.update(base_metadata)
- new_material_metadata["id"] = new_material_id
- new_material_metadata["compatible"] = machine_compatibility
- new_material_metadata["machine_manufacturer"] = machine_manufacturer
- new_material_metadata["definition"] = machine_id
- result_metadata.append(new_material_metadata)
- buildplates = machine.iterfind("./um:buildplate", cls.__namespaces)
- buildplate_map = {}
- buildplate_map["buildplate_compatible"] = {}
- buildplate_map["buildplate_recommended"] = {}
- for buildplate in buildplates:
- buildplate_id = buildplate.get("id")
- if buildplate_id is None:
- continue
- variant_metadata = ContainerRegistry.getInstance().findInstanceContainersMetadata(id = buildplate_id)
- if not variant_metadata:
-
- variant_metadata = ContainerRegistry.getInstance().findInstanceContainersMetadata(definition = machine_id, name = buildplate_id)
- if not variant_metadata:
- continue
- settings = buildplate.iterfind("./um:setting", cls.__namespaces)
- buildplate_compatibility = True
- buildplate_recommended = True
- for entry in settings:
- key = entry.get("key")
- if entry.text is not None:
- if key == "hardware compatible":
- buildplate_compatibility = cls._parseCompatibleValue(entry.text)
- elif key == "hardware recommended":
- buildplate_recommended = cls._parseCompatibleValue(entry.text)
- buildplate_map["buildplate_compatible"][buildplate_id] = buildplate_compatibility
- buildplate_map["buildplate_recommended"][buildplate_id] = buildplate_recommended
- for hotend in machine.iterfind("./um:hotend", cls.__namespaces):
- hotend_name = hotend.get("id")
- if hotend_name is None:
- continue
- hotend_compatibility = machine_compatibility
- for entry in hotend.iterfind("./um:setting[@key='hardware compatible']", cls.__namespaces):
- if entry.text is not None:
- hotend_compatibility = cls._parseCompatibleValue(entry.text)
- new_hotend_specific_material_id = container_id + "_" + machine_id + "_" + hotend_name.replace(" ", "_")
-
- new_hotend_material_metadata = {}
- new_hotend_material_metadata.update(base_metadata)
- new_hotend_material_metadata["variant_name"] = hotend_name
- new_hotend_material_metadata["compatible"] = hotend_compatibility
- new_hotend_material_metadata["machine_manufacturer"] = machine_manufacturer
- new_hotend_material_metadata["id"] = new_hotend_specific_material_id
- new_hotend_material_metadata["definition"] = machine_id
- if buildplate_map["buildplate_compatible"]:
- new_hotend_material_metadata["buildplate_compatible"] = buildplate_map["buildplate_compatible"]
- new_hotend_material_metadata["buildplate_recommended"] = buildplate_map["buildplate_recommended"]
- result_metadata.append(new_hotend_material_metadata)
-
-
-
- buildplates = hotend.iterfind("./um:buildplate", cls.__namespaces)
- for buildplate in buildplates:
-
- buildplate_name = buildplate.get("id")
- if buildplate_name is None:
- continue
- buildplate_mapped_settings, buildplate_unmapped_settings = cls._getSettingsDictForNode(buildplate)
- buildplate_compatibility = buildplate_unmapped_settings.get("hardware compatible",
- buildplate_map["buildplate_compatible"])
- buildplate_recommended = buildplate_unmapped_settings.get("hardware recommended",
- buildplate_map["buildplate_recommended"])
-
- new_hotend_and_buildplate_specific_material_id = new_hotend_specific_material_id + "_" + buildplate_name.replace(
- " ", "_")
- new_hotend_and_buildplate_material_metadata = {}
- new_hotend_and_buildplate_material_metadata.update(new_hotend_material_metadata)
- new_hotend_and_buildplate_material_metadata["id"] = new_hotend_and_buildplate_specific_material_id
- new_hotend_and_buildplate_material_metadata["buildplate_name"] = buildplate_name
- new_hotend_and_buildplate_material_metadata["compatible"] = buildplate_compatibility
- new_hotend_and_buildplate_material_metadata["buildplate_compatible"] = buildplate_compatibility
- new_hotend_and_buildplate_material_metadata["buildplate_recommended"] = buildplate_recommended
- result_metadata.append(new_hotend_and_buildplate_material_metadata)
-
-
- break
- return result_metadata
- def _addSettingElement(self, builder, instance):
- key = instance.definition.key
- if key in self.__material_settings_setting_map.values():
-
- key = UM.Dictionary.findKey(self.__material_settings_setting_map, instance.definition.key)
- tag_name = "setting"
- if key == "processing temperature graph":
- builder.start(tag_name, {"key": key})
- graph_str = str(instance.value)
- graph = graph_str.replace("[", "").replace("]", "").split(", ")
- graph = [graph[i:i + 2] for i in range(0, len(graph) - 1, 2)]
- for point in graph:
- builder.start("point", {"flow": point[0], "temperature": point[1]})
- builder.end("point")
- builder.end(tag_name)
- return
- elif key not in self.__material_properties_setting_map.values() and key not in self.__material_metadata_setting_map.values():
-
- tag_name = "cura:setting"
- else:
-
- return
- if instance.value is True:
- data = "yes"
- elif instance.value is False:
- data = "no"
- else:
- data = str(instance.value)
- builder.start(tag_name, { "key": key })
- builder.data(data)
- builder.end(tag_name)
- @classmethod
- def _profile_name(cls, material_name, color_name):
- if material_name is None:
- return "Unknown Material"
- if color_name != "Generic":
- return "%s %s" % (color_name, material_name)
- else:
- return material_name
- @classmethod
- def getPossibleDefinitionIDsFromName(cls, name):
- name_parts = name.lower().split(" ")
- merged_name_parts = []
- for part in name_parts:
- if len(part) == 0:
- continue
- if len(merged_name_parts) == 0:
- merged_name_parts.append(part)
- continue
- if part.isdigit():
-
-
- merged_name_parts[-1] = merged_name_parts[-1] + part
- else:
- merged_name_parts.append(part)
- id_list = {name.lower().replace(" ", ""),
- name.lower().replace(" ", "_"),
- "_".join(merged_name_parts),
- }
- id_list = list(id_list)
- return id_list
-
-
-
-
- @classmethod
- def getProductIdMap(cls) -> Dict[str, List[str]]:
- product_to_id_file = os.path.join(os.path.dirname(sys.modules[cls.__module__].__file__), "product_to_id.json")
- with open(product_to_id_file, encoding = "utf-8") as f:
- product_to_id_map = json.load(f)
- product_to_id_map = {key: [value] for key, value in product_to_id_map.items()}
-
-
- return product_to_id_map
-
- @classmethod
- def _parseCompatibleValue(cls, value: str):
- return value in {"yes", "unknown"}
-
- def __str__(self):
- return "<XmlMaterialProfile '{my_id}' ('{name}') from base file '{base_file}'>".format(my_id = self.getId(), name = self.getName(), base_file = self.getMetaDataEntry("base_file"))
- _metadata_tags_that_have_cura_namespace = {"pva_compatible", "breakaway_compatible"}
-
- __material_settings_setting_map = {
- "print temperature": "default_material_print_temperature",
- "heated bed temperature": "default_material_bed_temperature",
- "standby temperature": "material_standby_temperature",
- "processing temperature graph": "material_flow_temp_graph",
- "print cooling": "cool_fan_speed",
- "retraction amount": "retraction_amount",
- "retraction speed": "retraction_speed",
- "adhesion tendency": "material_adhesion_tendency",
- "surface energy": "material_surface_energy",
- "shrinkage percentage": "material_shrinkage_percentage",
- "build volume temperature": "build_volume_temperature",
- "anti ooze retract position": "material_anti_ooze_retracted_position",
- "anti ooze retract speed": "material_anti_ooze_retraction_speed",
- "break preparation position": "material_break_preparation_retracted_position",
- "break preparation speed": "material_break_preparation_speed",
- "break position": "material_break_retracted_position",
- "break speed": "material_break_speed",
- "break temperature": "material_break_temperature"
- }
- __unmapped_settings = [
- "hardware compatible",
- "hardware recommended"
- ]
- __material_properties_setting_map = {
- "diameter": "material_diameter"
- }
- __material_metadata_setting_map = {
- "GUID": "material_guid"
- }
-
- __namespaces = {
- "um": "http://www.ultimaker.com/material",
- "cura": "http://www.ultimaker.com/cura"
- }
- def _indent(elem, level = 0):
- i = "\n" + level * " "
- if len(elem):
- if not elem.text or not elem.text.strip():
- elem.text = i + " "
- if not elem.tail or not elem.tail.strip():
- elem.tail = i
- for elem in elem:
- _indent(elem, level + 1)
- if not elem.tail or not elem.tail.strip():
- elem.tail = i
- else:
- if level and (not elem.tail or not elem.tail.strip()):
- elem.tail = i
- def _tag_without_namespace(element):
- return element.tag[element.tag.rfind("}") + 1:]
|