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

Almost done with manual and auto slicing. CURA-3214

Browse source
This commit is contained in:
Jack Ha 2017-02-15 16:02:14 +01:00
parent 94badb1b9f
commit db984561e9
1 changed files with 27 additions and 42 deletions
Download patch file Download diff file Expand all files Collapse all files

65
plugins/CuraEngineBackend/CuraEngineBackend.py
View file

@ -95,7 +95,7 @@ class CuraEngineBackend(Backend):
self._start_slice_job = None self._start_slice_job = None
self._slicing = False # Are we currently slicing? self._slicing = False # Are we currently slicing?
self._restart = False # Back-end is currently restarting? self._restart = False # Back-end is currently restarting?
self._enabled = True # Should we be slicing? Slicing might be paused when, for instance, the user is dragging the mesh around. self._tool_active = False # If a tool is active, some tasks do not have to do anything
self._always_restart = True # Always restart the engine when starting a new slice. Don't keep the process running. TODO: Fix engine statelessness. self._always_restart = True # Always restart the engine when starting a new slice. Don't keep the process running. TODO: Fix engine statelessness.
self._process_layers_job = None # The currently active job to process layers, or None if it is not processing layers. self._process_layers_job = None # The currently active job to process layers, or None if it is not processing layers.
self._need_slicing = False self._need_slicing = False
@ -150,6 +150,7 @@ class CuraEngineBackend(Backend):
self.backendStateChange.emit(BackendState.NotStarted) self.backendStateChange.emit(BackendState.NotStarted)
if self._slicing: # We were already slicing. Stop the old job. if self._slicing: # We were already slicing. Stop the old job.
self._terminate() self._terminate()
self._createSocket()
if self._process_layers_job: # We were processing layers. Stop that, the layers are going to change soon. if self._process_layers_job: # We were processing layers. Stop that, the layers are going to change soon.
self._process_layers_job.abort() self._process_layers_job.abort()
@ -162,13 +163,8 @@ class CuraEngineBackend(Backend):
def slice(self): def slice(self):
Logger.log("d", "Starting slice job...") Logger.log("d", "Starting slice job...")
self._slice_start_time = time() self._slice_start_time = time()
# if not self._enabled or not self._global_container_stack: # We shouldn't be slicing.
# if self._use_timer:
# # try again in a short time
# self._change_timer.start()
# return
if not self._need_slicing: if not self._need_slicing:
Logger.log("d", "Do not need to slice") Logger.log("w", "Do not need to slice, optimizable or programming error.")
return return
self.printDurationMessage.emit(0, [0]) self.printDurationMessage.emit(0, [0])
@ -195,12 +191,9 @@ class CuraEngineBackend(Backend):
self._start_slice_job.finished.connect(self._onStartSliceCompleted) self._start_slice_job.finished.connect(self._onStartSliceCompleted)
## Terminate the engine process. ## Terminate the engine process.
# Start the engine process by calling _createSocket()
def _terminate(self): def _terminate(self):
# # Process is none, Try and re-create the socket????
# self._createSocket()
# return
self._slicing = False self._slicing = False
self._restart = True
self._stored_layer_data = [] self._stored_layer_data = []
self._stored_optimized_layer_data = [] self._stored_optimized_layer_data = []
if self._start_slice_job is not None: if self._start_slice_job is not None:
@ -222,9 +215,6 @@ class CuraEngineBackend(Backend):
except Exception as e: # terminating a process that is already terminating causes an exception, silently ignore this. except Exception as e: # terminating a process that is already terminating causes an exception, silently ignore this.
Logger.log("d", "Exception occurred while trying to kill the engine %s", str(e)) Logger.log("d", "Exception occurred while trying to kill the engine %s", str(e))
# else:
# # Process is none, but something did went wrong here. Try and re-create the socket
# self._createSocket()
## Event handler to call when the job to initiate the slicing process is ## Event handler to call when the job to initiate the slicing process is
# completed. # completed.
@ -300,7 +290,7 @@ class CuraEngineBackend(Backend):
Logger.log("d", "Sending slice message took %s seconds", time() - self._slice_start_time ) Logger.log("d", "Sending slice message took %s seconds", time() - self._slice_start_time )
## Determine enable or disable slicing. ## Determine enable or disable auto slicing. Return True for enable timer and False otherwise.
# It disables when # It disables when
# - preference auto slice is off # - preference auto slice is off
# - decorator isBlockSlicing is found (used in g-code reader) # - decorator isBlockSlicing is found (used in g-code reader)
@ -320,13 +310,12 @@ class CuraEngineBackend(Backend):
if self._use_timer == enable_timer: if self._use_timer == enable_timer:
return return
if enable_timer: if enable_timer:
self._enabled = True
self.backendStateChange.emit(BackendState.NotStarted) self.backendStateChange.emit(BackendState.NotStarted)
self.enableTimer() self.enableTimer()
return True
else: else:
self._enabled = False
# self.close()
self.disableTimer() self.disableTimer()
return False
## Listener for when the scene has changed. ## Listener for when the scene has changed.
# #
@ -334,6 +323,9 @@ class CuraEngineBackend(Backend):
# #
# \param source The scene node that was changed. # \param source The scene node that was changed.
def _onSceneChanged(self, source): def _onSceneChanged(self, source):
if self._tool_active:
return
if type(source) is not SceneNode: if type(source) is not SceneNode:
return return
@ -364,27 +356,26 @@ class CuraEngineBackend(Backend):
return return
self._terminate() self._terminate()
self._createSocket()
if error.getErrorCode() not in [Arcus.ErrorCode.BindFailedError, Arcus.ErrorCode.ConnectionResetError, Arcus.ErrorCode.Debug]: if error.getErrorCode() not in [Arcus.ErrorCode.BindFailedError, Arcus.ErrorCode.ConnectionResetError, Arcus.ErrorCode.Debug]:
Logger.log("w", "A socket error caused the connection to be reset") Logger.log("w", "A socket error caused the connection to be reset")
## Remove old layer data (if any)
## TODO: now copied from ProcessSlicedLayersJob. Find my a home. ## TODO: now copied from ProcessSlicedLayersJob. Find my a home.
def _clearLayerData(self): def _clearLayerData(self):
## Remove old layer data (if any)
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 break
# if self._abort_requested:
# if self._progress:
# self._progress.hide()
# return
## Convenient function: set need_slicing, emit state and clear layer data ## Convenient function: set need_slicing, emit state and clear layer data
def needSlicing(self): def needSlicing(self):
self._need_slicing = True self._need_slicing = True # For now only for debugging purposes
self.processingProgress.emit(0.0) self.processingProgress.emit(0.0)
self.backendStateChange.emit(BackendState.NotStarted) self.backendStateChange.emit(BackendState.NotStarted)
if not self._use_timer:
# With manually having to slice, we want to clear the old invalid layer data.
self._clearLayerData() self._clearLayerData()
## A setting has changed, so check if we must reslice. ## A setting has changed, so check if we must reslice.
@ -469,14 +460,15 @@ class CuraEngineBackend(Backend):
# #
# This indicates that we should probably re-slice soon. # This indicates that we should probably re-slice soon.
def _onChanged(self, *args, **kwargs): def _onChanged(self, *args, **kwargs):
self.needSlicing()
if self._use_timer: if self._use_timer:
self.forceSlice() self._change_timer.start()
## Called when the back-end connects to the front-end. ## Called when the back-end connects to the front-end.
def _onBackendConnected(self): def _onBackendConnected(self):
if self._restart: if self._restart:
self._onChanged()
self._restart = False self._restart = False
self._onChanged()
## Called when the user starts using some tool. ## Called when the user starts using some tool.
# #
@ -485,9 +477,8 @@ class CuraEngineBackend(Backend):
# #
# \param tool The tool that the user is using. # \param tool The tool that the user is using.
def _onToolOperationStarted(self, tool): def _onToolOperationStarted(self, tool):
self._enabled = False # Do not reslice when a tool is doing it's 'thing' self._tool_active = True # Do not react on scene change
if self._use_timer: self.disableTimer()
self._terminate() # Do not continue slicing once a tool has started
## Called when the user stops using some tool. ## Called when the user stops using some tool.
# #
@ -495,8 +486,8 @@ class CuraEngineBackend(Backend):
# #
# \param tool The tool that the user was using. # \param tool The tool that the user was using.
def _onToolOperationStopped(self, tool): def _onToolOperationStopped(self, tool):
self.needSlicing() self._tool_active = False # React on scene change again
self._enabled = True # Tool stop, start listening for changes again. self.determineAutoSlicing()
## Called when the user changes the active view mode. ## Called when the user changes the active view mode.
def _onActiveViewChanged(self): def _onActiveViewChanged(self):
@ -525,8 +516,6 @@ class CuraEngineBackend(Backend):
## Called when the global container stack changes ## Called when the global container stack changes
def _onGlobalStackChanged(self): def _onGlobalStackChanged(self):
self.needSlicing()
if self._global_container_stack: if self._global_container_stack:
self._global_container_stack.propertyChanged.disconnect(self._onSettingChanged) self._global_container_stack.propertyChanged.disconnect(self._onSettingChanged)
self._global_container_stack.containersChanged.disconnect(self._onChanged) self._global_container_stack.containersChanged.disconnect(self._onChanged)
@ -548,8 +537,6 @@ class CuraEngineBackend(Backend):
self._onChanged() self._onChanged()
def _onActiveExtruderChanged(self): def _onActiveExtruderChanged(self):
self.needSlicing()
if self._global_container_stack: if self._global_container_stack:
# Connect all extruders of the active machine. This might cause a few connects that have already happend, # Connect all extruders of the active machine. This might cause a few connects that have already happend,
# but that shouldn't cause issues as only new / unique connections are added. # but that shouldn't cause issues as only new / unique connections are added.
@ -569,9 +556,7 @@ class CuraEngineBackend(Backend):
def enableTimer(self): def enableTimer(self):
self.disableTimer() # disable any existing timer self.disableTimer() # disable any existing timer
self._enabled = True
self._use_timer = True self._use_timer = True
self._restart = True
# When you update a setting and other settings get changed through inheritance, many propertyChanged signals are fired. # When you update a setting and other settings get changed through inheritance, many propertyChanged signals are fired.
# This timer will group them up, and only slice for the last setting changed signal. # This timer will group them up, and only slice for the last setting changed signal.
# TODO: Properly group propertyChanged signals by whether they are triggered by the same user interaction. # TODO: Properly group propertyChanged signals by whether they are triggered by the same user interaction.
@ -583,14 +568,14 @@ class CuraEngineBackend(Backend):
## Disable timer. ## Disable timer.
# This means that slicing will not be triggered automatically # This means that slicing will not be triggered automatically
def disableTimer(self): def disableTimer(self):
self._enabled = False
if self._change_timer is not None: if self._change_timer is not None:
self._change_timer.timeout.disconnect() self._change_timer.timeout.disconnect()
self._change_timer = None self._change_timer = None
self._use_timer = False self._use_timer = False
self._restart = False
def _onPreferencesChanged(self, preference): def _onPreferencesChanged(self, preference):
if preference != "general/auto_slice": if preference != "general/auto_slice":
return return
self.determineAutoSlicing() auto_slice = self.determineAutoSlicing()
if auto_slice:
self._change_timer.start()