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):
self.getController().setActiveView("LayerView")
view = self.getController().getActiveView()
view.resetLayerData()
view.setLayer(999999)
view.calculateMaxLayers()
@pyqtSlot(QUrl)
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()):
if node.callDecoration("getLayerData"):
node.getParent().removeChild(node)
break
if self._abort_requested:
if self._progress:
self._progress.hide()

172
plugins/GCodeReader/GCodeReader.py
View file

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