MachineNode.py 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184
  1. # Copyright (c) 2019 Ultimaker B.V.
  2. # Cura is released under the terms of the LGPLv3 or higher.
  3. from typing import Dict, List
  4. from UM.Logger import Logger
  5. from UM.Signal import Signal
  6. from UM.Util import parseBool
  7. from UM.Settings.ContainerRegistry import ContainerRegistry # To find all the variants for this machine.
  8. import cura.CuraApplication # Imported like this to prevent circular dependencies.
  9. from cura.Machines.ContainerNode import ContainerNode
  10. from cura.Machines.QualityChangesGroup import QualityChangesGroup # To construct groups of quality changes profiles that belong together.
  11. from cura.Machines.QualityGroup import QualityGroup # To construct groups of quality profiles that belong together.
  12. from cura.Machines.QualityNode import QualityNode
  13. from cura.Machines.VariantNode import VariantNode
  14. import UM.FlameProfiler
  15. ## This class represents a machine in the container tree.
  16. #
  17. # The subnodes of these nodes are variants.
  18. class MachineNode(ContainerNode):
  19. def __init__(self, container_id: str) -> None:
  20. super().__init__(container_id)
  21. self.variants = {} # type: Dict[str, VariantNode] # Mapping variant names to their nodes.
  22. self.global_qualities = {} # type: Dict[str, QualityNode] # Mapping quality types to the global quality for those types.
  23. self.materialsChanged = Signal() # Emitted when one of the materials underneath this machine has been changed.
  24. container_registry = ContainerRegistry.getInstance()
  25. try:
  26. my_metadata = container_registry.findContainersMetadata(id = container_id)[0]
  27. except IndexError:
  28. Logger.log("Unable to find metadata for container %s", container_id)
  29. my_metadata = {}
  30. # Some of the metadata is cached upon construction here.
  31. # ONLY DO THAT FOR METADATA THAT DOESN'T CHANGE DURING RUNTIME!
  32. # Otherwise you need to keep it up-to-date during runtime.
  33. self.has_materials = parseBool(my_metadata.get("has_materials", "true"))
  34. self.has_variants = parseBool(my_metadata.get("has_variants", "false"))
  35. self.has_machine_quality = parseBool(my_metadata.get("has_machine_quality", "false"))
  36. self.quality_definition = my_metadata.get("quality_definition", container_id) if self.has_machine_quality else "fdmprinter"
  37. self.exclude_materials = my_metadata.get("exclude_materials", [])
  38. self.preferred_variant_name = my_metadata.get("preferred_variant_name", "")
  39. self.preferred_material = my_metadata.get("preferred_material", "")
  40. self.preferred_quality_type = my_metadata.get("preferred_quality_type", "")
  41. self._loadAll()
  42. ## Get the available quality groups for this machine.
  43. #
  44. # This returns all quality groups, regardless of whether they are
  45. # available to the combination of extruders or not. On the resulting
  46. # quality groups, the is_available property is set to indicate whether the
  47. # quality group can be selected according to the combination of extruders
  48. # in the parameters.
  49. # \param variant_names The names of the variants loaded in each extruder.
  50. # \param material_bases The base file names of the materials loaded in
  51. # each extruder.
  52. # \param extruder_enabled Whether or not the extruders are enabled. This
  53. # allows the function to set the is_available properly.
  54. # \return For each available quality type, a QualityGroup instance.
  55. def getQualityGroups(self, variant_names: List[str], material_bases: List[str], extruder_enabled: List[bool]) -> Dict[str, QualityGroup]:
  56. if len(variant_names) != len(material_bases) or len(variant_names) != len(extruder_enabled):
  57. Logger.log("e", "The number of extruders in the list of variants (" + str(len(variant_names)) + ") is not equal to the number of extruders in the list of materials (" + str(len(material_bases)) + ") or the list of enabled extruders (" + str(len(extruder_enabled)) + ").")
  58. return {}
  59. # For each extruder, find which quality profiles are available. Later we'll intersect the quality types.
  60. qualities_per_type_per_extruder = [{}] * len(variant_names) # type: List[Dict[str, QualityNode]]
  61. for extruder_nr, variant_name in enumerate(variant_names):
  62. if not extruder_enabled[extruder_nr]:
  63. continue # No qualities are available in this extruder. It'll get skipped when calculating the available quality types.
  64. material_base = material_bases[extruder_nr]
  65. if variant_name not in self.variants or material_base not in self.variants[variant_name].materials:
  66. # The printer has no variant/material-specific quality profiles. Use the global quality profiles.
  67. qualities_per_type_per_extruder[extruder_nr] = self.global_qualities
  68. else:
  69. # Use the actually specialised quality profiles.
  70. qualities_per_type_per_extruder[extruder_nr] = {node.quality_type: node for node in self.variants[variant_name].materials[material_base].qualities.values()}
  71. # Create the quality group for each available type.
  72. quality_groups = {}
  73. for quality_type, global_quality_node in self.global_qualities.items():
  74. if not global_quality_node.container:
  75. Logger.log("w", "Node {0} doesn't have a container.".format(global_quality_node.container_id))
  76. continue
  77. quality_groups[quality_type] = QualityGroup(name = global_quality_node.getMetaDataEntry("name", "Unnamed profile"), quality_type = quality_type)
  78. quality_groups[quality_type].node_for_global = global_quality_node
  79. for extruder_position, qualities_per_type in enumerate(qualities_per_type_per_extruder):
  80. if quality_type in qualities_per_type:
  81. quality_groups[quality_type].setExtruderNode(extruder_position, qualities_per_type[quality_type])
  82. available_quality_types = set(quality_groups.keys())
  83. for extruder_nr, qualities_per_type in enumerate(qualities_per_type_per_extruder):
  84. if not extruder_enabled[extruder_nr]:
  85. continue
  86. available_quality_types.intersection_update(qualities_per_type.keys())
  87. for quality_type in available_quality_types:
  88. quality_groups[quality_type].is_available = True
  89. return quality_groups
  90. ## Returns all of the quality changes groups available to this printer.
  91. #
  92. # The quality changes groups store which quality type and intent category
  93. # they were made for, but not which material and nozzle. Instead for the
  94. # quality type and intent category, the quality changes will always be
  95. # available but change the quality type and intent category when
  96. # activated.
  97. #
  98. # The quality changes group does depend on the printer: Which quality
  99. # definition is used.
  100. #
  101. # The quality changes groups that are available do depend on the quality
  102. # types that are available, so it must still be known which extruders are
  103. # enabled and which materials and variants are loaded in them. This allows
  104. # setting the correct is_available flag.
  105. # \param variant_names The names of the variants loaded in each extruder.
  106. # \param material_bases The base file names of the materials loaded in
  107. # each extruder.
  108. # \param extruder_enabled For each extruder whether or not they are
  109. # enabled.
  110. # \return List of all quality changes groups for the printer.
  111. def getQualityChangesGroups(self, variant_names: List[str], material_bases: List[str], extruder_enabled: List[bool]) -> List[QualityChangesGroup]:
  112. machine_quality_changes = ContainerRegistry.getInstance().findContainersMetadata(type = "quality_changes", definition = self.quality_definition) # All quality changes for each extruder.
  113. groups_by_name = {} #type: Dict[str, QualityChangesGroup] # Group quality changes profiles by their display name. The display name must be unique for quality changes. This finds profiles that belong together in a group.
  114. for quality_changes in machine_quality_changes:
  115. name = quality_changes["name"]
  116. if name not in groups_by_name:
  117. # CURA-6599
  118. # For some reason, QML will get null or fail to convert type for MachineManager.activeQualityChangesGroup() to
  119. # a QObject. Setting the object ownership to QQmlEngine.CppOwnership doesn't work, but setting the object
  120. # parent to application seems to work.
  121. from cura.CuraApplication import CuraApplication
  122. groups_by_name[name] = QualityChangesGroup(name, quality_type = quality_changes["quality_type"],
  123. intent_category = quality_changes.get("intent_category", "default"),
  124. parent = CuraApplication.getInstance())
  125. # CURA-6882
  126. # Custom qualities are always available, even if they are based on the "not supported" profile.
  127. groups_by_name[name].is_available = True
  128. elif groups_by_name[name].intent_category == "default": # Intent category should be stored as "default" if everything is default or as the intent if any of the extruder have an actual intent.
  129. groups_by_name[name].intent_category = quality_changes.get("intent_category", "default")
  130. if quality_changes.get("position") is not None and quality_changes.get("position") != "None": # An extruder profile.
  131. groups_by_name[name].metadata_per_extruder[int(quality_changes["position"])] = quality_changes
  132. else: # Global profile.
  133. groups_by_name[name].metadata_for_global = quality_changes
  134. return list(groups_by_name.values())
  135. ## Gets the preferred global quality node, going by the preferred quality
  136. # type.
  137. #
  138. # If the preferred global quality is not in there, an arbitrary global
  139. # quality is taken.
  140. # If there are no global qualities, an empty quality is returned.
  141. def preferredGlobalQuality(self) -> "QualityNode":
  142. return self.global_qualities.get(self.preferred_quality_type, next(iter(self.global_qualities.values())))
  143. ## (Re)loads all variants under this printer.
  144. @UM.FlameProfiler.profile
  145. def _loadAll(self) -> None:
  146. container_registry = ContainerRegistry.getInstance()
  147. if not self.has_variants:
  148. self.variants["empty"] = VariantNode("empty_variant", machine = self)
  149. self.variants["empty"].materialsChanged.connect(self.materialsChanged)
  150. else:
  151. # Find all the variants for this definition ID.
  152. variants = container_registry.findInstanceContainersMetadata(type = "variant", definition = self.container_id, hardware_type = "nozzle")
  153. for variant in variants:
  154. variant_name = variant["name"]
  155. if variant_name not in self.variants:
  156. self.variants[variant_name] = VariantNode(variant["id"], machine = self)
  157. self.variants[variant_name].materialsChanged.connect(self.materialsChanged)
  158. if not self.variants:
  159. self.variants["empty"] = VariantNode("empty_variant", machine = self)
  160. # Find the global qualities for this printer.
  161. global_qualities = container_registry.findInstanceContainersMetadata(type = "quality", definition = self.quality_definition, global_quality = "True") # First try specific to this printer.
  162. if not global_qualities: # This printer doesn't override the global qualities.
  163. global_qualities = container_registry.findInstanceContainersMetadata(type = "quality", definition = "fdmprinter", global_quality = "True") # Otherwise pick the global global qualities.
  164. if not global_qualities: # There are no global qualities either?! Something went very wrong, but we'll not crash and properly fill the tree.
  165. global_qualities = [cura.CuraApplication.CuraApplication.getInstance().empty_quality_container.getMetaData()]
  166. for global_quality in global_qualities:
  167. self.global_qualities[global_quality["quality_type"]] = QualityNode(global_quality["id"], parent = self)