MachineNode.py 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
  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. class MachineNode(ContainerNode):
  16. """This class represents a machine in the container tree.
  17. The subnodes of these nodes are variants.
  18. """
  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. def getQualityGroups(self, variant_names: List[str], material_bases: List[str], extruder_enabled: List[bool]) -> Dict[str, QualityGroup]:
  43. """Get the available quality groups for this machine.
  44. This returns all quality groups, regardless of whether they are available to the combination of extruders or
  45. not. On the resulting quality groups, the is_available property is set to indicate whether the quality group
  46. can be selected according to the combination of extruders in the parameters.
  47. :param variant_names: The names of the variants loaded in each extruder.
  48. :param material_bases: The base file names of the materials loaded in each extruder.
  49. :param extruder_enabled: Whether or not the extruders are enabled. This allows the function to set the
  50. is_available properly.
  51. :return: For each available quality type, a QualityGroup instance.
  52. """
  53. if len(variant_names) != len(material_bases) or len(variant_names) != len(extruder_enabled):
  54. 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)) + ").")
  55. return {}
  56. # For each extruder, find which quality profiles are available. Later we'll intersect the quality types.
  57. qualities_per_type_per_extruder = [{}] * len(variant_names) # type: List[Dict[str, QualityNode]]
  58. for extruder_nr, variant_name in enumerate(variant_names):
  59. if not extruder_enabled[extruder_nr]:
  60. continue # No qualities are available in this extruder. It'll get skipped when calculating the available quality types.
  61. material_base = material_bases[extruder_nr]
  62. if variant_name not in self.variants or material_base not in self.variants[variant_name].materials:
  63. # The printer has no variant/material-specific quality profiles. Use the global quality profiles.
  64. qualities_per_type_per_extruder[extruder_nr] = self.global_qualities
  65. else:
  66. # Use the actually specialised quality profiles.
  67. qualities_per_type_per_extruder[extruder_nr] = {node.quality_type: node for node in self.variants[variant_name].materials[material_base].qualities.values()}
  68. # Create the quality group for each available type.
  69. quality_groups = {}
  70. for quality_type, global_quality_node in self.global_qualities.items():
  71. if not global_quality_node.container:
  72. Logger.log("w", "Node {0} doesn't have a container.".format(global_quality_node.container_id))
  73. continue
  74. quality_groups[quality_type] = QualityGroup(name = global_quality_node.getMetaDataEntry("name", "Unnamed profile"), quality_type = quality_type)
  75. quality_groups[quality_type].node_for_global = global_quality_node
  76. for extruder_position, qualities_per_type in enumerate(qualities_per_type_per_extruder):
  77. if quality_type in qualities_per_type:
  78. quality_groups[quality_type].setExtruderNode(extruder_position, qualities_per_type[quality_type])
  79. available_quality_types = set(quality_groups.keys())
  80. for extruder_nr, qualities_per_type in enumerate(qualities_per_type_per_extruder):
  81. if not extruder_enabled[extruder_nr]:
  82. continue
  83. available_quality_types.intersection_update(qualities_per_type.keys())
  84. for quality_type in available_quality_types:
  85. quality_groups[quality_type].is_available = True
  86. return quality_groups
  87. def getQualityChangesGroups(self, variant_names: List[str], material_bases: List[str], extruder_enabled: List[bool]) -> List[QualityChangesGroup]:
  88. """Returns all of the quality changes groups available to this printer.
  89. The quality changes groups store which quality type and intent category they were made for, but not which
  90. material and nozzle. Instead for the quality type and intent category, the quality changes will always be
  91. available but change the quality type and intent category when activated.
  92. The quality changes group does depend on the printer: Which quality definition is used.
  93. The quality changes groups that are available do depend on the quality types that are available, so it must
  94. still be known which extruders are enabled and which materials and variants are loaded in them. This allows
  95. setting the correct is_available flag.
  96. :param variant_names: The names of the variants loaded in each extruder.
  97. :param material_bases: The base file names of the materials loaded in each extruder.
  98. :param extruder_enabled: For each extruder whether or not they are enabled.
  99. :return: List of all quality changes groups for the printer.
  100. """
  101. machine_quality_changes = ContainerRegistry.getInstance().findContainersMetadata(type = "quality_changes", definition = self.quality_definition) # All quality changes for each extruder.
  102. 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.
  103. for quality_changes in machine_quality_changes:
  104. name = quality_changes["name"]
  105. if name not in groups_by_name:
  106. # CURA-6599
  107. # For some reason, QML will get null or fail to convert type for MachineManager.activeQualityChangesGroup() to
  108. # a QObject. Setting the object ownership to QQmlEngine.CppOwnership doesn't work, but setting the object
  109. # parent to application seems to work.
  110. from cura.CuraApplication import CuraApplication
  111. groups_by_name[name] = QualityChangesGroup(name, quality_type = quality_changes["quality_type"],
  112. intent_category = quality_changes.get("intent_category", "default"),
  113. parent = CuraApplication.getInstance())
  114. 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.
  115. groups_by_name[name].intent_category = quality_changes.get("intent_category", "default")
  116. if quality_changes.get("position") is not None and quality_changes.get("position") != "None": # An extruder profile.
  117. groups_by_name[name].metadata_per_extruder[int(quality_changes["position"])] = quality_changes
  118. else: # Global profile.
  119. groups_by_name[name].metadata_for_global = quality_changes
  120. quality_groups = self.getQualityGroups(variant_names, material_bases, extruder_enabled)
  121. for quality_changes_group in groups_by_name.values():
  122. if quality_changes_group.quality_type not in quality_groups:
  123. if quality_changes_group.quality_type == "not_supported":
  124. # Quality changes based on an empty profile are always available.
  125. quality_changes_group.is_available = True
  126. else:
  127. quality_changes_group.is_available = False
  128. else:
  129. # Quality changes group is available iff the quality group it depends on is available. Irrespective of whether the intent category is available.
  130. quality_changes_group.is_available = quality_groups[quality_changes_group.quality_type].is_available
  131. return list(groups_by_name.values())
  132. def preferredGlobalQuality(self) -> "QualityNode":
  133. """Gets the preferred global quality node, going by the preferred quality type.
  134. If the preferred global quality is not in there, an arbitrary global quality is taken. If there are no global
  135. qualities, an empty quality is returned.
  136. """
  137. return self.global_qualities.get(self.preferred_quality_type, next(iter(self.global_qualities.values())))
  138. @UM.FlameProfiler.profile
  139. def _loadAll(self) -> None:
  140. """(Re)loads all variants under this printer."""
  141. container_registry = ContainerRegistry.getInstance()
  142. if not self.has_variants:
  143. self.variants["empty"] = VariantNode("empty_variant", machine = self)
  144. self.variants["empty"].materialsChanged.connect(self.materialsChanged)
  145. else:
  146. # Find all the variants for this definition ID.
  147. variants = container_registry.findInstanceContainersMetadata(type = "variant", definition = self.container_id, hardware_type = "nozzle")
  148. for variant in variants:
  149. variant_name = variant["name"]
  150. if variant_name not in self.variants:
  151. self.variants[variant_name] = VariantNode(variant["id"], machine = self)
  152. self.variants[variant_name].materialsChanged.connect(self.materialsChanged)
  153. else:
  154. # Force reloading the materials if the variant already exists or else materals won't be loaded
  155. # when the G-Code flavor changes --> CURA-7354
  156. self.variants[variant_name]._loadAll()
  157. if not self.variants:
  158. self.variants["empty"] = VariantNode("empty_variant", machine = self)
  159. # Find the global qualities for this printer.
  160. global_qualities = container_registry.findInstanceContainersMetadata(type = "quality", definition = self.quality_definition, global_quality = "True") # First try specific to this printer.
  161. if not global_qualities: # This printer doesn't override the global qualities.
  162. global_qualities = container_registry.findInstanceContainersMetadata(type = "quality", definition = "fdmprinter", global_quality = "True") # Otherwise pick the global global qualities.
  163. if not global_qualities: # There are no global qualities either?! Something went very wrong, but we'll not crash and properly fill the tree.
  164. global_qualities = [cura.CuraApplication.CuraApplication.getInstance().empty_quality_container.getMetaData()]
  165. for global_quality in global_qualities:
  166. self.global_qualities[global_quality["quality_type"]] = QualityNode(global_quality["id"], parent = self)