3D-printing/Cura
1
0
Fork 0
mirror of https://github.com/Ultimaker/Cura.git synced 2025-07-06 22:47:29 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

D5: Refactoring

Browse source
This commit is contained in:
Victor Larchenko 2016-11-22 16:30:56 +06:00 • committed by Youness Alaoui
parent 1631045d7a
commit cd7979e301
3 changed files with 102 additions and 105 deletions
Download patch file Download diff file Expand all files Collapse all files

4
cura/CuraApplication.py
View file

@ -546,6 +546,10 @@ class CuraApplication(QtApplication):
def changeToLayerView(self): def changeToLayerView(self):
self.getController().setActiveView("LayerView") self.getController().setActiveView("LayerView")
view = self.getController().getActiveView()
view.resetLayerData()
view.setLayer(999999)
view.calculateMaxLayers()
@pyqtSlot(QUrl) @pyqtSlot(QUrl)
def loadFile(self, file): def loadFile(self, file):

1
plugins/CuraEngineBackend/ProcessSlicedLayersJob.py
View file

@ -60,7 +60,6 @@ class ProcessSlicedLayersJob(Job):
for node in DepthFirstIterator(self._scene.getRoot()): for node in DepthFirstIterator(self._scene.getRoot()):
if node.callDecoration("getLayerData"): if node.callDecoration("getLayerData"):
node.getParent().removeChild(node) node.getParent().removeChild(node)
break
if self._abort_requested: if self._abort_requested:
if self._progress: if self._progress:
self._progress.hide() self._progress.hide()

202
plugins/GCodeReader/GCodeReader.py
View file

@ -18,7 +18,7 @@ catalog = i18nCatalog("cura")
from cura import LayerDataBuilder from cura import LayerDataBuilder
from cura import LayerDataDecorator from cura import LayerDataDecorator
from cura import LayerPolygon from cura.LayerPolygon import LayerPolygon
import numpy import numpy
import math import math
@ -28,66 +28,66 @@ class GCodeReader(MeshReader):
def __init__(self): def __init__(self):
super(GCodeReader, self).__init__() super(GCodeReader, self).__init__()
self._supported_extensions = [".gcode", ".g"] self._supported_extensions = [".gcode", ".g"]
Application.getInstance().hideMessageSignal.connect(self.onHideMessage) Application.getInstance().hideMessageSignal.connect(self._onHideMessage)
self.cancelled = False self._cancelled = False
self.message = None self._message = None
self.scene_node = None self._scene_node = None
@staticmethod @staticmethod
def getInt(line, code): def _getValue(line, code):
n = line.find(code) + 1 n = line.find(code) + len(code)
if n < 1: if n < 1:
return None return None
m = line.find(' ', n) m = line.find(' ', n)
try: try:
if m < 0: if m < 0:
return int(line[n:]) return line[n:]
return int(line[n:m]) return line[n:m]
except: except:
return None return None
@staticmethod def _getInt(self, line, code):
def getFloat(line, code): value = self._getValue(line, code)
n = line.find(code) + 1
if n < 1:
return None
m = line.find(' ', n)
try: try:
if m < 0: return int(value)
return float(line[n:])
return float(line[n:m])
except: except:
return None return None
def onHideMessage(self, m): def _getFloat(self, line, code):
if m == self.message: value = self._getValue(line, code)
self.cancelled = True try:
return float(value)
except:
return None
def onParentChanged(self, node): def _onHideMessage(self, message):
if message == self._message:
self._cancelled = True
def _onParentChanged(self, node):
backend = Application.getInstance().getBackend() backend = Application.getInstance().getBackend()
if self.scene_node is not None and self.scene_node.getParent() is None: if self._scene_node is not None and self._scene_node.getParent() is None:
self.scene_node = None self._scene_node = None
backend.backendStateChange.emit(BackendState.NotStarted) backend.backendStateChange.emit(BackendState.NotStarted)
Application.getInstance().setHideSettings(False) Application.getInstance().setHideSettings(False)
Application.getInstance().getPrintInformation().setPreSliced(False) Application.getInstance().getPrintInformation().setPreSliced(False)
else: # else:
backend.backendStateChange.emit(BackendState.SlicingDisabled) # backend.backendStateChange.emit(BackendState.SlicingDisabled)
Application.getInstance().getPrintInformation().setPreSliced(True) # Application.getInstance().getPrintInformation().setPreSliced(True)
Application.getInstance().setHideSettings(True) # Application.getInstance().setHideSettings(True)
@staticmethod @staticmethod
def getNullBoundingBox(): def _getNullBoundingBox():
return AxisAlignedBox(minimum=Vector(0, 0, 0), maximum=Vector(10, 10, 10)) return AxisAlignedBox(minimum=Vector(0, 0, 0), maximum=Vector(10, 10, 10))
@staticmethod @staticmethod
def createPolygon(layer_data, path, layer_id, extruder): def _createPolygon(layer_data, path, layer_id, extruder):
countvalid = 0 countvalid = 0
for point in path: for point in path:
if point[3] > 0: if point[3] > 0:
countvalid += 1 countvalid += 1
if countvalid < 2: if countvalid < 2:
path.clear()
return False return False
try: try:
layer_data.addLayer(layer_id) layer_data.addLayer(layer_id)
@ -95,57 +95,51 @@ class GCodeReader(MeshReader):
layer_data.setLayerThickness(layer_id, 0.25) layer_data.setLayerThickness(layer_id, 0.25)
this_layer = layer_data.getLayer(layer_id) this_layer = layer_data.getLayer(layer_id)
except ValueError: except ValueError:
path.clear()
return False return False
count = len(path) count = len(path)
line_types = numpy.empty((count - 1, 1), numpy.int32) line_types = numpy.empty((count - 1, 1), numpy.int32)
line_types[:, 0] = 1
line_widths = numpy.empty((count - 1, 1), numpy.float32) line_widths = numpy.empty((count - 1, 1), numpy.float32)
line_widths[:, 0] = 0.5 line_widths[:, 0] = 0.5
points = numpy.empty((count, 3), numpy.float32) points = numpy.empty((count, 3), numpy.float32)
i = 0 i = 0
for point in path: for point in path:
points[i, 0] = point[0] points[i, 0] = point[0]
points[i, 1] = point[1] points[i, 1] = point[2]
points[i, 2] = point[2] points[i, 2] = -point[1]
if i > 0: if i > 0:
if point[3] == 1: if point[3] == LayerPolygon.Inset0Type:
line_types[i - 1] = extruder + 1 line_types[i - 1] = extruder + 1
else: else:
line_types[i - 1] = point[3] line_types[i - 1] = point[3]
i += 1 i += 1
this_poly = LayerPolygon.LayerPolygon(layer_data, extruder, line_types, points, line_widths) this_poly = LayerPolygon(layer_data, extruder, line_types, points, line_widths)
this_poly.buildCache() this_poly.buildCache()
this_layer.polygons.append(this_poly) this_layer.polygons.append(this_poly)
path.clear()
return True return True
def read(self, file_name): def read(self, file_name):
extension = os.path.splitext(file_name)[1] Logger.log("d", "Preparing to load %s" % file_name)
if extension.lower() in self._supported_extensions: self._cancelled = False
Logger.log("d", "Preparing to load %s" % file_name)
self.cancelled = False
Application.getInstance().deleteAll()
self.scene_node = SceneNode() self._scene_node = SceneNode()
self.scene_node.getBoundingBox = self.getNullBoundingBox self._scene_node.getBoundingBox = self._getNullBoundingBox # Manually set bounding box, because mesh doesn't have mesh data
self.scene_node.gcode = True self._scene_node.gcode = True
self.scene_node.parentChanged.connect(self.onParentChanged) self._scene_node.parentChanged.connect(self._onParentChanged)
backend = Application.getInstance().getBackend() backend = Application.getInstance().getBackend()
backend.close() backend.close()
backend.backendStateChange.emit(BackendState.SlicingDisabled) backend.backendStateChange.emit(BackendState.SlicingDisabled)
glist = getattr(Application.getInstance().getController().getScene(), "gcode_list") glist = []
glist.clear() Application.getInstance().getController().getScene().gcode_list = glist
Logger.log("d", "Opening file %s" % file_name) Logger.log("d", "Opening file %s" % file_name)
file = open(file_name, "r") layer_data_builder = LayerDataBuilder.LayerDataBuilder()
with open(file_name, "r") as file:
file_lines = 0 file_lines = 0
current_line = 0 current_line = 0
for line in file: for line in file:
@ -153,7 +147,6 @@ class GCodeReader(MeshReader):
file.seek(0) file.seek(0)
file_step = max(math.floor(file_lines / 100), 1) file_step = max(math.floor(file_lines / 100), 1)
layer_data = LayerDataBuilder.LayerDataBuilder()
current_extruder = 0 current_extruder = 0
current_path = [] current_path = []
@ -163,30 +156,30 @@ class GCodeReader(MeshReader):
current_e = 0 current_e = 0
current_layer = 0 current_layer = 0
self.message = Message(catalog.i18nc("@info:status", "Parsing GCODE"), lifetime=0) self._message = Message(catalog.i18nc("@info:status", "Parsing GCODE"), lifetime=0)
self.message.setProgress(0) self._message.setProgress(0)
self.message.show() self._message.show()
Logger.log("d", "Parsing %s" % file_name) Logger.log("d", "Parsing %s" % file_name)
for line in file: for line in file:
if self.cancelled: if self._cancelled:
Logger.log("w", "Parsing %s cancelled" % file_name) Logger.log("w", "Parsing %s cancelled" % file_name)
return None return None
current_line += 1 current_line += 1
if current_line % file_step == 0: if current_line % file_step == 0:
self.message.setProgress(math.floor(current_line/file_lines*100)) self._message.setProgress(math.floor(current_line / file_lines * 100))
if len(line) == 0: if len(line) == 0:
continue continue
if line[0] == ";": if line[0] == ";":
continue continue
G = self.getInt(line, "G") G = self._getInt(line, "G")
if G is not None: if G is not None:
if G == 0 or G == 1: if G == 0 or G == 1:
x = self.getFloat(line, "X") x = self._getFloat(line, "X")
y = self.getFloat(line, "Y") y = self._getFloat(line, "Y")
z = self.getFloat(line, "Z") z = self._getFloat(line, "Z")
e = self.getFloat(line, "E") e = self._getFloat(line, "E")
z_changed = False z_changed = False
if x is not None: if x is not None:
current_x = x current_x = x
@ -198,78 +191,79 @@ class GCodeReader(MeshReader):
current_z = z current_z = z
if e is not None: if e is not None:
if e > current_e: if e > current_e:
current_path.append([current_x, current_z, -current_y, 1]) # extrusion current_path.append([current_x, current_y, current_z, LayerPolygon.Inset0Type]) # extrusion
else: else:
current_path.append([current_x, current_z, -current_y, 2]) # retraction current_path.append([current_x, current_y, current_z, LayerPolygon.MoveRetractionType]) # retraction
current_e = e current_e = e
else: else:
current_path.append([current_x, current_z, -current_y, 0]) current_path.append([current_x, current_y, current_z, LayerPolygon.NoneType])
if z_changed: if z_changed:
if len(current_path) > 1 and current_z > 0: if len(current_path) > 1 and current_z > 0:
if self.createPolygon(layer_data, current_path, current_layer, current_extruder): if self._createPolygon(layer_data_builder, current_path, current_layer, current_extruder):
current_layer += 1 current_layer += 1
current_path.clear()
else: else:
current_path.clear() current_path.clear()
elif G == 28: elif G == 28:
x = self.getFloat(line, "X") x = self._getFloat(line, "X")
y = self.getFloat(line, "Y") y = self._getFloat(line, "Y")
if x is not None: if x is not None:
current_x = x current_x = x
if y is not None: if y is not None:
current_y = y current_y = y
current_z = 0 current_z = 0
elif G == 92: elif G == 92:
x = self.getFloat(line, "X") x = self._getFloat(line, "X")
y = self.getFloat(line, "Y") y = self._getFloat(line, "Y")
z = self.getFloat(line, "Z") z = self._getFloat(line, "Z")
e = self._getFloat(line, "E")
if x is not None: if x is not None:
current_x += x current_x = x
if y is not None: if y is not None:
current_y += y current_y = y
if z is not None: if z is not None:
current_z += z current_z = z
if e is not None:
current_e = e
T = self.getInt(line, "T") T = self._getInt(line, "T")
if T is not None: if T is not None:
current_extruder = T current_extruder = T
if len(current_path) > 1 and current_z > 0: if len(current_path) > 1 and current_z > 0:
if self.createPolygon(layer_data, current_path, current_layer, current_extruder): if self._createPolygon(layer_data_builder, current_path, current_layer, current_extruder):
current_layer += 1 current_layer += 1
current_path.clear()
else: else:
current_path.clear() current_path.clear()
if len(current_path) > 1: if len(current_path) > 1 and current_z > 0:
if self.createPolygon(layer_data, current_path, current_layer, current_extruder): if self._createPolygon(layer_data_builder, current_path, current_layer, current_extruder):
current_layer += 1 current_layer += 1
current_path.clear()
layer_mesh = layer_data.build() layer_mesh = layer_data_builder.build()
decorator = LayerDataDecorator.LayerDataDecorator() decorator = LayerDataDecorator.LayerDataDecorator()
decorator.setLayerData(layer_mesh) decorator.setLayerData(layer_mesh)
self.scene_node.removeDecorator("LayerDataDecorator") self._scene_node.removeDecorator("LayerDataDecorator")
self.scene_node.addDecorator(decorator) self._scene_node.addDecorator(decorator)
Logger.log("d", "Finished parsing %s" % file_name) Logger.log("d", "Finished parsing %s" % file_name)
self.message.hide() self._message.hide()
if current_layer == 0: if current_layer == 0:
Logger.log("w", "File %s doesn't contain any valid layers" % file_name) Logger.log("w", "File %s doesn't contain any valid layers" % file_name)
Application.getInstance().getPrintInformation().setPreSliced(True) Application.getInstance().getPrintInformation().setPreSliced(True)
Application.getInstance().setHideSettings(True)
settings = Application.getInstance().getGlobalContainerStack() settings = Application.getInstance().getGlobalContainerStack()
machine_width = settings.getProperty("machine_width", "value") machine_width = settings.getProperty("machine_width", "value")
machine_depth = settings.getProperty("machine_depth", "value") machine_depth = settings.getProperty("machine_depth", "value")
self.scene_node.setPosition(Vector(-machine_width / 2, 0, machine_depth / 2)) self._scene_node.setPosition(Vector(-machine_width / 2, 0, machine_depth / 2))
view = Application.getInstance().getController().getActiveView() Logger.log("d", "Loaded %s" % file_name)
if view.getPluginId() == "LayerView":
view.resetLayerData()
view.setLayer(999999)
view.calculateMaxLayers()
Logger.log("d", "Loaded %s" % file_name) return self._scene_node
return self.scene_node