GCodeWriter.py 9.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191
  1. # Copyright (c) 2017 Ultimaker B.V.
  2. # Cura is released under the terms of the LGPLv3 or higher.
  3. import re # For escaping characters in the settings.
  4. import json
  5. import copy
  6. from UM.Mesh.MeshWriter import MeshWriter
  7. from UM.Logger import Logger
  8. from UM.Application import Application
  9. from UM.Settings.InstanceContainer import InstanceContainer
  10. from cura.Machines.QualityManager import getMachineDefinitionIDForQualitySearch
  11. ## Writes g-code to a file.
  12. #
  13. # While this poses as a mesh writer, what this really does is take the g-code
  14. # in the entire scene and write it to an output device. Since the g-code of a
  15. # single mesh isn't separable from the rest what with rafts and travel moves
  16. # and all, it doesn't make sense to write just a single mesh.
  17. #
  18. # So this plug-in takes the g-code that is stored in the root of the scene
  19. # node tree, adds a bit of extra information about the profiles and writes
  20. # that to the output device.
  21. class GCodeWriter(MeshWriter):
  22. ## The file format version of the serialised g-code.
  23. #
  24. # It can only read settings with the same version as the version it was
  25. # written with. If the file format is changed in a way that breaks reverse
  26. # compatibility, increment this version number!
  27. version = 3
  28. ## Dictionary that defines how characters are escaped when embedded in
  29. # g-code.
  30. #
  31. # Note that the keys of this dictionary are regex strings. The values are
  32. # not.
  33. escape_characters = {
  34. re.escape("\\"): "\\\\", # The escape character.
  35. re.escape("\n"): "\\n", # Newlines. They break off the comment.
  36. re.escape("\r"): "\\r" # Carriage return. Windows users may need this for visualisation in their editors.
  37. }
  38. _setting_keyword = ";SETTING_"
  39. def __init__(self):
  40. super().__init__()
  41. self._application = Application.getInstance()
  42. ## Writes the g-code for the entire scene to a stream.
  43. #
  44. # Note that even though the function accepts a collection of nodes, the
  45. # entire scene is always written to the file since it is not possible to
  46. # separate the g-code for just specific nodes.
  47. #
  48. # \param stream The stream to write the g-code to.
  49. # \param nodes This is ignored.
  50. # \param mode Additional information on how to format the g-code in the
  51. # file. This must always be text mode.
  52. def write(self, stream, nodes, mode = MeshWriter.OutputMode.TextMode):
  53. if mode != MeshWriter.OutputMode.TextMode:
  54. Logger.log("e", "GCodeWriter does not support non-text mode.")
  55. return False
  56. active_build_plate = Application.getInstance().getMultiBuildPlateModel().activeBuildPlate
  57. scene = Application.getInstance().getController().getScene()
  58. if not hasattr(scene, "gcode_dict"):
  59. return False
  60. gcode_dict = getattr(scene, "gcode_dict")
  61. gcode_list = gcode_dict.get(active_build_plate, None)
  62. if gcode_list is not None:
  63. has_settings = False
  64. for gcode in gcode_list:
  65. if gcode[:len(self._setting_keyword)] == self._setting_keyword:
  66. has_settings = True
  67. stream.write(gcode)
  68. # Serialise the current container stack and put it at the end of the file.
  69. if not has_settings:
  70. settings = self._serialiseSettings(Application.getInstance().getGlobalContainerStack())
  71. stream.write(settings)
  72. return True
  73. return False
  74. ## Create a new container with container 2 as base and container 1 written over it.
  75. def _createFlattenedContainerInstance(self, instance_container1, instance_container2):
  76. flat_container = InstanceContainer(instance_container2.getName())
  77. # The metadata includes id, name and definition
  78. flat_container.setMetaData(copy.deepcopy(instance_container2.getMetaData()))
  79. if instance_container1.getDefinition():
  80. flat_container.setDefinition(instance_container1.getDefinition().getId())
  81. for key in instance_container2.getAllKeys():
  82. flat_container.setProperty(key, "value", instance_container2.getProperty(key, "value"))
  83. for key in instance_container1.getAllKeys():
  84. flat_container.setProperty(key, "value", instance_container1.getProperty(key, "value"))
  85. return flat_container
  86. ## Serialises a container stack to prepare it for writing at the end of the
  87. # g-code.
  88. #
  89. # The settings are serialised, and special characters (including newline)
  90. # are escaped.
  91. #
  92. # \param settings A container stack to serialise.
  93. # \return A serialised string of the settings.
  94. def _serialiseSettings(self, stack):
  95. container_registry = self._application.getContainerRegistry()
  96. quality_manager = self._application.getQualityManager()
  97. prefix = self._setting_keyword + str(GCodeWriter.version) + " " # The prefix to put before each line.
  98. prefix_length = len(prefix)
  99. quality_type = stack.quality.getMetaDataEntry("quality_type")
  100. container_with_profile = stack.qualityChanges
  101. if container_with_profile.getId() == "empty_quality_changes":
  102. # If the global quality changes is empty, create a new one
  103. quality_name = container_registry.uniqueName(stack.quality.getName())
  104. container_with_profile = quality_manager._createQualityChanges(quality_type, quality_name, stack, None)
  105. flat_global_container = self._createFlattenedContainerInstance(stack.userChanges, container_with_profile)
  106. # If the quality changes is not set, we need to set type manually
  107. if flat_global_container.getMetaDataEntry("type", None) is None:
  108. flat_global_container.addMetaDataEntry("type", "quality_changes")
  109. # Ensure that quality_type is set. (Can happen if we have empty quality changes).
  110. if flat_global_container.getMetaDataEntry("quality_type", None) is None:
  111. flat_global_container.addMetaDataEntry("quality_type", stack.quality.getMetaDataEntry("quality_type", "normal"))
  112. # Get the machine definition ID for quality profiles
  113. machine_definition_id_for_quality = getMachineDefinitionIDForQualitySearch(stack.definition)
  114. flat_global_container.setMetaDataEntry("definition", machine_definition_id_for_quality)
  115. serialized = flat_global_container.serialize()
  116. data = {"global_quality": serialized}
  117. all_setting_keys = set(flat_global_container.getAllKeys())
  118. for extruder in sorted(stack.extruders.values(), key = lambda k: int(k.getMetaDataEntry("position"))):
  119. extruder_quality = extruder.qualityChanges
  120. if extruder_quality.getId() == "empty_quality_changes":
  121. # Same story, if quality changes is empty, create a new one
  122. quality_name = container_registry.uniqueName(stack.quality.getName())
  123. extruder_quality = quality_manager._createQualityChanges(quality_type, quality_name, stack, None)
  124. flat_extruder_quality = self._createFlattenedContainerInstance(extruder.userChanges, extruder_quality)
  125. # If the quality changes is not set, we need to set type manually
  126. if flat_extruder_quality.getMetaDataEntry("type", None) is None:
  127. flat_extruder_quality.addMetaDataEntry("type", "quality_changes")
  128. # Ensure that extruder is set. (Can happen if we have empty quality changes).
  129. if flat_extruder_quality.getMetaDataEntry("position", None) is None:
  130. flat_extruder_quality.addMetaDataEntry("position", extruder.getMetaDataEntry("position"))
  131. # Ensure that quality_type is set. (Can happen if we have empty quality changes).
  132. if flat_extruder_quality.getMetaDataEntry("quality_type", None) is None:
  133. flat_extruder_quality.addMetaDataEntry("quality_type", extruder.quality.getMetaDataEntry("quality_type", "normal"))
  134. # Change the default definition
  135. flat_extruder_quality.setMetaDataEntry("definition", machine_definition_id_for_quality)
  136. extruder_serialized = flat_extruder_quality.serialize()
  137. data.setdefault("extruder_quality", []).append(extruder_serialized)
  138. all_setting_keys.update(set(flat_extruder_quality.getAllKeys()))
  139. # Check if there is any profiles
  140. if not all_setting_keys:
  141. Logger.log("i", "No custom settings found, not writing settings to g-code.")
  142. return ""
  143. json_string = json.dumps(data)
  144. # Escape characters that have a special meaning in g-code comments.
  145. pattern = re.compile("|".join(GCodeWriter.escape_characters.keys()))
  146. # Perform the replacement with a regular expression.
  147. escaped_string = pattern.sub(lambda m: GCodeWriter.escape_characters[re.escape(m.group(0))], json_string)
  148. # Introduce line breaks so that each comment is no longer than 80 characters. Prepend each line with the prefix.
  149. result = ""
  150. # Lines have 80 characters, so the payload of each line is 80 - prefix.
  151. for pos in range(0, len(escaped_string), 80 - prefix_length):
  152. result += prefix + escaped_string[pos: pos + 80 - prefix_length] + "\n"
  153. return result