mirror of
https://git.mirrors.martin98.com/https://github.com/Ultimaker/Cura
synced 2025-04-23 06:09:38 +08:00
415 lines
17 KiB
Python
415 lines
17 KiB
Python
# Copyright (c) 2016 Ultimaker B.V.
|
|
# Cura is released under the terms of the AGPLv3 or higher.
|
|
|
|
import math
|
|
import copy
|
|
import io
|
|
import xml.etree.ElementTree as ET
|
|
import uuid
|
|
|
|
from UM.Logger import Logger
|
|
|
|
import UM.Dictionary
|
|
|
|
import UM.Settings
|
|
|
|
## Handles serializing and deserializing material containers from an XML file
|
|
class XmlMaterialProfile(UM.Settings.InstanceContainer):
|
|
def __init__(self, container_id, *args, **kwargs):
|
|
super().__init__(container_id, *args, **kwargs)
|
|
|
|
## Overridden from InstanceContainer
|
|
def duplicate(self, new_id, new_name = None):
|
|
base_file = self.getMetaDataEntry("base_file", "")
|
|
new_uuid = str(uuid.uuid4())
|
|
|
|
if base_file:
|
|
containers = UM.Settings.ContainerRegistry.getInstance().findInstanceContainers(id = base_file)
|
|
if containers:
|
|
new_basefile = containers[0].duplicate(self.getMetaDataEntry("brand") + "_" + new_id, new_name)
|
|
new_basefile.setMetaDataEntry("GUID", new_uuid)
|
|
base_file = new_basefile.id
|
|
UM.Settings.ContainerRegistry.getInstance().addContainer(new_basefile)
|
|
|
|
new_id = self.getMetaDataEntry("brand") + "_" + new_id + "_" + self.getDefinition().getId()
|
|
variant = self.getMetaDataEntry("variant")
|
|
if variant:
|
|
variant_containers = UM.Settings.ContainerRegistry.getInstance().findInstanceContainers(id = variant)
|
|
if variant_containers:
|
|
new_id += "_" + variant_containers[0].getName().replace(" ", "_")
|
|
|
|
result = super().duplicate(new_id, new_name)
|
|
result.setMetaDataEntry("GUID", new_uuid)
|
|
result.setMetaDataEntry("base_file", base_file)
|
|
return result
|
|
|
|
## Overridden from InstanceContainer
|
|
def setReadOnly(self, read_only):
|
|
super().setReadOnly(read_only)
|
|
|
|
for container in UM.Settings.ContainerRegistry.getInstance().findInstanceContainers(GUID = self.getMetaDataEntry("GUID")):
|
|
container._read_only = read_only
|
|
|
|
## Overridden from InstanceContainer
|
|
def setMetaDataEntry(self, key, value):
|
|
if self.isReadOnly():
|
|
return
|
|
|
|
super().setMetaDataEntry(key, value)
|
|
|
|
for container in UM.Settings.ContainerRegistry.getInstance().findInstanceContainers(GUID = self.getMetaDataEntry("GUID")):
|
|
container.setMetaData(copy.deepcopy(self._metadata))
|
|
|
|
## Overridden from InstanceContainer
|
|
def setProperty(self, key, property_name, property_value, container = None):
|
|
if self.isReadOnly():
|
|
return
|
|
|
|
super().setProperty(key, property_name, property_value)
|
|
|
|
for container in UM.Settings.ContainerRegistry.getInstance().findInstanceContainers(GUID = self.getMetaDataEntry("GUID")):
|
|
container._dirty = True
|
|
|
|
## Overridden from InstanceContainer
|
|
def serialize(self):
|
|
registry = UM.Settings.ContainerRegistry.getInstance()
|
|
|
|
base_file = self.getMetaDataEntry("base_file", "")
|
|
if base_file and self.id != base_file:
|
|
# Since we create an instance of XmlMaterialProfile for each machine and nozzle in the profile,
|
|
# we should only serialize the "base" material definition, since that can then take care of
|
|
# serializing the machine/nozzle specific profiles.
|
|
raise NotImplementedError("Cannot serialize non-root XML materials")
|
|
|
|
builder = ET.TreeBuilder()
|
|
|
|
root = builder.start("fdmmaterial", { "xmlns": "http://www.ultimaker.com/material"})
|
|
|
|
## Begin Metadata Block
|
|
builder.start("metadata")
|
|
|
|
metadata = copy.deepcopy(self.getMetaData())
|
|
properties = metadata.pop("properties", {})
|
|
|
|
# Metadata properties that should not be serialized.
|
|
metadata.pop("status", "")
|
|
metadata.pop("variant", "")
|
|
metadata.pop("type", "")
|
|
metadata.pop("base_file", "")
|
|
|
|
## Begin Name Block
|
|
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.end("name")
|
|
## End Name Block
|
|
|
|
for key, value in metadata.items():
|
|
builder.start(key)
|
|
builder.data(value)
|
|
builder.end(key)
|
|
|
|
builder.end("metadata")
|
|
## End Metadata Block
|
|
|
|
## Begin Properties Block
|
|
builder.start("properties")
|
|
|
|
for key, value in properties.items():
|
|
builder.start(key)
|
|
builder.data(value)
|
|
builder.end(key)
|
|
|
|
builder.end("properties")
|
|
## End Properties Block
|
|
|
|
## Begin Settings Block
|
|
builder.start("settings")
|
|
|
|
if self.getDefinition().id == "fdmprinter":
|
|
for instance in self.findInstances():
|
|
self._addSettingElement(builder, instance)
|
|
|
|
machine_container_map = {}
|
|
machine_nozzle_map = {}
|
|
|
|
all_containers = registry.findInstanceContainers(GUID = self.getMetaDataEntry("GUID"))
|
|
for container in all_containers:
|
|
definition_id = container.getDefinition().id
|
|
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_nozzle_map:
|
|
machine_nozzle_map[definition_id] = {}
|
|
|
|
variant = container.getMetaDataEntry("variant")
|
|
if variant:
|
|
machine_nozzle_map[definition_id][variant] = container
|
|
continue
|
|
|
|
machine_container_map[definition_id] = container
|
|
|
|
for definition_id, container in machine_container_map.items():
|
|
definition = container.getDefinition()
|
|
try:
|
|
product = UM.Dictionary.findKey(self.__product_id_map, definition_id)
|
|
except ValueError:
|
|
continue
|
|
|
|
builder.start("machine")
|
|
builder.start("machine_identifier", { "manufacturer": definition.getMetaDataEntry("manufacturer", ""), "product": product})
|
|
builder.end("machine_identifier")
|
|
|
|
for instance in container.findInstances():
|
|
if self.getDefinition().id == "fdmprinter" and self.getInstance(instance.definition.key) and self.getProperty(instance.definition.key, "value") == instance.value:
|
|
# If the settings match that of the base profile, just skip since we inherit the base profile.
|
|
continue
|
|
|
|
self._addSettingElement(builder, instance)
|
|
|
|
# Find all hotend sub-profiles corresponding to this material and machine and add them to this profile.
|
|
for hotend_id, hotend in machine_nozzle_map[definition_id].items():
|
|
variant_containers = registry.findInstanceContainers(id = hotend.getMetaDataEntry("variant"))
|
|
if not variant_containers:
|
|
continue
|
|
|
|
builder.start("hotend", { "id": variant_containers[0].getName() })
|
|
|
|
for instance in hotend.findInstances():
|
|
if container.getInstance(instance.definition.key) and container.getProperty(instance.definition.key, "value") == instance.value:
|
|
# If the settings match that of the machine profile, just skip since we inherit the machine profile.
|
|
continue
|
|
|
|
self._addSettingElement(builder, instance)
|
|
|
|
builder.end("hotend")
|
|
|
|
builder.end("machine")
|
|
|
|
builder.end("settings")
|
|
## End Settings Block
|
|
|
|
builder.end("fdmmaterial")
|
|
|
|
root = builder.close()
|
|
_indent(root)
|
|
stream = io.StringIO()
|
|
tree = ET.ElementTree(root)
|
|
tree.write(stream, "unicode", True)
|
|
|
|
return stream.getvalue()
|
|
|
|
## Overridden from InstanceContainer
|
|
def deserialize(self, serialized):
|
|
data = ET.fromstring(serialized)
|
|
|
|
self.addMetaDataEntry("type", "material")
|
|
|
|
# TODO: Add material verfication
|
|
self.addMetaDataEntry("status", "unknown")
|
|
|
|
metadata = data.iterfind("./um:metadata/*", self.__namespaces)
|
|
for entry in metadata:
|
|
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)
|
|
|
|
self.setName(material.text)
|
|
|
|
self.addMetaDataEntry("brand", brand.text)
|
|
self.addMetaDataEntry("material", material.text)
|
|
self.addMetaDataEntry("color_name", color.text)
|
|
|
|
continue
|
|
|
|
self.addMetaDataEntry(tag_name, entry.text)
|
|
|
|
if not "description" in self.getMetaData():
|
|
self.addMetaDataEntry("description", "")
|
|
|
|
if not "adhesion_info" in self.getMetaData():
|
|
self.addMetaDataEntry("adhesion_info", "")
|
|
|
|
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
|
|
|
|
diameter = float(property_values.get("diameter", 2.85)) # In mm
|
|
density = float(property_values.get("density", 1.3)) # In g/cm3
|
|
|
|
self.addMetaDataEntry("properties", property_values)
|
|
|
|
self.setDefinition(UM.Settings.ContainerRegistry.getInstance().findDefinitionContainers(id = "fdmprinter")[0])
|
|
|
|
global_setting_values = {}
|
|
settings = data.iterfind("./um:settings/um:setting", self.__namespaces)
|
|
for entry in settings:
|
|
key = entry.get("key")
|
|
if key in self.__material_property_setting_map:
|
|
self.setProperty(self.__material_property_setting_map[key], "value", entry.text, self._definition)
|
|
global_setting_values[self.__material_property_setting_map[key]] = entry.text
|
|
else:
|
|
Logger.log("d", "Unsupported material setting %s", key)
|
|
|
|
self._dirty = False
|
|
|
|
machines = data.iterfind("./um:settings/um:machine", self.__namespaces)
|
|
for machine in machines:
|
|
machine_setting_values = {}
|
|
settings = machine.iterfind("./um:setting", self.__namespaces)
|
|
for entry in settings:
|
|
key = entry.get("key")
|
|
if key in self.__material_property_setting_map:
|
|
machine_setting_values[self.__material_property_setting_map[key]] = entry.text
|
|
else:
|
|
Logger.log("d", "Unsupported material setting %s", key)
|
|
|
|
identifiers = machine.iterfind("./um:machine_identifier", self.__namespaces)
|
|
for identifier in identifiers:
|
|
machine_id = self.__product_id_map.get(identifier.get("product"), None)
|
|
if machine_id is None:
|
|
Logger.log("w", "Cannot create material for unknown machine %s", machine_id)
|
|
continue
|
|
|
|
definitions = UM.Settings.ContainerRegistry.getInstance().findDefinitionContainers(id = machine_id)
|
|
if not definitions:
|
|
Logger.log("w", "No definition found for machine ID %s", machine_id)
|
|
continue
|
|
|
|
definition = definitions[0]
|
|
|
|
new_material = XmlMaterialProfile(self.id + "_" + machine_id)
|
|
new_material.setName(self.getName())
|
|
new_material.setMetaData(copy.deepcopy(self.getMetaData()))
|
|
new_material.setDefinition(definition)
|
|
new_material.addMetaDataEntry("base_file", self.id)
|
|
|
|
for key, value in global_setting_values.items():
|
|
new_material.setProperty(key, "value", value, definition)
|
|
|
|
for key, value in machine_setting_values.items():
|
|
new_material.setProperty(key, "value", value, definition)
|
|
|
|
new_material._dirty = False
|
|
|
|
UM.Settings.ContainerRegistry.getInstance().addContainer(new_material)
|
|
|
|
hotends = machine.iterfind("./um:hotend", self.__namespaces)
|
|
for hotend in hotends:
|
|
hotend_id = hotend.get("id")
|
|
if hotend_id is None:
|
|
continue
|
|
|
|
variant_containers = UM.Settings.ContainerRegistry.getInstance().findInstanceContainers(id = hotend_id)
|
|
if not variant_containers:
|
|
# It is not really properly defined what "ID" is so also search for variants by name.
|
|
variant_containers = UM.Settings.ContainerRegistry.getInstance().findInstanceContainers(definition = definition.id, name = hotend_id)
|
|
|
|
if not variant_containers:
|
|
Logger.log("d", "No variants found with ID or name %s for machine %s", hotend_id, definition.id)
|
|
continue
|
|
|
|
new_hotend_material = XmlMaterialProfile(self.id + "_" + machine_id + "_" + hotend_id.replace(" ", "_"))
|
|
new_hotend_material.setName(self.getName())
|
|
new_hotend_material.setMetaData(copy.deepcopy(self.getMetaData()))
|
|
new_hotend_material.setDefinition(definition)
|
|
new_hotend_material.addMetaDataEntry("base_file", self.id)
|
|
|
|
new_hotend_material.addMetaDataEntry("variant", variant_containers[0].id)
|
|
|
|
for key, value in global_setting_values.items():
|
|
new_hotend_material.setProperty(key, "value", value, definition)
|
|
|
|
for key, value in machine_setting_values.items():
|
|
new_hotend_material.setProperty(key, "value", value, definition)
|
|
|
|
settings = hotend.iterfind("./um:setting", self.__namespaces)
|
|
for entry in settings:
|
|
key = entry.get("key")
|
|
if key in self.__material_property_setting_map:
|
|
new_hotend_material.setProperty(self.__material_property_setting_map[key], "value", entry.text, definition)
|
|
else:
|
|
Logger.log("d", "Unsupported material setting %s", key)
|
|
|
|
new_hotend_material._dirty = False
|
|
UM.Settings.ContainerRegistry.getInstance().addContainer(new_hotend_material)
|
|
|
|
def _addSettingElement(self, builder, instance):
|
|
try:
|
|
key = UM.Dictionary.findKey(self.__material_property_setting_map, instance.definition.key)
|
|
except ValueError:
|
|
return
|
|
|
|
builder.start("setting", { "key": key })
|
|
builder.data(str(instance.value))
|
|
builder.end("setting")
|
|
|
|
# Map XML file setting names to internal names
|
|
__material_property_setting_map = {
|
|
"print temperature": "material_print_temperature",
|
|
"heated bed temperature": "material_bed_temperature",
|
|
"standby temperature": "material_standby_temperature",
|
|
"print cooling": "cool_fan_speed",
|
|
"retraction amount": "retraction_amount",
|
|
"retraction speed": "retraction_speed",
|
|
}
|
|
|
|
# Map XML file product names to internal ids
|
|
# TODO: Move this to definition's metadata
|
|
__product_id_map = {
|
|
"Ultimaker2": "ultimaker2",
|
|
"Ultimaker2+": "ultimaker2_plus",
|
|
"Ultimaker2go": "ultimaker2_go",
|
|
"Ultimaker2extended": "ultimaker2_extended",
|
|
"Ultimaker2extended+": "ultimaker2_extended_plus",
|
|
"Ultimaker Original": "ultimaker_original",
|
|
"Ultimaker Original+": "ultimaker_original_plus"
|
|
}
|
|
|
|
# Map of recognised namespaces with a proper prefix.
|
|
__namespaces = {
|
|
"um": "http://www.ultimaker.com/material"
|
|
}
|
|
|
|
## Helper function for pretty-printing XML because ETree is stupid
|
|
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
|
|
|
|
|
|
# The namespace is prepended to the tag name but between {}.
|
|
# We are only interested in the actual tag name, so discard everything
|
|
# before the last }
|
|
def _tag_without_namespace(element):
|
|
return element.tag[element.tag.rfind("}") + 1:]
|