Merge pull request #3029 from Ultimaker/CURA-4525-multi-build-plate-merge

CURA-4525 multi build plate (master merged 2018-1-3)

cura/Arranging/Arrange.py

@@ -1,8 +1,8 @@
 from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
 from UM.Logger import Logger
 from UM.Math.Vector import Vector
-from cura.ShapeArray import ShapeArray
+from cura.Arranging.ShapeArray import ShapeArray
-from cura import ZOffsetDecorator
+from cura.Scene import ZOffsetDecorator
 
 from collections import namedtuple
 
@@ -30,6 +30,7 @@ class Arrange:
         self._offset_x = offset_x
         self._offset_y = offset_y
         self._last_priority = 0
+        self._is_empty = True
 
     ##  Helper to create an Arranger instance
     #
@@ -38,8 +39,8 @@ class Arrange:
     #   \param scene_root   Root for finding all scene nodes
     #   \param fixed_nodes  Scene nodes to be placed
     @classmethod
-    def create(cls, scene_root = None, fixed_nodes = None, scale = 0.5):
+    def create(cls, scene_root = None, fixed_nodes = None, scale = 0.5, x = 220, y = 220):
-        arranger = Arrange(220, 220, 110, 110, scale = scale)
+        arranger = Arrange(x, y, x // 2, y // 2, scale = scale)
         arranger.centerFirst()
 
         if fixed_nodes is None:
@@ -64,7 +65,7 @@ class Arrange:
             for area in disallowed_areas:
                 points = copy.deepcopy(area._points)
                 shape_arr = ShapeArray.fromPolygon(points, scale = scale)
-                arranger.place(0, 0, shape_arr)
+                arranger.place(0, 0, shape_arr, update_empty = False)
         return arranger
 
     ##  Find placement for a node (using offset shape) and place it (using hull shape)
@@ -168,7 +169,8 @@ class Arrange:
     #   \param x x-coordinate
     #   \param y y-coordinate
     #   \param shape_arr ShapeArray object
-    def place(self, x, y, shape_arr):
+    #   \param update_empty updates the _is_empty, used when adding disallowed areas
+    def place(self, x, y, shape_arr, update_empty = True):
         x = int(self._scale * x)
         y = int(self._scale * y)
         offset_x = x + self._offset_x + shape_arr.offset_x
@@ -181,10 +183,17 @@ class Arrange:
         max_y = min(max(offset_y + shape_arr.arr.shape[0], 0), shape_y - 1)
         occupied_slice = self._occupied[min_y:max_y, min_x:max_x]
         # we use a slice of shape because it can be out of bounds
-        occupied_slice[numpy.where(shape_arr.arr[
+        new_occupied = numpy.where(shape_arr.arr[
-            min_y - offset_y:max_y - offset_y, min_x - offset_x:max_x - offset_x] == 1)] = 1
+            min_y - offset_y:max_y - offset_y, min_x - offset_x:max_x - offset_x] == 1)
+        if update_empty and new_occupied:
+            self._is_empty = False
+        occupied_slice[new_occupied] = 1
 
         # Set priority to low (= high number), so it won't get picked at trying out.
         prio_slice = self._priority[min_y:max_y, min_x:max_x]
         prio_slice[numpy.where(shape_arr.arr[
             min_y - offset_y:max_y - offset_y, min_x - offset_x:max_x - offset_x] == 1)] = 999
+
+    @property
+    def isEmpty(self):
+        return self._is_empty

cura/Arranging/ArrangeObjectsAllBuildPlatesJob.py

@@ -0,0 +1,154 @@
+# Copyright (c) 2017 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from UM.Job import Job
+from UM.Scene.SceneNode import SceneNode
+from UM.Math.Vector import Vector
+from UM.Operations.TranslateOperation import TranslateOperation
+from UM.Operations.GroupedOperation import GroupedOperation
+from UM.Message import Message
+from UM.i18n import i18nCatalog
+i18n_catalog = i18nCatalog("cura")
+
+from cura.Scene.ZOffsetDecorator import ZOffsetDecorator
+from cura.Arranging.Arrange import Arrange
+from cura.Arranging.ShapeArray import ShapeArray
+
+from typing import List
+
+
+class ArrangeArray:
+    def __init__(self, x: int, y: int, fixed_nodes: List[SceneNode]):
+        self._x = x
+        self._y = y
+        self._fixed_nodes = fixed_nodes
+        self._count = 0
+        self._first_empty = None
+        self._has_empty = False
+        self._arrange = []
+
+    def _update_first_empty(self):
+        for i, a in enumerate(self._arrange):
+            if a.isEmpty:
+                self._first_empty = i
+                self._has_empty = True
+                return
+        self._first_empty = None
+        self._has_empty = False
+
+    def add(self):
+        new_arrange = Arrange.create(x = self._x, y = self._y, fixed_nodes = self._fixed_nodes)
+        self._arrange.append(new_arrange)
+        self._count += 1
+        self._update_first_empty()
+
+    def count(self):
+        return self._count
+
+    def get(self, index):
+        return self._arrange[index]
+
+    def getFirstEmpty(self):
+        if not self._is_empty:
+            self.add()
+        return self._arrange[self._first_empty]
+
+
+class ArrangeObjectsAllBuildPlatesJob(Job):
+    def __init__(self, nodes: List[SceneNode], min_offset = 8):
+        super().__init__()
+        self._nodes = nodes
+        self._min_offset = min_offset
+
+    def run(self):
+        status_message = Message(i18n_catalog.i18nc("@info:status", "Finding new location for objects"),
+                                 lifetime = 0,
+                                 dismissable=False,
+                                 progress = 0,
+                                 title = i18n_catalog.i18nc("@info:title", "Finding Location"))
+        status_message.show()
+
+
+        # Collect nodes to be placed
+        nodes_arr = []  # fill with (size, node, offset_shape_arr, hull_shape_arr)
+        for node in self._nodes:
+            offset_shape_arr, hull_shape_arr = ShapeArray.fromNode(node, min_offset = self._min_offset)
+            nodes_arr.append((offset_shape_arr.arr.shape[0] * offset_shape_arr.arr.shape[1], node, offset_shape_arr, hull_shape_arr))
+
+        # Sort the nodes with the biggest area first.
+        nodes_arr.sort(key=lambda item: item[0])
+        nodes_arr.reverse()
+
+        x, y = 200, 200
+
+        arrange_array = ArrangeArray(x = x, y = y, fixed_nodes = [])
+        arrange_array.add()
+
+        # Place nodes one at a time
+        start_priority = 0
+        grouped_operation = GroupedOperation()
+        found_solution_for_all = True
+        left_over_nodes = []  # nodes that do not fit on an empty build plate
+
+        for idx, (size, node, offset_shape_arr, hull_shape_arr) in enumerate(nodes_arr):
+            # For performance reasons, we assume that when a location does not fit,
+            # it will also not fit for the next object (while what can be untrue).
+            # We also skip possibilities by slicing through the possibilities (step = 10)
+
+            try_placement = True
+
+            current_build_plate_number = 0  # always start with the first one
+
+            # # Only for first build plate
+            # if last_size == size and last_build_plate_number == current_build_plate_number:
+            #     # This optimization works if many of the objects have the same size
+            #     # Continue with same build plate number
+            #     start_priority = last_priority
+            # else:
+            #     start_priority = 0
+
+            while try_placement:
+                # make sure that current_build_plate_number is not going crazy or you'll have a lot of arrange objects
+                while current_build_plate_number >= arrange_array.count():
+                    arrange_array.add()
+                arranger = arrange_array.get(current_build_plate_number)
+
+                best_spot = arranger.bestSpot(offset_shape_arr, start_prio=start_priority, step=10)
+                x, y = best_spot.x, best_spot.y
+                node.removeDecorator(ZOffsetDecorator)
+                if node.getBoundingBox():
+                    center_y = node.getWorldPosition().y - node.getBoundingBox().bottom
+                else:
+                    center_y = 0
+                if x is not None:  # We could find a place
+                    arranger.place(x, y, hull_shape_arr)  # place the object in the arranger
+
+                    node.callDecoration("setBuildPlateNumber", current_build_plate_number)
+                    grouped_operation.addOperation(TranslateOperation(node, Vector(x, center_y, y), set_position = True))
+                    try_placement = False
+                else:
+                    # very naive, because we skip to the next build plate if one model doesn't fit.
+                    if arranger.isEmpty:
+                        # apparently we can never place this object
+                        left_over_nodes.append(node)
+                        try_placement = False
+                    else:
+                        # try next build plate
+                        current_build_plate_number += 1
+                        try_placement = True
+
+            status_message.setProgress((idx + 1) / len(nodes_arr) * 100)
+            Job.yieldThread()
+
+        for node in left_over_nodes:
+            node.callDecoration("setBuildPlateNumber", -1)  # these are not on any build plate
+            found_solution_for_all = False
+
+        grouped_operation.push()
+
+        status_message.hide()
+
+        if not found_solution_for_all:
+            no_full_solution_message = Message(i18n_catalog.i18nc("@info:status", "Unable to find a location within the build volume for all objects"),
+                                               title = i18n_catalog.i18nc("@info:title", "Can't Find Location"))
+            no_full_solution_message.show()

cura/Arranging/ArrangeObjectsJob.py

@@ -4,7 +4,6 @@
 from UM.Job import Job
 from UM.Scene.SceneNode import SceneNode
 from UM.Math.Vector import Vector
-from UM.Operations.SetTransformOperation import SetTransformOperation
 from UM.Operations.TranslateOperation import TranslateOperation
 from UM.Operations.GroupedOperation import GroupedOperation
 from UM.Logger import Logger
@@ -12,9 +11,9 @@ from UM.Message import Message
 from UM.i18n import i18nCatalog
 i18n_catalog = i18nCatalog("cura")
 
-from cura.ZOffsetDecorator import ZOffsetDecorator
+from cura.Scene.ZOffsetDecorator import ZOffsetDecorator
-from cura.Arrange import Arrange
+from cura.Arranging.Arrange import Arrange
-from cura.ShapeArray import ShapeArray
+from cura.Arranging.ShapeArray import ShapeArray
 
 from typing import List
 

cura/BuildPlateModel.py

@@ -0,0 +1,53 @@
+from PyQt5.QtCore import pyqtSignal, pyqtProperty, pyqtSlot
+
+from UM.Qt.ListModel import ListModel
+from UM.Scene.Selection import Selection
+from UM.Logger import Logger
+from UM.Application import Application
+
+
+class BuildPlateModel(ListModel):
+    maxBuildPlateChanged = pyqtSignal()
+    activeBuildPlateChanged = pyqtSignal()
+    selectionChanged = pyqtSignal()
+
+    def __init__(self):
+        super().__init__()
+        Application.getInstance().getController().getScene().sceneChanged.connect(self._updateSelectedObjectBuildPlateNumbers)
+        Selection.selectionChanged.connect(self._updateSelectedObjectBuildPlateNumbers)
+
+        self._max_build_plate = 1  # default
+        self._active_build_plate = -1
+        self._selection_build_plates = []
+
+    def setMaxBuildPlate(self, max_build_plate):
+        self._max_build_plate = max_build_plate
+        self.maxBuildPlateChanged.emit()
+
+    ##  Return the highest build plate number
+    @pyqtProperty(int, notify = maxBuildPlateChanged)
+    def maxBuildPlate(self):
+        return self._max_build_plate
+
+    def setActiveBuildPlate(self, nr):
+        self._active_build_plate = nr
+        self.activeBuildPlateChanged.emit()
+
+    @pyqtProperty(int, notify = activeBuildPlateChanged)
+    def activeBuildPlate(self):
+        return self._active_build_plate
+
+    @staticmethod
+    def createBuildPlateModel():
+        return BuildPlateModel()
+
+    def _updateSelectedObjectBuildPlateNumbers(self, *args):
+        result = set()
+        for node in Selection.getAllSelectedObjects():
+            result.add(node.callDecoration("getBuildPlateNumber"))
+        self._selection_build_plates = list(result)
+        self.selectionChanged.emit()
+
+    @pyqtProperty("QVariantList", notify = selectionChanged)
+    def selectionBuildPlates(self):
+        return self._selection_build_plates

cura/CuraActions.py

@@ -15,11 +15,16 @@ from UM.Operations.RemoveSceneNodeOperation import RemoveSceneNodeOperation
 from UM.Operations.SetTransformOperation import SetTransformOperation
 from UM.Operations.TranslateOperation import TranslateOperation
 
-from cura.SetParentOperation import SetParentOperation
+from cura.Operations.SetParentOperation import SetParentOperation
 from cura.MultiplyObjectsJob import MultiplyObjectsJob
 from cura.Settings.SetObjectExtruderOperation import SetObjectExtruderOperation
 from cura.Settings.ExtruderManager import ExtruderManager
 
+from cura.Operations.SetBuildPlateNumberOperation import SetBuildPlateNumberOperation
+
+from UM.Logger import Logger
+
+
 class CuraActions(QObject):
     def __init__(self, parent = None):
         super().__init__(parent)
@@ -129,5 +134,31 @@ class CuraActions(QObject):
             operation.addOperation(SetObjectExtruderOperation(node, extruder_id))
         operation.push()
 
+    @pyqtSlot(int)
+    def setBuildPlateForSelection(self, build_plate_nr: int) -> None:
+        Logger.log("d", "Setting build plate number... %d" % build_plate_nr)
+        operation = GroupedOperation()
+
+        root = Application.getInstance().getController().getScene().getRoot()
+
+        nodes_to_change = []
+        for node in Selection.getAllSelectedObjects():
+            parent_node = node  # Find the parent node to change instead
+            while parent_node.getParent() != root:
+                parent_node = parent_node.getParent()
+
+            for single_node in BreadthFirstIterator(parent_node):
+                nodes_to_change.append(single_node)
+
+        if not nodes_to_change:
+            Logger.log("d", "Nothing to change.")
+            return
+
+        for node in nodes_to_change:
+            operation.addOperation(SetBuildPlateNumberOperation(node, build_plate_nr))
+        operation.push()
+
+        Selection.clear()
+
     def _openUrl(self, url):
         QDesktopServices.openUrl(url)

cura/CuraApplication.py

@@ -1,4 +1,5 @@
 # Copyright (c) 2017 Ultimaker B.V.
+# Copyright (c) 2017 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 from PyQt5.QtNetwork import QLocalServer
 from PyQt5.QtNetwork import QLocalSocket
@@ -16,7 +17,6 @@ from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
 from UM.Mesh.ReadMeshJob import ReadMeshJob
 from UM.Logger import Logger
 from UM.Preferences import Preferences
-from UM.SaveFile import SaveFile
 from UM.Scene.Selection import Selection
 from UM.Scene.GroupDecorator import GroupDecorator
 from UM.Settings.ContainerStack import ContainerStack
@@ -32,15 +32,19 @@ from UM.Operations.RemoveSceneNodeOperation import RemoveSceneNodeOperation
 from UM.Operations.GroupedOperation import GroupedOperation
 from UM.Operations.SetTransformOperation import SetTransformOperation
 
-from cura.Arrange import Arrange
+from cura.Arranging.Arrange import Arrange
-from cura.ShapeArray import ShapeArray
+from cura.Arranging.ArrangeObjectsJob import ArrangeObjectsJob
-from cura.ConvexHullDecorator import ConvexHullDecorator
+from cura.Arranging.ArrangeObjectsAllBuildPlatesJob import ArrangeObjectsAllBuildPlatesJob
-from cura.SetParentOperation import SetParentOperation
+from cura.Arranging.ShapeArray import ShapeArray
-from cura.SliceableObjectDecorator import SliceableObjectDecorator
-from cura.BlockSlicingDecorator import BlockSlicingDecorator
-
-from cura.ArrangeObjectsJob import ArrangeObjectsJob
 from cura.MultiplyObjectsJob import MultiplyObjectsJob
+from cura.Scene.ConvexHullDecorator import ConvexHullDecorator
+from cura.Operations.SetParentOperation import SetParentOperation
+from cura.Scene.SliceableObjectDecorator import SliceableObjectDecorator
+from cura.Scene.BlockSlicingDecorator import BlockSlicingDecorator
+from cura.Scene.BuildPlateDecorator import BuildPlateDecorator
+from cura.Scene.CuraSceneNode import CuraSceneNode
+
+from cura.CuraSceneController import CuraSceneController
 
 from UM.Settings.SettingDefinition import SettingDefinition, DefinitionPropertyType
 from UM.Settings.ContainerRegistry import ContainerRegistry
@@ -53,12 +57,13 @@ from cura.Settings.SettingInheritanceManager import SettingInheritanceManager
 from cura.Settings.UserProfilesModel import UserProfilesModel
 from cura.Settings.SimpleModeSettingsManager import SimpleModeSettingsManager
 
+
 from . import PlatformPhysics
 from . import BuildVolume
 from . import CameraAnimation
 from . import PrintInformation
 from . import CuraActions
-from . import ZOffsetDecorator
+from cura.Scene import ZOffsetDecorator
 from . import CuraSplashScreen
 from . import CameraImageProvider
 from . import MachineActionManager
@@ -72,8 +77,9 @@ from cura.Settings.ContainerSettingsModel import ContainerSettingsModel
 from cura.Settings.MaterialSettingsVisibilityHandler import MaterialSettingsVisibilityHandler
 from cura.Settings.QualitySettingsModel import QualitySettingsModel
 from cura.Settings.ContainerManager import ContainerManager
-from cura.Settings.GlobalStack import GlobalStack
+
-from cura.Settings.ExtruderStack import ExtruderStack
+from cura.ObjectsModel import ObjectsModel
+from cura.BuildPlateModel import BuildPlateModel
 
 from PyQt5.QtCore import QUrl, pyqtSignal, pyqtProperty, QEvent, Q_ENUMS
 from UM.FlameProfiler import pyqtSlot
@@ -85,7 +91,6 @@ import sys
 import os.path
 import numpy
 import copy
-import urllib.parse
 import os
 import argparse
 import json
@@ -203,8 +208,11 @@ class CuraApplication(QtApplication):
         self._machine_manager = None    # This is initialized on demand.
         self._extruder_manager = None
         self._material_manager = None
+        self._object_manager = None
+        self._build_plate_model = None
         self._setting_inheritance_manager = None
         self._simple_mode_settings_manager = None
+        self._cura_scene_controller = None
 
         self._additional_components = {} # Components to add to certain areas in the interface
 
@@ -311,11 +319,14 @@ class CuraApplication(QtApplication):
         preferences.addPreference("cura/asked_dialog_on_project_save", False)
         preferences.addPreference("cura/choice_on_profile_override", "always_ask")
         preferences.addPreference("cura/choice_on_open_project", "always_ask")
+        preferences.addPreference("cura/arrange_objects_on_load", True)
+        preferences.addPreference("cura/use_multi_build_plate", False)
 
         preferences.addPreference("cura/currency", "€")
         preferences.addPreference("cura/material_settings", "{}")
 
         preferences.addPreference("view/invert_zoom", False)
+        preferences.addPreference("view/filter_current_build_plate", False)
         preferences.addPreference("cura/sidebar_collapsed", False)
 
         self._need_to_show_user_agreement = not Preferences.getInstance().getValue("general/accepted_user_agreement")
@@ -389,6 +400,8 @@ class CuraApplication(QtApplication):
 
         self._plugin_registry.addSupportedPluginExtension("curaplugin", "Cura Plugin")
 
+        self.getCuraSceneController().setActiveBuildPlate(0)  # Initialize
+
     def _onEngineCreated(self):
         self._engine.addImageProvider("camera", CameraImageProvider.CameraImageProvider())
 
@@ -684,8 +697,16 @@ class CuraApplication(QtApplication):
         qmlRegisterSingletonType(ExtruderManager, "Cura", 1, 0, "ExtruderManager", self.getExtruderManager)
         qmlRegisterSingletonType(MachineManager, "Cura", 1, 0, "MachineManager", self.getMachineManager)
         qmlRegisterSingletonType(MaterialManager, "Cura", 1, 0, "MaterialManager", self.getMaterialManager)
-        qmlRegisterSingletonType(SettingInheritanceManager, "Cura", 1, 0, "SettingInheritanceManager", self.getSettingInheritanceManager)
+
-        qmlRegisterSingletonType(SimpleModeSettingsManager, "Cura", 1, 2, "SimpleModeSettingsManager", self.getSimpleModeSettingsManager)
+        qmlRegisterSingletonType(SettingInheritanceManager, "Cura", 1, 0, "SettingInheritanceManager",
+                                 self.getSettingInheritanceManager)
+        qmlRegisterSingletonType(SimpleModeSettingsManager, "Cura", 1, 2, "SimpleModeSettingsManager",
+                                 self.getSimpleModeSettingsManager)
+
+        qmlRegisterSingletonType(ObjectsModel, "Cura", 1, 2, "ObjectsModel", self.getObjectsModel)
+        qmlRegisterSingletonType(BuildPlateModel, "Cura", 1, 2, "BuildPlateModel", self.getBuildPlateModel)
+        qmlRegisterSingletonType(CuraSceneController, "Cura", 1, 2, "SceneController", self.getCuraSceneController)
+
         qmlRegisterSingletonType(MachineActionManager.MachineActionManager, "Cura", 1, 0, "MachineActionManager", self.getMachineActionManager)
 
         self.setMainQml(Resources.getPath(self.ResourceTypes.QmlFiles, "Cura.qml"))
@@ -723,6 +744,22 @@ class CuraApplication(QtApplication):
             self._material_manager = MaterialManager.createMaterialManager()
         return self._material_manager
 
+    def getObjectsModel(self, *args):
+        if self._object_manager is None:
+            self._object_manager = ObjectsModel.createObjectsModel()
+        return self._object_manager
+
+    def getBuildPlateModel(self, *args):
+        if self._build_plate_model is None:
+            self._build_plate_model = BuildPlateModel.createBuildPlateModel()
+
+        return self._build_plate_model
+
+    def getCuraSceneController(self, *args):
+        if self._cura_scene_controller is None:
+            self._cura_scene_controller = CuraSceneController.createCuraSceneController()
+        return self._cura_scene_controller
+
     def getSettingInheritanceManager(self, *args):
         if self._setting_inheritance_manager is None:
             self._setting_inheritance_manager = SettingInheritanceManager.createSettingInheritanceManager()
@@ -858,7 +895,7 @@ class CuraApplication(QtApplication):
         scene_bounding_box = None
         is_block_slicing_node = False
         for node in DepthFirstIterator(self.getController().getScene().getRoot()):
-            if type(node) is not SceneNode or (not node.getMeshData() and not node.callDecoration("getLayerData")):
+            if not issubclass(type(node), SceneNode) or (not node.getMeshData() and not node.callDecoration("getLayerData")):
                 continue
             if node.callDecoration("isBlockSlicing"):
                 is_block_slicing_node = True
@@ -975,7 +1012,7 @@ class CuraApplication(QtApplication):
 
         Selection.clear()
         for node in DepthFirstIterator(self.getController().getScene().getRoot()):
-            if type(node) is not SceneNode:
+            if not issubclass(type(node), SceneNode):
                 continue
             if not node.getMeshData() and not node.callDecoration("isGroup"):
                 continue  # Node that doesnt have a mesh and is not a group.
@@ -983,6 +1020,9 @@ class CuraApplication(QtApplication):
                 continue  # Grouped nodes don't need resetting as their parent (the group) is resetted)
             if not node.isSelectable():
                 continue  # i.e. node with layer data
+            if not node.callDecoration("isSliceable"):
+                continue  # i.e. node with layer data
+
             Selection.add(node)
 
     ##  Delete all nodes containing mesh data in the scene.
@@ -994,7 +1034,7 @@ class CuraApplication(QtApplication):
 
         nodes = []
         for node in DepthFirstIterator(self.getController().getScene().getRoot()):
-            if type(node) is not SceneNode:
+            if type(node) not in {SceneNode, CuraSceneNode}:
                 continue
             if (not node.getMeshData() and not node.callDecoration("getLayerData")) and not node.callDecoration("isGroup"):
                 continue  # Node that doesnt have a mesh and is not a group.
@@ -1010,13 +1050,15 @@ class CuraApplication(QtApplication):
             op.push()
             Selection.clear()
 
-    ## Reset all translation on nodes with mesh data. 
+        self.getCuraSceneController().setActiveBuildPlate(0)  # Select first build plate
+
+    ## Reset all translation on nodes with mesh data.
     @pyqtSlot()
     def resetAllTranslation(self):
         Logger.log("i", "Resetting all scene translations")
         nodes = []
         for node in DepthFirstIterator(self.getController().getScene().getRoot()):
-            if type(node) is not SceneNode:
+            if not issubclass(type(node), SceneNode):
                 continue
             if not node.getMeshData() and not node.callDecoration("isGroup"):
                 continue  # Node that doesnt have a mesh and is not a group.
@@ -1044,13 +1086,13 @@ class CuraApplication(QtApplication):
         Logger.log("i", "Resetting all scene transformations")
         nodes = []
         for node in DepthFirstIterator(self.getController().getScene().getRoot()):
-            if type(node) is not SceneNode:
+            if not issubclass(type(node), SceneNode):
                 continue
             if not node.getMeshData() and not node.callDecoration("isGroup"):
                 continue  # Node that doesnt have a mesh and is not a group.
             if node.getParent() and node.getParent().callDecoration("isGroup"):
                 continue  # Grouped nodes don't need resetting as their parent (the group) is resetted)
-            if not node.isSelectable():
+            if not node.callDecoration("isSliceable"):
                 continue  # i.e. node with layer data
             nodes.append(node)
 
@@ -1068,10 +1110,31 @@ class CuraApplication(QtApplication):
 
     ##  Arrange all objects.
     @pyqtSlot()
-    def arrangeAll(self):
+    def arrangeObjectsToAllBuildPlates(self):
         nodes = []
         for node in DepthFirstIterator(self.getController().getScene().getRoot()):
-            if type(node) is not SceneNode:
+            if not issubclass(type(node), SceneNode):
+                continue
+            if not node.getMeshData() and not node.callDecoration("isGroup"):
+                continue  # Node that doesnt have a mesh and is not a group.
+            if node.getParent() and node.getParent().callDecoration("isGroup"):
+                continue  # Grouped nodes don't need resetting as their parent (the group) is resetted)
+            if not node.callDecoration("isSliceable"):
+                continue  # i.e. node with layer data
+            # Skip nodes that are too big
+            if node.getBoundingBox().width < self._volume.getBoundingBox().width or node.getBoundingBox().depth < self._volume.getBoundingBox().depth:
+                nodes.append(node)
+        job = ArrangeObjectsAllBuildPlatesJob(nodes)
+        job.start()
+        self.getCuraSceneController().setActiveBuildPlate(0)  # Select first build plate
+
+    # Single build plate
+    @pyqtSlot()
+    def arrangeAll(self):
+        nodes = []
+        active_build_plate = self.getBuildPlateModel().activeBuildPlate
+        for node in DepthFirstIterator(self.getController().getScene().getRoot()):
+            if not issubclass(type(node), SceneNode):
                 continue
             if not node.getMeshData() and not node.callDecoration("isGroup"):
                 continue  # Node that doesnt have a mesh and is not a group.
@@ -1079,9 +1142,12 @@ class CuraApplication(QtApplication):
                 continue  # Grouped nodes don't need resetting as their parent (the group) is resetted)
             if not node.isSelectable():
                 continue  # i.e. node with layer data
-            # Skip nodes that are too big
+            if not node.callDecoration("isSliceable"):
-            if node.getBoundingBox().width < self._volume.getBoundingBox().width or node.getBoundingBox().depth < self._volume.getBoundingBox().depth:
+                continue  # i.e. node with layer data
-                nodes.append(node)
+            if node.callDecoration("getBuildPlateNumber") == active_build_plate:
+                # Skip nodes that are too big
+                if node.getBoundingBox().width < self._volume.getBoundingBox().width or node.getBoundingBox().depth < self._volume.getBoundingBox().depth:
+                    nodes.append(node)
         self.arrange(nodes, fixed_nodes = [])
 
     ##  Arrange Selection
@@ -1092,7 +1158,7 @@ class CuraApplication(QtApplication):
         # What nodes are on the build plate and are not being moved
         fixed_nodes = []
         for node in DepthFirstIterator(self.getController().getScene().getRoot()):
-            if type(node) is not SceneNode:
+            if not issubclass(type(node), SceneNode):
                 continue
             if not node.getMeshData() and not node.callDecoration("isGroup"):
                 continue  # Node that doesnt have a mesh and is not a group.
@@ -1100,6 +1166,8 @@ class CuraApplication(QtApplication):
                 continue  # Grouped nodes don't need resetting as their parent (the group) is resetted)
             if not node.isSelectable():
                 continue  # i.e. node with layer data
+            if not node.callDecoration("isSliceable"):
+                continue  # i.e. node with layer data
             if node in nodes:  # exclude selected node from fixed_nodes
                 continue
             fixed_nodes.append(node)
@@ -1118,7 +1186,7 @@ class CuraApplication(QtApplication):
         Logger.log("i", "Reloading all loaded mesh data.")
         nodes = []
         for node in DepthFirstIterator(self.getController().getScene().getRoot()):
-            if type(node) is not SceneNode or not node.getMeshData():
+            if not issubclass(type(node), SceneNode) or not node.getMeshData():
                 continue
 
             nodes.append(node)
@@ -1135,7 +1203,7 @@ class CuraApplication(QtApplication):
                 job.start()
             else:
                 Logger.log("w", "Unable to reload data because we don't have a filename.")
-    
+
     ##  Get logging data of the backend engine
     #   \returns \type{string} Logging data
     @pyqtSlot(result = str)
@@ -1209,10 +1277,11 @@ class CuraApplication(QtApplication):
     @pyqtSlot()
     def groupSelected(self):
         # Create a group-node
-        group_node = SceneNode()
+        group_node = CuraSceneNode()
         group_decorator = GroupDecorator()
         group_node.addDecorator(group_decorator)
         group_node.addDecorator(ConvexHullDecorator())
+        group_node.addDecorator(BuildPlateDecorator(self.getBuildPlateModel().activeBuildPlate))
         group_node.setParent(self.getController().getScene().getRoot())
         group_node.setSelectable(True)
         center = Selection.getSelectionCenter()
@@ -1357,8 +1426,15 @@ class CuraApplication(QtApplication):
         min_offset = 8
 
         self.fileLoaded.emit(filename)
+        arrange_objects_on_load = (
+            not Preferences.getInstance().getValue("cura/use_multi_build_plate") or
+            Preferences.getInstance().getValue("cura/arrange_objects_on_load"))
+        target_build_plate = self.getBuildPlateModel().activeBuildPlate if arrange_objects_on_load else -1
+
+        for original_node in nodes:
+            node = CuraSceneNode()  # We want our own CuraSceneNode
+            node.setMeshData(original_node.getMeshData())
 
-        for node in nodes:
             node.setSelectable(True)
             node.setName(os.path.basename(filename))
 
@@ -1385,21 +1461,23 @@ class CuraApplication(QtApplication):
                 if not child.getDecorator(ConvexHullDecorator):
                     child.addDecorator(ConvexHullDecorator())
 
-            if node.callDecoration("isSliceable"):
+            if arrange_objects_on_load:
-                # Only check position if it's not already blatantly obvious that it won't fit.
+                if node.callDecoration("isSliceable"):
-                if node.getBoundingBox() is None or self._volume.getBoundingBox() is None or node.getBoundingBox().width < self._volume.getBoundingBox().width or node.getBoundingBox().depth < self._volume.getBoundingBox().depth:
+                    # Only check position if it's not already blatantly obvious that it won't fit.
-                    # Find node location
+                    if node.getBoundingBox() is None or self._volume.getBoundingBox() is None or node.getBoundingBox().width < self._volume.getBoundingBox().width or node.getBoundingBox().depth < self._volume.getBoundingBox().depth:
-                    offset_shape_arr, hull_shape_arr = ShapeArray.fromNode(node, min_offset = min_offset)
+                        # Find node location
+                        offset_shape_arr, hull_shape_arr = ShapeArray.fromNode(node, min_offset = min_offset)
 
-                    # If a model is to small then it will not contain any points
+                        # If a model is to small then it will not contain any points
-                    if offset_shape_arr is None and hull_shape_arr is None:
+                        if offset_shape_arr is None and hull_shape_arr is None:
-                        Message(self._i18n_catalog.i18nc("@info:status", "The selected model was too small to load."),
+                            Message(self._i18n_catalog.i18nc("@info:status", "The selected model was too small to load."),
-                                title=self._i18n_catalog.i18nc("@info:title", "Warning")
+                                    title=self._i18n_catalog.i18nc("@info:title", "Warning")).show()
-                                ).show()
+                            return
-                        return
 
-                    # Step is for skipping tests to make it a lot faster. it also makes the outcome somewhat rougher
+                        # Step is for skipping tests to make it a lot faster. it also makes the outcome somewhat rougher
-                    node, _ = arranger.findNodePlacement(node, offset_shape_arr, hull_shape_arr, step = 10)
+                        node, _ = arranger.findNodePlacement(node, offset_shape_arr, hull_shape_arr, step = 10)
+
+            node.addDecorator(BuildPlateDecorator(target_build_plate))
 
             op = AddSceneNodeOperation(node, scene.getRoot())
             op.push()

cura/CuraSceneController.py

@@ -0,0 +1,101 @@
+from UM.Logger import Logger
+
+from PyQt5.QtCore import Qt, pyqtSlot, QObject
+from PyQt5.QtWidgets import QApplication
+
+from cura.ObjectsModel import ObjectsModel
+from cura.BuildPlateModel import BuildPlateModel
+
+from UM.Application import Application
+from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
+from UM.Scene.SceneNode import SceneNode
+from UM.Scene.Selection import Selection
+
+
+class CuraSceneController(QObject):
+    def __init__(self, objects_model: ObjectsModel, build_plate_model: BuildPlateModel):
+        super().__init__()
+
+        self._objects_model = objects_model
+        self._build_plate_model = build_plate_model
+        self._active_build_plate = -1
+
+        self._last_selected_index = 0
+        self._max_build_plate = 1  # default
+
+        Application.getInstance().getController().getScene().sceneChanged.connect(self.updateMaxBuildPlate)  # it may be a bit inefficient when changing a lot simultaneously
+
+    def updateMaxBuildPlate(self, *args):
+        if args:
+            source = args[0]
+        else:
+            source = None
+        if not issubclass(type(source), SceneNode):
+            return
+        max_build_plate = self._calcMaxBuildPlate()
+        changed = False
+        if max_build_plate != self._max_build_plate:
+            self._max_build_plate = max_build_plate
+            changed = True
+        if changed:
+            self._build_plate_model.setMaxBuildPlate(self._max_build_plate)
+            build_plates = [{"name": "Build Plate %d" % (i + 1), "buildPlateNumber": i} for i in range(self._max_build_plate + 1)]
+            self._build_plate_model.setItems(build_plates)
+            # self.buildPlateItemsChanged.emit()  # TODO: necessary after setItems?
+
+    def _calcMaxBuildPlate(self):
+        max_build_plate = 0
+        for node in DepthFirstIterator(Application.getInstance().getController().getScene().getRoot()):
+            if node.callDecoration("isSliceable"):
+                build_plate_number = node.callDecoration("getBuildPlateNumber")
+                max_build_plate = max(build_plate_number, max_build_plate)
+        return max_build_plate
+
+    ##  Either select or deselect an item
+    @pyqtSlot(int)
+    def changeSelection(self, index):
+        modifiers = QApplication.keyboardModifiers()
+        ctrl_is_active = modifiers & Qt.ControlModifier
+        shift_is_active = modifiers & Qt.ShiftModifier
+
+        if ctrl_is_active:
+            item = self._objects_model.getItem(index)
+            node = item["node"]
+            if Selection.isSelected(node):
+                Selection.remove(node)
+            else:
+                Selection.add(node)
+        elif shift_is_active:
+            polarity = 1 if index + 1 > self._last_selected_index else -1
+            for i in range(self._last_selected_index, index + polarity, polarity):
+                item = self._objects_model.getItem(i)
+                node = item["node"]
+                Selection.add(node)
+        else:
+            # Single select
+            item = self._objects_model.getItem(index)
+            node = item["node"]
+            Selection.clear()
+            Selection.add(node)
+            build_plate_number = node.callDecoration("getBuildPlateNumber")
+            if build_plate_number is not None and build_plate_number != -1:
+                self._build_plate_model.setActiveBuildPlate(build_plate_number)
+
+        self._last_selected_index = index
+
+    @pyqtSlot(int)
+    def setActiveBuildPlate(self, nr):
+        if nr == self._active_build_plate:
+            return
+        Logger.log("d", "Select build plate: %s" % nr)
+        self._active_build_plate = nr
+        Selection.clear()
+
+        self._build_plate_model.setActiveBuildPlate(nr)
+        self._objects_model.setActiveBuildPlate(nr)
+
+    @staticmethod
+    def createCuraSceneController():
+        objects_model = Application.getInstance().getObjectsModel()
+        build_plate_model = Application.getInstance().getBuildPlateModel()
+        return CuraSceneController(objects_model = objects_model, build_plate_model = build_plate_model)

cura/MultiplyObjectsJob.py

@@ -2,24 +2,15 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from UM.Job import Job
-from UM.Scene.SceneNode import SceneNode
-from UM.Math.Vector import Vector
-from UM.Operations.SetTransformOperation import SetTransformOperation
-from UM.Operations.TranslateOperation import TranslateOperation
 from UM.Operations.GroupedOperation import GroupedOperation
-from UM.Logger import Logger
 from UM.Message import Message
 from UM.i18n import i18nCatalog
 i18n_catalog = i18nCatalog("cura")
 
-from cura.ZOffsetDecorator import ZOffsetDecorator
+from cura.Arranging.Arrange import Arrange
-from cura.Arrange import Arrange
+from cura.Arranging.ShapeArray import ShapeArray
-from cura.ShapeArray import ShapeArray
-
-from typing import List
 
 from UM.Application import Application
-from UM.Scene.Selection import Selection
 from UM.Operations.AddSceneNodeOperation import AddSceneNodeOperation
 
 
@@ -65,6 +56,10 @@ class MultiplyObjectsJob(Job):
                     new_location = new_location.set(z = 100 - i * 20)
                     node.setPosition(new_location)
 
+                # Same build plate
+                build_plate_number = current_node.callDecoration("getBuildPlateNumber")
+                node.callDecoration("setBuildPlateNumber", build_plate_number)
+
                 nodes.append(node)
                 current_progress += 1
                 status_message.setProgress((current_progress / total_progress) * 100)

cura/ObjectsModel.py

@@ -0,0 +1,49 @@
+from UM.Application import Application
+from UM.Qt.ListModel import ListModel
+from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
+from UM.Scene.SceneNode import SceneNode
+from UM.Scene.Selection import Selection
+from UM.Preferences import Preferences
+
+
+##  Keep track of all objects in the project
+class ObjectsModel(ListModel):
+    def __init__(self):
+        super().__init__()
+
+        Application.getInstance().getController().getScene().sceneChanged.connect(self._update)
+        Preferences.getInstance().preferenceChanged.connect(self._update)
+
+        self._build_plate_number = -1
+
+    def setActiveBuildPlate(self, nr):
+        self._build_plate_number = nr
+        self._update()
+
+    def _update(self, *args):
+        nodes = []
+        filter_current_build_plate = Preferences.getInstance().getValue("view/filter_current_build_plate")
+        active_build_plate_number = self._build_plate_number
+        for node in DepthFirstIterator(Application.getInstance().getController().getScene().getRoot()):
+            if not issubclass(type(node), SceneNode) or (not node.getMeshData() and not node.callDecoration("getLayerData")):
+                continue
+            if not node.callDecoration("isSliceable"):
+                continue
+            node_build_plate_number = node.callDecoration("getBuildPlateNumber")
+            if filter_current_build_plate and node_build_plate_number != active_build_plate_number:
+                continue
+            nodes.append({
+                "name": node.getName(),
+                "isSelected": Selection.isSelected(node),
+                "isOutsideBuildArea": node.isOutsideBuildArea(),
+                "buildPlateNumber": node_build_plate_number,
+                "node": node
+            })
+        nodes = sorted(nodes, key=lambda n: n["name"])
+        self.setItems(nodes)
+
+        self.itemsChanged.emit()
+
+    @staticmethod
+    def createObjectsModel():
+        return ObjectsModel()

cura/Operations/SetBuildPlateNumberOperation.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2017 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from UM.Scene.SceneNode import SceneNode
+from UM.Operations.Operation import Operation
+
+from cura.Settings.SettingOverrideDecorator import SettingOverrideDecorator
+
+##  Simple operation to set the buildplate number of a scenenode.
+class SetBuildPlateNumberOperation(Operation):
+    def __init__(self, node: SceneNode, build_plate_nr: int) -> None:
+        self._node = node
+        self._build_plate_nr = build_plate_nr
+        self._previous_build_plate_nr = None
+        self._decorator_added = False
+
+    def undo(self):
+        if self._previous_build_plate_nr:
+            self._node.callDecoration("setBuildPlateNumber", self._previous_build_plate_nr)
+
+    def redo(self):
+        stack = self._node.callDecoration("getStack") #Don't try to get the active extruder since it may be None anyway.
+        if not stack:
+            self._node.addDecorator(SettingOverrideDecorator())
+
+        self._previous_build_plate_nr = self._node.callDecoration("getBuildPlateNumber")
+        self._node.callDecoration("setBuildPlateNumber", self._build_plate_nr)

cura/PlatformPhysics.py

@@ -10,10 +10,10 @@ from UM.Math.Vector import Vector
 from UM.Scene.Selection import Selection
 from UM.Preferences import Preferences
 
-from cura.ConvexHullDecorator import ConvexHullDecorator
+from cura.Scene.ConvexHullDecorator import ConvexHullDecorator
 
-from . import PlatformPhysicsOperation
+from cura.Operations import PlatformPhysicsOperation
-from . import ZOffsetDecorator
+from cura.Scene import ZOffsetDecorator
 
 import random  # used for list shuffling
 
@@ -58,10 +58,11 @@ class PlatformPhysics:
 
         # Only check nodes inside build area.
         nodes = [node for node in nodes if (hasattr(node, "_outside_buildarea") and not node._outside_buildarea)]
+        active_build_plate = Application.getInstance().getBuildPlateModel().activeBuildPlate
 
         random.shuffle(nodes)
         for node in nodes:
-            if node is root or type(node) is not SceneNode or node.getBoundingBox() is None:
+            if node is root or not issubclass(type(node), SceneNode) or node.getBoundingBox() is None:
                 continue
 
             bbox = node.getBoundingBox()
@@ -82,7 +83,7 @@ class PlatformPhysics:
                 # Check for collisions between convex hulls
                 for other_node in BreadthFirstIterator(root):
                     # Ignore root, ourselves and anything that is not a normal SceneNode.
-                    if other_node is root or type(other_node) is not SceneNode or other_node is node:
+                    if other_node is root or not issubclass(type(other_node), SceneNode) or other_node is node or other_node.callDecoration("getBuildPlateNumber") != node.callDecoration("getBuildPlateNumber"):
                         continue
                     
                     # Ignore collisions of a group with it's own children

cura/PrintInformation.py

@@ -54,10 +54,10 @@ class PrintInformation(QObject):
 
         self.initializeCuraMessagePrintTimeProperties()
 
-        self._material_lengths = []
+        self._material_lengths = {}  # indexed by build plate number
-        self._material_weights = []
+        self._material_weights = {}
-        self._material_costs = []
+        self._material_costs = {}
-        self._material_names = []
+        self._material_names = {}
 
         self._pre_sliced = False
 
@@ -68,10 +68,15 @@ class PrintInformation(QObject):
         self._base_name = ""
         self._abbr_machine = ""
         self._job_name = ""
+        self._project_name = ""
+        self._active_build_plate = 0
+        self._initVariablesWithBuildPlate(self._active_build_plate)
 
         Application.getInstance().globalContainerStackChanged.connect(self._updateJobName)
         Application.getInstance().fileLoaded.connect(self.setBaseName)
+        Application.getInstance().getBuildPlateModel().activeBuildPlateChanged.connect(self._onActiveBuildPlateChanged)
         Application.getInstance().workspaceLoaded.connect(self.setProjectName)
+
         Preferences.getInstance().preferenceChanged.connect(self._onPreferencesChanged)
 
         self._active_material_container = None
@@ -83,7 +88,7 @@ class PrintInformation(QObject):
     # Crate cura message translations and using translation keys initialize empty time Duration object for total time
     # and time for each feature
     def initializeCuraMessagePrintTimeProperties(self):
-        self._current_print_time = Duration(None, self)
+        self._current_print_time = {}  # Duration(None, self)
 
         self._print_time_message_translations = {
             "inset_0": catalog.i18nc("@tooltip", "Outer Wall"),
@@ -101,10 +106,26 @@ class PrintInformation(QObject):
 
         self._print_time_message_values = {}
 
-        # Full fill message values using keys from _print_time_message_translations
-        for key in self._print_time_message_translations.keys():
-            self._print_time_message_values[key] = Duration(None, self)
 
+    def _initPrintTimeMessageValues(self, build_plate_number):
+        # Full fill message values using keys from _print_time_message_translations
+        self._print_time_message_values[build_plate_number] = {}
+        for key in self._print_time_message_translations.keys():
+            self._print_time_message_values[build_plate_number][key] = Duration(None, self)
+
+    def _initVariablesWithBuildPlate(self, build_plate_number):
+        if build_plate_number not in self._print_time_message_values:
+            self._initPrintTimeMessageValues(build_plate_number)
+        if self._active_build_plate not in self._material_lengths:
+            self._material_lengths[self._active_build_plate] = []
+        if self._active_build_plate not in self._material_weights:
+            self._material_weights[self._active_build_plate] = []
+        if self._active_build_plate not in self._material_costs:
+            self._material_costs[self._active_build_plate] = []
+        if self._active_build_plate not in self._material_names:
+            self._material_names[self._active_build_plate] = []
+        if self._active_build_plate not in self._current_print_time:
+            self._current_print_time[self._active_build_plate] = Duration(None, self)
 
     currentPrintTimeChanged = pyqtSignal()
 
@@ -120,64 +141,71 @@ class PrintInformation(QObject):
 
     @pyqtProperty(Duration, notify = currentPrintTimeChanged)
     def currentPrintTime(self):
-        return self._current_print_time
+        return self._current_print_time[self._active_build_plate]
 
     materialLengthsChanged = pyqtSignal()
 
     @pyqtProperty("QVariantList", notify = materialLengthsChanged)
     def materialLengths(self):
-        return self._material_lengths
+        return self._material_lengths[self._active_build_plate]
 
     materialWeightsChanged = pyqtSignal()
 
     @pyqtProperty("QVariantList", notify = materialWeightsChanged)
     def materialWeights(self):
-        return self._material_weights
+        return self._material_weights[self._active_build_plate]
 
     materialCostsChanged = pyqtSignal()
 
     @pyqtProperty("QVariantList", notify = materialCostsChanged)
     def materialCosts(self):
-        return self._material_costs
+        return self._material_costs[self._active_build_plate]
 
     materialNamesChanged = pyqtSignal()
 
     @pyqtProperty("QVariantList", notify = materialNamesChanged)
     def materialNames(self):
-        return self._material_names
+        return self._material_names[self._active_build_plate]
 
-    def _onPrintDurationMessage(self, print_time, material_amounts):
+    def printTimes(self):
+        return self._print_time_message_values[self._active_build_plate]
 
-        self._updateTotalPrintTimePerFeature(print_time)
+    def _onPrintDurationMessage(self, build_plate_number, print_time, material_amounts):
+        self._updateTotalPrintTimePerFeature(build_plate_number, print_time)
         self.currentPrintTimeChanged.emit()
 
         self._material_amounts = material_amounts
-        self._calculateInformation()
+        self._calculateInformation(build_plate_number)
 
-    def _updateTotalPrintTimePerFeature(self, print_time):
+    def _updateTotalPrintTimePerFeature(self, build_plate_number, print_time):
         total_estimated_time = 0
 
+        if build_plate_number not in self._print_time_message_values:
+            self._initPrintTimeMessageValues(build_plate_number)
+
         for feature, time in print_time.items():
             if time != time:  # Check for NaN. Engine can sometimes give us weird values.
-                self._print_time_message_values.get(feature).setDuration(0)
+                self._print_time_message_values[build_plate_number].get(feature).setDuration(0)
                 Logger.log("w", "Received NaN for print duration message")
                 continue
 
             total_estimated_time += time
-            self._print_time_message_values.get(feature).setDuration(time)
+            self._print_time_message_values[build_plate_number].get(feature).setDuration(time)
 
-        self._current_print_time.setDuration(total_estimated_time)
+        if build_plate_number not in self._current_print_time:
+            self._current_print_time[build_plate_number] = Duration(None, self)
+        self._current_print_time[build_plate_number].setDuration(total_estimated_time)
 
-    def _calculateInformation(self):
+    def _calculateInformation(self, build_plate_number):
         if Application.getInstance().getGlobalContainerStack() is None:
             return
 
         # Material amount is sent as an amount of mm^3, so calculate length from that
         radius = Application.getInstance().getGlobalContainerStack().getProperty("material_diameter", "value") / 2
-        self._material_lengths = []
+        self._material_lengths[build_plate_number] = []
-        self._material_weights = []
+        self._material_weights[build_plate_number] = []
-        self._material_costs = []
+        self._material_costs[build_plate_number] = []
-        self._material_names = []
+        self._material_names[build_plate_number] = []
 
         material_preference_values = json.loads(Preferences.getInstance().getValue("cura/material_settings"))
 
@@ -215,10 +243,10 @@ class PrintInformation(QObject):
                 length = round((amount / (math.pi * radius ** 2)) / 1000, 2)
             else:
                 length = 0
-            self._material_weights.append(weight)
+            self._material_weights[build_plate_number].append(weight)
-            self._material_lengths.append(length)
+            self._material_lengths[build_plate_number].append(length)
-            self._material_costs.append(cost)
+            self._material_costs[build_plate_number].append(cost)
-            self._material_names.append(material_name)
+            self._material_names[build_plate_number].append(material_name)
 
         self.materialLengthsChanged.emit()
         self.materialWeightsChanged.emit()
@@ -229,7 +257,8 @@ class PrintInformation(QObject):
         if preference != "cura/material_settings":
             return
 
-        self._calculateInformation()
+        for build_plate_number in range(Application.getInstance().getBuildPlateModel().maxBuildPlate + 1):
+            self._calculateInformation(build_plate_number)
 
     def _onActiveMaterialChanged(self):
         if self._active_material_container:
@@ -245,8 +274,22 @@ class PrintInformation(QObject):
             self._active_material_container = active_material_containers[0]
             self._active_material_container.metaDataChanged.connect(self._onMaterialMetaDataChanged)
 
+    def _onActiveBuildPlateChanged(self):
+        new_active_build_plate = Application.getInstance().getBuildPlateModel().activeBuildPlate
+        if new_active_build_plate != self._active_build_plate:
+            self._active_build_plate = new_active_build_plate
+
+            self._initVariablesWithBuildPlate(self._active_build_plate)
+
+            self.materialLengthsChanged.emit()
+            self.materialWeightsChanged.emit()
+            self.materialCostsChanged.emit()
+            self.materialNamesChanged.emit()
+            self.currentPrintTimeChanged.emit()
+
     def _onMaterialMetaDataChanged(self, *args, **kwargs):
-        self._calculateInformation()
+        for build_plate_number in range(Application.getInstance().getBuildPlateModel().maxBuildPlate + 1):
+            self._calculateInformation(build_plate_number)
 
     @pyqtSlot(str)
     def setJobName(self, name):
@@ -340,7 +383,9 @@ class PrintInformation(QObject):
     @pyqtSlot(result = "QVariantMap")
     def getFeaturePrintTimes(self):
         result = {}
-        for feature, time in self._print_time_message_values.items():
+        if self._active_build_plate not in self._print_time_message_values:
+            self._initPrintTimeMessageValues(self._active_build_plate)
+        for feature, time in self._print_time_message_values[self._active_build_plate].items():
             if feature in self._print_time_message_translations:
                 result[self._print_time_message_translations[feature]] = time
             else:
@@ -348,10 +393,12 @@ class PrintInformation(QObject):
         return result
 
     # Simulate message with zero time duration
-    def setToZeroPrintInformation(self):
+    def setToZeroPrintInformation(self, build_plate_number):
         temp_message = {}
-        for key in self._print_time_message_values.keys():
+        if build_plate_number not in self._print_time_message_values:
+            self._print_time_message_values[build_plate_number] = {}
+        for key in self._print_time_message_values[build_plate_number].keys():
             temp_message[key] = 0
 
         temp_material_amounts = [0]
-        self._onPrintDurationMessage(temp_message, temp_material_amounts)
+        self._onPrintDurationMessage(build_plate_number, temp_message, temp_material_amounts)

cura/Scene/BuildPlateDecorator.py

@@ -0,0 +1,26 @@
+from UM.Scene.SceneNodeDecorator import SceneNodeDecorator
+from cura.Scene.CuraSceneNode import CuraSceneNode
+
+
+##  Make a SceneNode build plate aware CuraSceneNode objects all have this decorator.
+class BuildPlateDecorator(SceneNodeDecorator):
+    def __init__(self, build_plate_number = -1):
+        super().__init__()
+        self._build_plate_number = None
+        self.setBuildPlateNumber(build_plate_number)
+
+    def setBuildPlateNumber(self, nr):
+        # Make sure that groups are set correctly
+        # setBuildPlateForSelection in CuraActions makes sure that no single childs are set.
+        self._build_plate_number = nr
+        if issubclass(type(self._node), CuraSceneNode):
+            self._node.transformChanged()  # trigger refresh node without introducing a new signal
+        if self._node and self._node.callDecoration("isGroup"):
+            for child in self._node.getChildren():
+                child.callDecoration("setBuildPlateNumber", nr)
+
+    def getBuildPlateNumber(self):
+        return self._build_plate_number
+
+    def __deepcopy__(self, memo):
+        return BuildPlateDecorator()

cura/Scene/ConvexHullDecorator.py

@@ -7,7 +7,7 @@ from UM.Scene.SceneNodeDecorator import SceneNodeDecorator
 from UM.Settings.ContainerRegistry import ContainerRegistry
 
 from cura.Settings.ExtruderManager import ExtruderManager
-from . import ConvexHullNode
+from cura.Scene import ConvexHullNode
 
 import numpy
 

cura/Scene/ConvexHullNode.py

@@ -6,7 +6,6 @@ from UM.Scene.SceneNode import SceneNode
 from UM.Resources import Resources
 from UM.Math.Color import Color
 from UM.Mesh.MeshBuilder import MeshBuilder  # To create a mesh to display the convex hull with.
-
 from UM.View.GL.OpenGL import OpenGL
 
 
@@ -66,7 +65,7 @@ class ConvexHullNode(SceneNode):
             ConvexHullNode.shader.setUniformValue("u_opacity", 0.6)
 
         if self.getParent():
-            if self.getMeshData():
+            if self.getMeshData() and issubclass(type(self._node), SceneNode) and self._node.callDecoration("getBuildPlateNumber") == Application.getInstance().getBuildPlateModel().activeBuildPlate:
                 renderer.queueNode(self, transparent = True, shader = ConvexHullNode.shader, backface_cull = True, sort = -8)
                 if self._convex_hull_head_mesh:
                     renderer.queueNode(self, shader = ConvexHullNode.shader, transparent = True, mesh = self._convex_hull_head_mesh, backface_cull = True, sort = -8)

cura/Scene/CuraSceneNode.py

@@ -0,0 +1,43 @@
+from UM.Application import Application
+from UM.Logger import Logger
+from UM.Scene.SceneNode import SceneNode
+from copy import deepcopy
+
+
+##  Scene nodes that are models are only seen when selecting the corresponding build plate
+#   Note that many other nodes can just be UM SceneNode objects.
+class CuraSceneNode(SceneNode):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._outside_buildarea = True
+
+    def setOutsideBuildArea(self, new_value):
+        self._outside_buildarea = new_value
+
+    def isOutsideBuildArea(self):
+        return self._outside_buildarea or self.callDecoration("getBuildPlateNumber") < 0
+
+    def isVisible(self):
+        return super().isVisible() and self.callDecoration("getBuildPlateNumber") == Application.getInstance().getBuildPlateModel().activeBuildPlate
+
+    def isSelectable(self) -> bool:
+        return super().isSelectable() and self.callDecoration("getBuildPlateNumber") == Application.getInstance().getBuildPlateModel().activeBuildPlate
+
+    ##  Taken from SceneNode, but replaced SceneNode with CuraSceneNode
+    def __deepcopy__(self, memo):
+        copy = CuraSceneNode()
+        copy.setTransformation(self.getLocalTransformation())
+        copy.setMeshData(self._mesh_data)
+        copy.setVisible(deepcopy(self._visible, memo))
+        copy._selectable = deepcopy(self._selectable, memo)
+        copy._name = deepcopy(self._name, memo)
+        for decorator in self._decorators:
+            copy.addDecorator(deepcopy(decorator, memo))
+
+        for child in self._children:
+            copy.addChild(deepcopy(child, memo))
+        self.calculateBoundingBoxMesh()
+        return copy
+
+    def transformChanged(self) -> None:
+        self._transformChanged()

plugins/3MFReader/ThreeMFReader.py

@@ -4,7 +4,6 @@
 import os.path
 import zipfile
 
-from UM.Job import Job
 from UM.Logger import Logger
 from UM.Math.Matrix import Matrix
 from UM.Math.Vector import Vector
@@ -15,9 +14,10 @@ from cura.Settings.SettingOverrideDecorator import SettingOverrideDecorator
 from UM.Application import Application
 from cura.Settings.ExtruderManager import ExtruderManager
 from cura.QualityManager import QualityManager
-from UM.Scene.SceneNode import SceneNode
+from cura.Scene.CuraSceneNode import CuraSceneNode
-from cura.SliceableObjectDecorator import SliceableObjectDecorator
+from cura.Scene.BuildPlateDecorator import BuildPlateDecorator
-from cura.ZOffsetDecorator import ZOffsetDecorator
+from cura.Scene.SliceableObjectDecorator import SliceableObjectDecorator
+from cura.Scene.ZOffsetDecorator import ZOffsetDecorator
 
 MYPY = False
 
@@ -43,6 +43,7 @@ class ThreeMFReader(MeshReader):
         }
         self._base_name = ""
         self._unit = None
+        self._object_count = 0  # Used to name objects as there is no node name yet.
 
     def _createMatrixFromTransformationString(self, transformation):
         if transformation == "":
@@ -77,7 +78,12 @@ class ThreeMFReader(MeshReader):
     ##  Convenience function that converts a SceneNode object (as obtained from libSavitar) to a Uranium scene node.
     #   \returns Uranium scene node.
     def _convertSavitarNodeToUMNode(self, savitar_node):
-        um_node = SceneNode()
+        self._object_count += 1
+        node_name = "Object %s" % self._object_count
+
+        um_node = CuraSceneNode()
+        um_node.addDecorator(BuildPlateDecorator(0))
+        um_node.setName(node_name)
         transformation = self._createMatrixFromTransformationString(savitar_node.getTransformation())
         um_node.setTransformation(transformation)
         mesh_builder = MeshBuilder()
@@ -147,6 +153,7 @@ class ThreeMFReader(MeshReader):
 
     def read(self, file_name):
         result = []
+        self._object_count = 0  # Used to name objects as there is no node name yet.
         # The base object of 3mf is a zipped archive.
         try:
             archive = zipfile.ZipFile(file_name, "r")

plugins/3MFWriter/ThreeMFWriter.py

@@ -7,6 +7,7 @@ from UM.Logger import Logger
 from UM.Math.Matrix import Matrix
 from UM.Application import Application
 import UM.Scene.SceneNode
+from cura.Scene.CuraSceneNode import CuraSceneNode
 
 import Savitar
 
@@ -63,7 +64,7 @@ class ThreeMFWriter(MeshWriter):
     ##  Convenience function that converts an Uranium SceneNode object to a SavitarSceneNode
     #   \returns Uranium Scenen node.
     def _convertUMNodeToSavitarNode(self, um_node, transformation = Matrix()):
-        if type(um_node) is not UM.Scene.SceneNode.SceneNode:
+        if type(um_node) not in [UM.Scene.SceneNode.SceneNode, CuraSceneNode]:
             return None
 
         savitar_node = Savitar.SceneNode()

plugins/CuraEngineBackend/CuraEngineBackend.py

@@ -16,6 +16,7 @@ from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
 from UM.Qt.Duration import DurationFormat
 from PyQt5.QtCore import QObject, pyqtSlot
 
+from collections import defaultdict
 from cura.Settings.ExtruderManager import ExtruderManager
 from . import ProcessSlicedLayersJob
 from . import StartSliceJob
@@ -69,9 +70,10 @@ class CuraEngineBackend(QObject, Backend):
         # Workaround to disable layer view processing if layer view is not active.
         self._layer_view_active = False
         Application.getInstance().getController().activeViewChanged.connect(self._onActiveViewChanged)
+        Application.getInstance().getBuildPlateModel().activeBuildPlateChanged.connect(self._onActiveViewChanged)
         self._onActiveViewChanged()
         self._stored_layer_data = []
-        self._stored_optimized_layer_data = []
+        self._stored_optimized_layer_data = {}  # key is build plate number, then arrays are stored until they go to the ProcessSlicesLayersJob
 
         self._scene = Application.getInstance().getController().getScene()
         self._scene.sceneChanged.connect(self._onSceneChanged)
@@ -105,17 +107,18 @@ class CuraEngineBackend(QObject, Backend):
         self._message_handlers["cura.proto.SlicingFinished"] = self._onSlicingFinishedMessage
 
         self._start_slice_job = None
+        self._start_slice_job_build_plate = None
         self._slicing = False  # Are we currently slicing?
         self._restart = False  # Back-end is currently restarting?
         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._process_layers_job = None  # The currently active job to process layers, or None if it is not processing layers.
-        self._need_slicing = False
+        self._build_plates_to_be_sliced = []  # what needs slicing?
         self._engine_is_fresh = True  # Is the newly started engine used before or not?
 
         self._backend_log_max_lines = 20000  # Maximum number of lines to buffer
         self._error_message = None  # Pop-up message that shows errors.
-        self._last_num_objects = 0  # Count number of objects to see if there is something changed
+        self._last_num_objects = defaultdict(int)  # Count number of objects to see if there is something changed
         self._postponed_scene_change_sources = []  # scene change is postponed (by a tool)
 
         self.backendQuit.connect(self._onBackendQuit)
@@ -174,6 +177,7 @@ class CuraEngineBackend(QObject, Backend):
             self._createSocket()
 
         if self._process_layers_job:  # We were processing layers. Stop that, the layers are going to change soon.
+            Logger.log("d", "Aborting process layers job...")
             self._process_layers_job.abort()
             self._process_layers_job = None
 
@@ -190,17 +194,34 @@ class CuraEngineBackend(QObject, Backend):
 
     ##  Perform a slice of the scene.
     def slice(self):
+        Logger.log("d", "starting to slice!")
         self._slice_start_time = time()
-        if not self._need_slicing:
+        if not self._build_plates_to_be_sliced:
             self.processingProgress.emit(1.0)
             self.backendStateChange.emit(BackendState.Done)
             Logger.log("w", "Slice unnecessary, nothing has changed that needs reslicing.")
             return
-        if Application.getInstance().getPrintInformation():
+
-            Application.getInstance().getPrintInformation().setToZeroPrintInformation()
+        if self._process_layers_job:
+            Logger.log("d", "  ## Process layers job still busy, trying later")
+            self._invokeSlice()
+            return
+
+        # see if we really have to slice
+        active_build_plate = Application.getInstance().getBuildPlateModel().activeBuildPlate
+        build_plate_to_be_sliced = self._build_plates_to_be_sliced.pop(0)
+        Logger.log("d", "Going to slice build plate [%s]!" % build_plate_to_be_sliced)
+        num_objects = self._numObjects()
+        if build_plate_to_be_sliced not in num_objects or num_objects[build_plate_to_be_sliced] == 0:
+            Logger.log("d", "Build plate %s has 0 objects to be sliced, skipping", build_plate_to_be_sliced)
+            self._invokeSlice()
+            return
 
         self._stored_layer_data = []
-        self._stored_optimized_layer_data = []
+        self._stored_optimized_layer_data[build_plate_to_be_sliced] = []
+
+        if Application.getInstance().getPrintInformation() and build_plate_to_be_sliced == active_build_plate:
+            Application.getInstance().getPrintInformation().setToZeroPrintInformation(build_plate_to_be_sliced)
 
         if self._process is None:
             self._createSocket()
@@ -210,12 +231,16 @@ class CuraEngineBackend(QObject, Backend):
         self.processingProgress.emit(0.0)
         self.backendStateChange.emit(BackendState.NotStarted)
 
-        self._scene.gcode_list = []
+        if not hasattr(self._scene, "gcode_list"):
+            self._scene.gcode_list = {}
+        self._scene.gcode_list[build_plate_to_be_sliced] = []  #[] indexed by build plate number
         self._slicing = True
         self.slicingStarted.emit()
 
         slice_message = self._socket.createMessage("cura.proto.Slice")
         self._start_slice_job = StartSliceJob.StartSliceJob(slice_message)
+        self._start_slice_job_build_plate = build_plate_to_be_sliced
+        self._start_slice_job.setBuildPlate(self._start_slice_job_build_plate)
         self._start_slice_job.start()
         self._start_slice_job.finished.connect(self._onStartSliceCompleted)
 
@@ -224,7 +249,8 @@ class CuraEngineBackend(QObject, Backend):
     def _terminate(self):
         self._slicing = False
         self._stored_layer_data = []
-        self._stored_optimized_layer_data = []
+        if self._start_slice_job_build_plate in self._stored_optimized_layer_data:
+            del self._stored_optimized_layer_data[self._start_slice_job_build_plate]
         if self._start_slice_job is not None:
             self._start_slice_job.cancel()
 
@@ -331,15 +357,6 @@ class CuraEngineBackend(QObject, Backend):
             else:
                 self.backendStateChange.emit(BackendState.NotStarted)
 
-        if job.getResult() == StartSliceJob.StartJobResult.NothingToSlice:
-            if Application.getInstance().platformActivity:
-                self._error_message = Message(catalog.i18nc("@info:status", "Nothing to slice because none of the models fit the build volume. Please scale or rotate models to fit."),
-                                              title = catalog.i18nc("@info:title", "Unable to slice"))
-                self._error_message.show()
-                self.backendStateChange.emit(BackendState.Error)
-            else:
-                self.backendStateChange.emit(BackendState.NotStarted)
-            return
         # Preparation completed, send it to the backend.
         self._socket.sendMessage(job.getSliceMessage())
 
@@ -363,7 +380,7 @@ class CuraEngineBackend(QObject, Backend):
                 self.backendStateChange.emit(BackendState.Disabled)
             gcode_list = node.callDecoration("getGCodeList")
             if gcode_list is not None:
-                self._scene.gcode_list = gcode_list
+                self._scene.gcode_list[node.callDecoration("getBuildPlateNumber")] = gcode_list
 
         if self._use_timer == enable_timer:
             return self._use_timer
@@ -375,33 +392,48 @@ class CuraEngineBackend(QObject, Backend):
             self.disableTimer()
             return False
 
+    ##  Return a dict with number of objects per build plate
+    def _numObjects(self):
+        num_objects = defaultdict(int)
+        for node in DepthFirstIterator(self._scene.getRoot()):
+            # Only count sliceable objects
+            if node.callDecoration("isSliceable"):
+                build_plate_number = node.callDecoration("getBuildPlateNumber")
+                num_objects[build_plate_number] += 1
+        return num_objects
+
     ##  Listener for when the scene has changed.
     #
     #   This should start a slice if the scene is now ready to slice.
     #
     #   \param source The scene node that was changed.
     def _onSceneChanged(self, source):
-        if type(source) is not SceneNode:
+        if not issubclass(type(source), SceneNode):
             return
 
-        root_scene_nodes_changed = False
+        build_plate_changed = set()
+        source_build_plate_number = source.callDecoration("getBuildPlateNumber")
         if source == self._scene.getRoot():
-            num_objects = 0
+            # we got the root node
-            for node in DepthFirstIterator(self._scene.getRoot()):
+            num_objects = self._numObjects()
-                # Only count sliceable objects
+            for build_plate_number in list(self._last_num_objects.keys()) + list(num_objects.keys()):
-                if node.callDecoration("isSliceable"):
+                if build_plate_number not in self._last_num_objects or num_objects[build_plate_number] != self._last_num_objects[build_plate_number]:
-                    num_objects += 1
+                    self._last_num_objects[build_plate_number] = num_objects[build_plate_number]
-            if num_objects != self._last_num_objects:
+                    build_plate_changed.add(build_plate_number)
-                self._last_num_objects = num_objects
+        else:
-                root_scene_nodes_changed = True
+            # we got a single scenenode
-            else:
+            if not source.callDecoration("isGroup"):
-                return
+                if source.getMeshData() is None:
+                    return
+                if source.getMeshData().getVertices() is None:
+                    return
 
-        if not source.callDecoration("isGroup") and not root_scene_nodes_changed:
+            build_plate_changed.add(source_build_plate_number)
-            if source.getMeshData() is None:
+
-                return
+        build_plate_changed.discard(None)
-            if source.getMeshData().getVertices() is None:
+        build_plate_changed.discard(-1)  # object not on build plate
-                return
+        if not build_plate_changed:
+            return
 
         if self._tool_active:
             # do it later, each source only has to be done once
@@ -409,9 +441,17 @@ class CuraEngineBackend(QObject, Backend):
                 self._postponed_scene_change_sources.append(source)
             return
 
-        self.needsSlicing()
         self.stopSlicing()
-        self._onChanged()
+        for build_plate_number in build_plate_changed:
+            if build_plate_number not in self._build_plates_to_be_sliced:
+                self._build_plates_to_be_sliced.append(build_plate_number)
+        self.processingProgress.emit(0.0)
+        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(build_plate_changed)
+
+        self._invokeSlice()
 
     ##  Called when an error occurs in the socket connection towards the engine.
     #
@@ -431,16 +471,21 @@ class CuraEngineBackend(QObject, Backend):
             Logger.log("w", "A socket error caused the connection to be reset")
 
     ##  Remove old layer data (if any)
-    def _clearLayerData(self):
+    def _clearLayerData(self, build_plate_numbers = set()):
         for node in DepthFirstIterator(self._scene.getRoot()):
             if node.callDecoration("getLayerData"):
-                node.getParent().removeChild(node)
+                if not build_plate_numbers or node.callDecoration("getBuildPlateNumber") in build_plate_numbers:
-                break
+                    node.getParent().removeChild(node)
 
-    ##  Convenient function: set need_slicing, emit state and clear layer data
+    def markSliceAll(self):
+        for build_plate_number in range(Application.getInstance().getBuildPlateModel().maxBuildPlate + 1):
+            if build_plate_number not in self._build_plates_to_be_sliced:
+                self._build_plates_to_be_sliced.append(build_plate_number)
+
+    ##  Convenient function: mark everything to slice, emit state and clear layer data
     def needsSlicing(self):
         self.stopSlicing()
-        self._need_slicing = True
+        self.markSliceAll()
         self.processingProgress.emit(0.0)
         self.backendStateChange.emit(BackendState.NotStarted)
         if not self._use_timer:
@@ -462,7 +507,7 @@ class CuraEngineBackend(QObject, Backend):
 
     def _onStackErrorCheckFinished(self):
         self._is_error_check_scheduled = False
-        if not self._slicing and self._need_slicing:
+        if not self._slicing and self._build_plates_to_be_sliced:  #self._need_slicing:
             self.needsSlicing()
             self._onChanged()
 
@@ -476,7 +521,7 @@ class CuraEngineBackend(QObject, Backend):
     #
     #   \param message The protobuf message containing sliced layer data.
     def _onOptimizedLayerMessage(self, message):
-        self._stored_optimized_layer_data.append(message)
+        self._stored_optimized_layer_data[self._start_slice_job_build_plate].append(message)
 
     ##  Called when a progress message is received from the engine.
     #
@@ -485,6 +530,16 @@ class CuraEngineBackend(QObject, Backend):
         self.processingProgress.emit(message.amount)
         self.backendStateChange.emit(BackendState.Processing)
 
+    # testing
+    def _invokeSlice(self):
+        if self._use_timer:
+            # if the error check is scheduled, wait for the error check finish signal to trigger auto-slice,
+            # otherwise business as usual
+            if self._is_error_check_scheduled:
+                self._change_timer.stop()
+            else:
+                self._change_timer.start()
+
     ##  Called when the engine sends a message that slicing is finished.
     #
     #   \param message The protobuf message signalling that slicing is finished.
@@ -492,36 +547,44 @@ class CuraEngineBackend(QObject, Backend):
         self.backendStateChange.emit(BackendState.Done)
         self.processingProgress.emit(1.0)
 
-        for line in self._scene.gcode_list:
+        gcode_list = self._scene.gcode_list[self._start_slice_job_build_plate]
+        for index, line in enumerate(gcode_list):
             replaced = line.replace("{print_time}", str(Application.getInstance().getPrintInformation().currentPrintTime.getDisplayString(DurationFormat.Format.ISO8601)))
             replaced = replaced.replace("{filament_amount}", str(Application.getInstance().getPrintInformation().materialLengths))
             replaced = replaced.replace("{filament_weight}", str(Application.getInstance().getPrintInformation().materialWeights))
             replaced = replaced.replace("{filament_cost}", str(Application.getInstance().getPrintInformation().materialCosts))
             replaced = replaced.replace("{jobname}", str(Application.getInstance().getPrintInformation().jobName))
 
-            self._scene.gcode_list[self._scene.gcode_list.index(line)] = replaced
+            gcode_list[index] = replaced
 
         self._slicing = False
-        self._need_slicing = False
         Logger.log("d", "Slicing took %s seconds", time() - self._slice_start_time )
-        if self._layer_view_active and (self._process_layers_job is None or not self._process_layers_job.isRunning()):
+
-            self._process_layers_job = ProcessSlicedLayersJob.ProcessSlicedLayersJob(self._stored_optimized_layer_data)
+        # See if we need to process the sliced layers job.
-            self._process_layers_job.finished.connect(self._onProcessLayersFinished)
+        active_build_plate = Application.getInstance().getBuildPlateModel().activeBuildPlate
-            self._process_layers_job.start()
+        if self._layer_view_active and (self._process_layers_job is None or not self._process_layers_job.isRunning()) and active_build_plate == self._start_slice_job_build_plate:
-            self._stored_optimized_layer_data = []
+            self._startProcessSlicedLayersJob(active_build_plate)
+        # self._onActiveViewChanged()
+        self._start_slice_job_build_plate = None
+
+        Logger.log("d", "See if there is more to slice...")
+        # Somehow this results in an Arcus Error
+        # self.slice()
+        # Testing call slice again, allow backend to restart by using the timer
+        self._invokeSlice()
 
     ##  Called when a g-code message is received from the engine.
     #
     #   \param message The protobuf message containing g-code, encoded as UTF-8.
     def _onGCodeLayerMessage(self, message):
-        self._scene.gcode_list.append(message.data.decode("utf-8", "replace"))
+        self._scene.gcode_list[self._start_slice_job_build_plate].append(message.data.decode("utf-8", "replace"))
 
     ##  Called when a g-code prefix message is received from the engine.
     #
     #   \param message The protobuf message containing the g-code prefix,
     #   encoded as UTF-8.
     def _onGCodePrefixMessage(self, message):
-        self._scene.gcode_list.insert(0, message.data.decode("utf-8", "replace"))
+        self._scene.gcode_list[self._start_slice_job_build_plate].insert(0, message.data.decode("utf-8", "replace"))
 
     ##  Creates a new socket connection.
     def _createSocket(self):
@@ -551,7 +614,7 @@ class CuraEngineBackend(QObject, Backend):
             material_amounts.append(message.getRepeatedMessage("materialEstimates", index).material_amount)
 
         times = self._parseMessagePrintTimes(message)
-        self.printDurationMessage.emit(times, material_amounts)
+        self.printDurationMessage.emit(self._start_slice_job_build_plate, times, material_amounts)
 
     ##  Called for parsing message to retrieve estimated time per feature
     #
@@ -605,19 +668,25 @@ class CuraEngineBackend(QObject, Backend):
             source = self._postponed_scene_change_sources.pop(0)
             self._onSceneChanged(source)
 
+    def _startProcessSlicedLayersJob(self, build_plate_number):
+        self._process_layers_job = ProcessSlicedLayersJob.ProcessSlicedLayersJob(self._stored_optimized_layer_data[build_plate_number])
+        self._process_layers_job.setBuildPlate(build_plate_number)
+        self._process_layers_job.finished.connect(self._onProcessLayersFinished)
+        self._process_layers_job.start()
+
     ##  Called when the user changes the active view mode.
     def _onActiveViewChanged(self):
-        if Application.getInstance().getController().getActiveView():
+        application = Application.getInstance()
-            view = Application.getInstance().getController().getActiveView()
+        view = application.getController().getActiveView()
+        if view:
+            active_build_plate = application.getBuildPlateModel().activeBuildPlate
             if view.getPluginId() == "SimulationView":  # If switching to layer view, we should process the layers if that hasn't been done yet.
                 self._layer_view_active = True
                 # There is data and we're not slicing at the moment
                 # if we are slicing, there is no need to re-calculate the data as it will be invalid in a moment.
-                if self._stored_optimized_layer_data and not self._slicing:
+                # TODO: what build plate I am slicing
-                    self._process_layers_job = ProcessSlicedLayersJob.ProcessSlicedLayersJob(self._stored_optimized_layer_data)
+                if active_build_plate in self._stored_optimized_layer_data and not self._slicing and not self._process_layers_job:
-                    self._process_layers_job.finished.connect(self._onProcessLayersFinished)
+                    self._startProcessSlicedLayersJob(active_build_plate)
-                    self._process_layers_job.start()
-                    self._stored_optimized_layer_data = []
             else:
                 self._layer_view_active = False
 
@@ -653,7 +722,10 @@ class CuraEngineBackend(QObject, Backend):
             self._onChanged()
 
     def _onProcessLayersFinished(self, job):
+        del self._stored_optimized_layer_data[job.getBuildPlate()]
         self._process_layers_job = None
+        Logger.log("d", "See if there is more to slice(2)...")
+        self._invokeSlice()
 
     ##  Connect slice function to timer.
     def enableTimer(self):

plugins/CuraEngineBackend/ProcessSlicedLayersJob.py

@@ -4,7 +4,6 @@
 import gc
 
 from UM.Job import Job
-from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
 from UM.Scene.SceneNode import SceneNode
 from UM.Application import Application
 from UM.Mesh.MeshData import MeshData
@@ -17,6 +16,7 @@ from UM.Logger import Logger
 
 from UM.Math.Vector import Vector
 
+from cura.Scene.BuildPlateDecorator import BuildPlateDecorator
 from cura.Settings.ExtruderManager import ExtruderManager
 from cura import LayerDataBuilder
 from cura import LayerDataDecorator
@@ -49,6 +49,7 @@ class ProcessSlicedLayersJob(Job):
         self._scene = Application.getInstance().getController().getScene()
         self._progress_message = Message(catalog.i18nc("@info:status", "Processing Layers"), 0, False, -1)
         self._abort_requested = False
+        self._build_plate_number = None
 
     ##  Aborts the processing of layers.
     #
@@ -59,7 +60,14 @@ class ProcessSlicedLayersJob(Job):
     def abort(self):
         self._abort_requested = True
 
+    def setBuildPlate(self, new_value):
+        self._build_plate_number = new_value
+
+    def getBuildPlate(self):
+        return self._build_plate_number
+
     def run(self):
+        Logger.log("d", "Processing new layer for build plate %s..." % self._build_plate_number)
         start_time = time()
         view = Application.getInstance().getController().getActiveView()
         if view.getPluginId() == "SimulationView":
@@ -74,16 +82,7 @@ class ProcessSlicedLayersJob(Job):
         Application.getInstance().getController().activeViewChanged.connect(self._onActiveViewChanged)
 
         new_node = SceneNode()
-
+        new_node.addDecorator(BuildPlateDecorator(self._build_plate_number))
-        ## Remove old layer data (if any)
-        for node in DepthFirstIterator(self._scene.getRoot()):
-            if node.callDecoration("getLayerData"):
-                node.getParent().removeChild(node)
-                break
-            if self._abort_requested:
-                if self._progress_message:
-                    self._progress_message.hide()
-                return
 
         # Force garbage collection.
         # For some reason, Python has a tendency to keep the layer data

plugins/CuraEngineBackend/StartSliceJob.py

@@ -10,12 +10,12 @@ from UM.Job import Job
 from UM.Application import Application
 from UM.Logger import Logger
 
-from UM.Scene.SceneNode import SceneNode
 from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
 
 from UM.Settings.Validator import ValidatorState
 from UM.Settings.SettingRelation import RelationType
 
+from cura.Scene.CuraSceneNode import CuraSceneNode as SceneNode
 from cura.OneAtATimeIterator import OneAtATimeIterator
 from cura.Settings.ExtruderManager import ExtruderManager
 
@@ -78,12 +78,16 @@ class StartSliceJob(Job):
         self._scene = Application.getInstance().getController().getScene()
         self._slice_message = slice_message
         self._is_cancelled = False
+        self._build_plate_number = None
 
         self._all_extruders_settings = None # cache for all setting values from all stacks (global & extruder) for the current machine
 
     def getSliceMessage(self):
         return self._slice_message
 
+    def setBuildPlate(self, build_plate_number):
+        self._build_plate_number = build_plate_number
+
     ##  Check if a stack has any errors.
     ##  returns true if it has errors, false otherwise.
     def _checkStackForErrors(self, stack):
@@ -100,6 +104,10 @@ class StartSliceJob(Job):
 
     ##  Runs the job that initiates the slicing.
     def run(self):
+        if self._build_plate_number is None:
+            self.setResult(StartJobResult.Error)
+            return
+
         stack = Application.getInstance().getGlobalContainerStack()
         if not stack:
             self.setResult(StartJobResult.Error)
@@ -133,7 +141,7 @@ class StartSliceJob(Job):
         with self._scene.getSceneLock():
             # Remove old layer data.
             for node in DepthFirstIterator(self._scene.getRoot()):
-                if node.callDecoration("getLayerData"):
+                if node.callDecoration("getLayerData") and node.callDecoration("getBuildPlateNumber") == self._build_plate_number:
                     node.getParent().removeChild(node)
                     break
 
@@ -168,10 +176,11 @@ class StartSliceJob(Job):
                         if per_object_stack:
                             is_non_printing_mesh = any(per_object_stack.getProperty(key, "value") for key in NON_PRINTING_MESH_SETTINGS)
 
-                        if not getattr(node, "_outside_buildarea", False) or is_non_printing_mesh:
+                        if (node.callDecoration("getBuildPlateNumber") == self._build_plate_number):
-                            temp_list.append(node)
+                            if not getattr(node, "_outside_buildarea", False) or is_non_printing_mesh:
-                            if not is_non_printing_mesh:
+                                temp_list.append(node)
-                                has_printing_mesh = True
+                                if not is_non_printing_mesh:
+                                    has_printing_mesh = True
 
                     Job.yieldThread()
 

plugins/GCodeReader/FlavorParser.py

@@ -17,7 +17,7 @@ catalog = i18nCatalog("cura")
 from cura import LayerDataBuilder
 from cura import LayerDataDecorator
 from cura.LayerPolygon import LayerPolygon
-from cura.GCodeListDecorator import GCodeListDecorator
+from cura.Scene.GCodeListDecorator import GCodeListDecorator
 from cura.Settings.ExtruderManager import ExtruderManager
 
 import numpy

plugins/GCodeWriter/GCodeWriter.py

@@ -59,8 +59,9 @@ class GCodeWriter(MeshWriter):
             Logger.log("e", "GCode Writer does not support non-text mode.")
             return False
 
+        active_build_plate = Application.getInstance().getBuildPlateModel().activeBuildPlate
         scene = Application.getInstance().getController().getScene()
-        gcode_list = getattr(scene, "gcode_list")
+        gcode_list = getattr(scene, "gcode_list")[active_build_plate]
         if gcode_list:
             for gcode in gcode_list:
                 stream.write(gcode)

plugins/ImageReader/ImageReader.py

@@ -8,12 +8,13 @@ from PyQt5.QtCore import Qt
 
 from UM.Mesh.MeshReader import MeshReader
 from UM.Mesh.MeshBuilder import MeshBuilder
-from UM.Scene.SceneNode import SceneNode
 from UM.Math.Vector import Vector
 from UM.Job import Job
 from UM.Logger import Logger
 from .ImageReaderUI import ImageReaderUI
 
+from cura.Scene.CuraSceneNode import CuraSceneNode as SceneNode
+
 
 class ImageReader(MeshReader):
     def __init__(self):

plugins/SimulationView/SimulationPass.py

@@ -93,6 +93,7 @@ class SimulationPass(RenderPass):
         self.bind()
 
         tool_handle_batch = RenderBatch(self._tool_handle_shader, type = RenderBatch.RenderType.Overlay, backface_cull = True)
+        active_build_plate = Application.getInstance().getBuildPlateModel().activeBuildPlate
         head_position = None  # Indicates the current position of the print head
         nozzle_node = None
 
@@ -105,7 +106,7 @@ class SimulationPass(RenderPass):
                 nozzle_node = node
                 nozzle_node.setVisible(False)
 
-            elif isinstance(node, SceneNode) and (node.getMeshData() or node.callDecoration("isBlockSlicing")) and node.isVisible():
+            elif issubclass(type(node), SceneNode) and (node.getMeshData() or node.callDecoration("isBlockSlicing")) and node.isVisible() and node.callDecoration("getBuildPlateNumber") == active_build_plate:
                 layer_data = node.callDecoration("getLayerData")
                 if not layer_data:
                     continue

plugins/SimulationView/SimulationView.py

@@ -25,7 +25,7 @@ from UM.View.GL.OpenGL import OpenGL
 from UM.View.GL.OpenGLContext import OpenGLContext
 from UM.View.View import View
 from UM.i18n import i18nCatalog
-from cura.ConvexHullNode import ConvexHullNode
+from cura.Scene.ConvexHullNode import ConvexHullNode
 from cura.CuraApplication import CuraApplication
 
 from .NozzleNode import NozzleNode

plugins/SliceInfoPlugin/SliceInfo.py

@@ -166,7 +166,7 @@ class SliceInfo(Extension):
 
                     data["models"].append(model)
 
-            print_times = print_information._print_time_message_values
+            print_times = print_information.printTimes()
             data["print_times"] = {"travel": int(print_times["travel"].getDisplayString(DurationFormat.Format.Seconds)),
                                    "support": int(print_times["support"].getDisplayString(DurationFormat.Format.Seconds)),
                                    "infill": int(print_times["infill"].getDisplayString(DurationFormat.Format.Seconds)),

plugins/UM3NetworkPrinting/NetworkClusterPrinterOutputDevice.py

@@ -243,6 +243,11 @@ class NetworkClusterPrinterOutputDevice(NetworkPrinterOutputDevice.NetworkPrinte
         self._selected_printer = self._automatic_printer  # reset to default option
         self._request_job = [nodes, file_name, filter_by_machine, file_handler, kwargs]
 
+        # the build plates to be sent
+        gcodes = getattr(Application.getInstance().getController().getScene(), "gcode_list")
+        self._job_list = list(gcodes.keys())
+        Logger.log("d", "build plates to be sent to printer: %s", (self._job_list))
+
         if self._stage != OutputStage.ready:
             if self._error_message:
                 self._error_message.hide()
@@ -252,14 +257,15 @@ class NetworkClusterPrinterOutputDevice(NetworkPrinterOutputDevice.NetworkPrinte
             self._error_message.show()
             return
 
+        self._add_build_plate_number = len(self._job_list) > 1
         self.writeStarted.emit(self) # Allow postprocessing before sending data to the printer
-
         if len(self._printers) > 1:
             self.spawnPrintView()  # Ask user how to print it.
         elif len(self._printers) == 1:
             # If there is only one printer, don't bother asking.
             self.selectAutomaticPrinter()
             self.sendPrintJob()
+
         else:
             # Cluster has no printers, warn the user of this.
             if self._error_message:
@@ -274,28 +280,34 @@ class NetworkClusterPrinterOutputDevice(NetworkPrinterOutputDevice.NetworkPrinte
     @pyqtSlot()
     def sendPrintJob(self):
         nodes, file_name, filter_by_machine, file_handler, kwargs = self._request_job
-        require_printer_name = self._selected_printer["unique_name"]
+        output_build_plate_number = self._job_list.pop(0)
+        gcode = getattr(Application.getInstance().getController().getScene(), "gcode_list")[output_build_plate_number]
 
         self._send_gcode_start = time.time()
-        Logger.log("d", "Sending print job [%s] to host..." % file_name)
+        Logger.log("d", "Sending print job [%s] to host, build plate [%s]..." % (file_name, output_build_plate_number))
 
         if self._stage != OutputStage.ready:
             Logger.log("d", "Unable to send print job as the state is %s", self._stage)
             raise OutputDeviceError.DeviceBusyError()
         self._stage = OutputStage.uploading
 
-        self._file_name = "%s.gcode.gz" % file_name
+        if self._add_build_plate_number:
+            self._file_name = "%s_%d.gcode.gz" % (file_name, output_build_plate_number)
+        else:
+            self._file_name = "%s.gcode.gz" % (file_name)
         self._showProgressMessage()
 
-        new_request = self._buildSendPrintJobHttpRequest(require_printer_name)
+        require_printer_name = self._selected_printer["unique_name"]
+
+        new_request = self._buildSendPrintJobHttpRequest(require_printer_name, gcode)
         if new_request is None or self._stage != OutputStage.uploading:
             return
         self._request = new_request
         self._reply = self._manager.post(self._request, self._multipart)
         self._reply.uploadProgress.connect(self._onUploadProgress)
-        # See _finishedPostPrintJobRequest()
+        # See _finishedPrintJobPostRequest()
 
-    def _buildSendPrintJobHttpRequest(self, require_printer_name):
+    def _buildSendPrintJobHttpRequest(self, require_printer_name, gcode):
         api_url = QUrl(self._api_base_uri + "print_jobs/")
         request = QNetworkRequest(api_url)
         # Create multipart request and add the g-code.
@@ -304,9 +316,8 @@ class NetworkClusterPrinterOutputDevice(NetworkPrinterOutputDevice.NetworkPrinte
         # Add gcode
         part = QHttpPart()
         part.setHeader(QNetworkRequest.ContentDispositionHeader,
-                       'form-data; name="file"; filename="%s"' % self._file_name)
+                       'form-data; name="file"; filename="%s"' % (self._file_name))
 
-        gcode = getattr(Application.getInstance().getController().getScene(), "gcode_list")
         compressed_gcode = self._compressGcode(gcode)
         if compressed_gcode is None:
             return None     # User aborted print, so stop trying.
@@ -392,6 +403,9 @@ class NetworkClusterPrinterOutputDevice(NetworkPrinterOutputDevice.NetworkPrinte
 
         self._cleanupRequest()
 
+        if self._job_list:  # start sending next job
+            self.sendPrintJob()
+
     def _showRequestFailedMessage(self, reply):
         if reply is not None:
             Logger.log("w", "Unable to send print job to group {cluster_name}: {error_string} ({error})".format(

plugins/UM3NetworkPrinting/NetworkPrinterOutputDevice.py

@@ -675,7 +675,8 @@ class NetworkPrinterOutputDevice(PrinterOutputDevice):
         Application.getInstance().getController().setActiveStage("MonitorStage")
         self._print_finished = True
         self.writeStarted.emit(self)
-        self._gcode = getattr(Application.getInstance().getController().getScene(), "gcode_list")
+        active_build_plate = Application.getInstance().getBuildPlateModel().activeBuildPlate
+        self._gcode = getattr(Application.getInstance().getController().getScene(), "gcode_list")[active_build_plate]
 
         print_information = Application.getInstance().getPrintInformation()
         warnings = []  # There might be multiple things wrong. Keep a list of all the stuff we need to warn about.

plugins/X3DReader/X3DReader.py

@@ -11,7 +11,7 @@ from UM.Math.Matrix import Matrix
 from UM.Math.Vector import Vector
 from UM.Mesh.MeshBuilder import MeshBuilder
 from UM.Mesh.MeshReader import MeshReader
-from UM.Scene.SceneNode import SceneNode
+from cura.Scene.CuraSceneNode import CuraSceneNode as SceneNode
 
 MYPY = False
 try:
@@ -19,63 +19,63 @@ try:
         import xml.etree.cElementTree as ET
 except ImportError:
     import xml.etree.ElementTree as ET
-    
+
 # TODO: preserve the structure of scenes that contain several objects
-# Use CADPart, for example, to distinguish between separate objects    
+# Use CADPart, for example, to distinguish between separate objects
-    
+
 DEFAULT_SUBDIV = 16 # Default subdivision factor for spheres, cones, and cylinders
 EPSILON = 0.000001
 
 class Shape:
-    
+
     # Expects verts in MeshBuilder-ready format, as a n by 3 mdarray
     # with vertices stored in rows
     def __init__(self, verts, faces, index_base, name):
         self.verts = verts
         self.faces = faces
         # Those are here for debugging purposes only
-        self.index_base = index_base 
+        self.index_base = index_base
         self.name = name
-        
+
 class X3DReader(MeshReader):
     def __init__(self):
         super().__init__()
         self._supported_extensions = [".x3d"]
         self._namespaces = {}
-    
+
     # Main entry point
     # Reads the file, returns a SceneNode (possibly with nested ones), or None
     def read(self, file_name):
         try:
             self.defs = {}
             self.shapes = []
-            
+
             tree = ET.parse(file_name)
             xml_root = tree.getroot()
-            
+
             if xml_root.tag != "X3D":
                 return None
 
-            scale = 1000 # Default X3D unit it one meter, while Cura's is one millimeters            
+            scale = 1000 # Default X3D unit it one meter, while Cura's is one millimeters
             if xml_root[0].tag == "head":
                 for head_node in xml_root[0]:
                     if head_node.tag == "unit" and head_node.attrib.get("category") == "length":
                         scale *= float(head_node.attrib["conversionFactor"])
-                        break 
+                        break
                 xml_scene = xml_root[1]
             else:
                 xml_scene = xml_root[0]
-                
+
             if xml_scene.tag != "Scene":
                 return None
-            
+
             self.transform = Matrix()
             self.transform.setByScaleFactor(scale)
             self.index_base = 0
-            
+
             # Traverse the scene tree, populate the shapes list
             self.processChildNodes(xml_scene)
-            
+
             if self.shapes:
                 builder = MeshBuilder()
                 builder.setVertices(numpy.concatenate([shape.verts for shape in self.shapes]))
@@ -95,20 +95,20 @@ class X3DReader(MeshReader):
 
             else:
                 return None
-            
+
         except Exception:
             Logger.logException("e", "Exception in X3D reader")
             return None
 
         return node
-    
+
     # ------------------------- XML tree traversal
-  
+
     def processNode(self, xml_node):
         xml_node =  self.resolveDefUse(xml_node)
         if xml_node is None:
             return
-        
+
         tag = xml_node.tag
         if tag in ("Group", "StaticGroup", "CADAssembly", "CADFace", "CADLayer", "Collision"):
             self.processChildNodes(xml_node)
@@ -120,8 +120,8 @@ class X3DReader(MeshReader):
             self.processTransform(xml_node)
         elif tag == "Shape":
             self.processShape(xml_node)
-            
+
-            
+
     def processShape(self, xml_node):
         # Find the geometry and the appearance inside the Shape
         geometry = appearance = None
@@ -130,21 +130,21 @@ class X3DReader(MeshReader):
                 appearance = self.resolveDefUse(sub_node)
             elif sub_node.tag in self.geometry_importers and not geometry:
                 geometry = self.resolveDefUse(sub_node)
-        
+
-        # TODO: appearance is completely ignored. At least apply the material color...        
+        # TODO: appearance is completely ignored. At least apply the material color...
         if not geometry is None:
             try:
-                self.verts = self.faces = [] # Safeguard 
+                self.verts = self.faces = [] # Safeguard
                 self.geometry_importers[geometry.tag](self, geometry)
                 m = self.transform.getData()
                 verts = m.dot(self.verts)[:3].transpose()
-                
+
                 self.shapes.append(Shape(verts, self.faces, self.index_base, geometry.tag))
                 self.index_base += len(verts)
-                
+
             except Exception:
                 Logger.logException("e", "Exception in X3D reader while reading %s", geometry.tag)
-        
+
     # Returns the referenced node if the node has USE, the same node otherwise.
     # May return None is USE points at a nonexistent node
     # In X3DOM, when both DEF and USE are in the same node, DEF is ignored.
@@ -155,34 +155,34 @@ class X3DReader(MeshReader):
         if USE:
             return self.defs.get(USE, None)
 
-        DEF = node.attrib.get("DEF")            
+        DEF = node.attrib.get("DEF")
         if DEF:
-            self.defs[DEF] = node 
+            self.defs[DEF] = node
         return node
-    
+
     def processChildNodes(self, node):
         for c in node:
             self.processNode(c)
             Job.yieldThread()
-    
+
     # Since this is a grouping node, will recurse down the tree.
     # According to the spec, the final transform matrix is:
     # T * C * R * SR * S * -SR * -C
     # Where SR corresponds to the rotation matrix to scaleOrientation
-    # C and SR are rather exotic. S, slightly less so. 
+    # C and SR are rather exotic. S, slightly less so.
     def processTransform(self, node):
         rot = readRotation(node, "rotation", (0, 0, 1, 0)) # (angle, axisVactor) tuple
         trans = readVector(node, "translation", (0, 0, 0)) # Vector
         scale = readVector(node, "scale", (1, 1, 1)) # Vector
         center = readVector(node, "center", (0, 0, 0)) # Vector
         scale_orient = readRotation(node, "scaleOrientation", (0, 0, 1, 0)) # (angle, axisVactor) tuple
-        
+
-        # Store the previous transform; in Cura, the default matrix multiplication is in place        
+        # Store the previous transform; in Cura, the default matrix multiplication is in place
         prev = Matrix(self.transform.getData()) # It's deep copy, I've checked
-        
+
         # The rest of transform manipulation will be applied in place
         got_center = (center.x != 0 or center.y != 0 or center.z != 0)
-        
+
         T = self.transform
         if trans.x != 0 or trans.y != 0 or trans.z != 0:
             T.translate(trans)
@@ -202,13 +202,13 @@ class X3DReader(MeshReader):
                 T.rotateByAxis(-scale_orient[0], scale_orient[1])
         if got_center:
             T.translate(-center)
-            
+
         self.processChildNodes(node)
         self.transform = prev
-    
+
     # ------------------------- Geometry importers
     # They are supposed to fill the self.verts and self.faces arrays, the caller will do the rest
-    
+
     # Primitives
 
     def processGeometryBox(self, node):
@@ -228,14 +228,14 @@ class X3DReader(MeshReader):
         self.addVertex(-dx, -dy, dz)
         self.addVertex(-dx, -dy, -dz)
         self.addVertex(dx, -dy, -dz)
-        
+
         self.addQuad(0, 1, 2, 3)   # +y
         self.addQuad(4, 0, 3, 7)   # +x
         self.addQuad(7, 3, 2, 6)   # -z
         self.addQuad(6, 2, 1, 5)   # -x
         self.addQuad(5, 1, 0, 4)   # +z
         self.addQuad(7, 6, 5, 4)  # -y
-    
+
     # The sphere is subdivided into nr rings and ns segments
     def processGeometrySphere(self, node):
         r = readFloat(node, "radius", 0.5)
@@ -247,16 +247,16 @@ class X3DReader(MeshReader):
                 (nr, ns) = subdiv
         else:
             nr = ns = DEFAULT_SUBDIV
-            
+
         lau = pi / nr  # Unit angle of latitude (rings) for the given tesselation
         lou = 2 * pi / ns  # Unit angle of longitude (segments)
-        
+
         self.reserveFaceAndVertexCount(ns*(nr*2 - 2), 2 + (nr - 1)*ns)
-        
+
         # +y and -y poles
         self.addVertex(0, r, 0)
         self.addVertex(0, -r, 0)
-        
+
         # The non-polar vertices go from x=0, negative z plane counterclockwise -
         # to -x, to +z, to +x, back to -z
         for ring in range(1, nr):
@@ -264,12 +264,12 @@ class X3DReader(MeshReader):
                 self.addVertex(-r*sin(lou * seg) * sin(lau * ring),
                           r*cos(lau * ring),
                           -r*cos(lou * seg) * sin(lau * ring))
-                
+
         vb = 2 + (nr - 2) * ns  # First vertex index for the bottom cap
-    
+
         # Faces go in order: top cap, sides, bottom cap.
         # Sides go by ring then by segment.
-    
+
         # Caps
         # Top cap face vertices go in order: down right up
         # (starting from +y pole)
@@ -277,7 +277,7 @@ class X3DReader(MeshReader):
         for seg in range(ns):
             self.addTri(0, seg + 2, (seg + 1) % ns + 2)
             self.addTri(1, vb + (seg + 1) % ns, vb + seg)
-    
+
         # Sides
         # Side face vertices go in order:  down right upleft, downright up left
         for ring in range(nr - 2):
@@ -288,24 +288,24 @@ class X3DReader(MeshReader):
             for seg in range(ns):
                 nseg = (seg + 1) % ns
                 self.addQuad(tvb + seg, bvb + seg, bvb + nseg, tvb + nseg)
-        
+
     def processGeometryCone(self, node):
         r = readFloat(node, "bottomRadius", 1)
         height = readFloat(node, "height", 2)
         bottom = readBoolean(node, "bottom", True)
         side = readBoolean(node, "side", True)
         n = readInt(node, "subdivision", DEFAULT_SUBDIV)
-        
+
         d = height / 2
         angle = 2 * pi / n
-    
+
         self.reserveFaceAndVertexCount((n if side else 0) + (n-2 if bottom else 0), n+1)
-    
+
         # Vertex 0 is the apex, vertices 1..n are the bottom
         self.addVertex(0, d, 0)
         for i in range(n):
             self.addVertex(-r * sin(angle * i), -d, -r * cos(angle * i))
-                    
+
         # Side face vertices go: up down right
         if side:
             for i in range(n):
@@ -313,7 +313,7 @@ class X3DReader(MeshReader):
         if bottom:
             for i in range(2, n):
                 self.addTri(1, i, i+1)
-    
+
     def processGeometryCylinder(self, node):
         r = readFloat(node, "radius", 1)
         height = readFloat(node, "height", 2)
@@ -321,13 +321,13 @@ class X3DReader(MeshReader):
         side = readBoolean(node, "side", True)
         top = readBoolean(node, "top", True)
         n = readInt(node, "subdivision", DEFAULT_SUBDIV)
-        
+
         nn = n * 2
         angle = 2 * pi / n
         hh = height/2
-        
+
         self.reserveFaceAndVertexCount((nn if side else 0) + (n - 2 if top else 0) + (n - 2 if bottom else 0), nn)
-        
+
         # The seam is at x=0, z=-r, vertices go ccw -
         # to pos x, to neg z, to neg x, back to neg z
         for i in range(n):
@@ -335,18 +335,18 @@ class X3DReader(MeshReader):
             rc = -r * cos(angle * i)
             self.addVertex(rs, hh, rc)
             self.addVertex(rs, -hh, rc)
-        
+
         if side:
             for i in range(n):
                 ni = (i + 1) % n
                 self.addQuad(ni * 2 + 1, ni * 2, i * 2, i * 2 + 1)
-            
+
         for i in range(2, nn-3, 2):
             if top:
                 self.addTri(0, i, i+2)
             if bottom:
                 self.addTri(1, i+1, i+3)
-    
+
     # Semi-primitives
 
     def processGeometryElevationGrid(self, node):
@@ -356,21 +356,21 @@ class X3DReader(MeshReader):
         nz = readInt(node, "zDimension", 0)
         height = readFloatArray(node, "height", False)
         ccw = readBoolean(node, "ccw", True)
-        
+
         if nx <= 0 or nz <= 0 or len(height) < nx*nz:
             return # That's weird, the wording of the standard suggests grids with zero quads are somehow valid
-        
+
         self.reserveFaceAndVertexCount(2*(nx-1)*(nz-1), nx*nz)
-        
+
         for z in range(nz):
             for x in range(nx):
                 self.addVertex(x * dx, height[z*nx + x], z * dz)
-                
+
         for z in range(1, nz):
             for x in range(1, nx):
                 self.addTriFlip((z - 1)*nx + x - 1, z*nx + x, (z - 1)*nx + x, ccw)
                 self.addTriFlip((z - 1)*nx + x - 1, z*nx + x - 1, z*nx + x, ccw)
-    
+
     def processGeometryExtrusion(self, node):
         ccw = readBoolean(node, "ccw", True)
         begin_cap = readBoolean(node, "beginCap", True)
@@ -384,23 +384,23 @@ class X3DReader(MeshReader):
             # This converts X3D's axis/angle rotation to a 3x3 numpy matrix
             def toRotationMatrix(rot):
                 (x, y, z) = rot[:3]
-                a = rot[3]  
+                a = rot[3]
                 s = sin(a)
                 c = cos(a)
                 t = 1-c
                 return numpy.array((
                     (x * x * t + c,  x * y * t - z*s, x * z * t + y * s),
                     (x * y * t + z*s, y * y * t + c, y * z * t - x * s),
-                    (x * z * t - y * s, y * z * t + x * s, z * z * t + c)))   
+                    (x * z * t - y * s, y * z * t + x * s, z * z * t + c)))
-            
+
             orient = [toRotationMatrix(orient[i:i+4]) if orient[i+3] != 0 else None for i in range(0, len(orient), 4)]
-            
+
         scale = readFloatArray(node, "scale", None)
         if scale:
             scale = [numpy.array(((scale[i], 0, 0), (0, 1, 0), (0, 0, scale[i+1])))
                      if scale[i] != 1 or scale[i+1] != 1 else None for i in range(0, len(scale), 2)]
-        
+
-        
+
         # Special treatment for the closed spine and cross section.
         # Let's save some memory by not creating identical but distinct vertices;
         # later we'll introduce conditional logic to link the last vertex with
@@ -413,14 +413,14 @@ class X3DReader(MeshReader):
         ncf = nc if crossClosed else nc - 1
         # Face count along the cross; for closed cross, it's the same as the
         # respective vertex count
-    
+
         spine_closed = spine[0] == spine[-1]
         if spine_closed:
             spine = spine[:-1]
         ns = len(spine)
         spine = [Vector(*s) for s in spine]
         nsf = ns if spine_closed else ns - 1
-    
+
         # This will be used for fallback, where the current spine point joins
         # two collinear spine segments. No need to recheck the case of the
         # closed spine/last-to-first point juncture; if there's an angle there,
@@ -442,7 +442,7 @@ class X3DReader(MeshReader):
             if v.cross(orig_y).length() > EPSILON:
                 # Spine at angle with global y - rotate the z accordingly
                 a = v.cross(orig_y) # Axis of rotation to get to the Z
-                (x, y, z) = a.normalized().getData()  
+                (x, y, z) = a.normalized().getData()
                 s = a.length()/v.length()
                 c = sqrt(1-s*s)
                 t = 1-c
@@ -452,7 +452,7 @@ class X3DReader(MeshReader):
                     (x * z * t + y * s, y * z * t - x * s, z * z * t + c)))
                 orig_z = Vector(*m.dot(orig_z.getData()))
             return orig_z
-    
+
         self.reserveFaceAndVertexCount(2*nsf*ncf + (nc - 2 if begin_cap else 0) + (nc - 2 if end_cap else 0), ns*nc)
 
         z = None
@@ -482,151 +482,151 @@ class X3DReader(MeshReader):
                 y = spt - sprev
                 # If there's more than one point in the spine, z is already set.
                 # One point in the spline is an error anyway.
-    
+
             z = z.normalized()
             y = y.normalized()
             x = y.cross(z) # Already normalized
             m = numpy.array(((x.x, y.x, z.x), (x.y, y.y, z.y), (x.z, y.z, z.z)))
-            
+
             # Columns are the unit vectors for the xz plane for the cross-section
             if orient:
                 mrot = orient[i] if len(orient) > 1 else orient[0]
                 if not mrot is None:
                     m = m.dot(mrot)  # Tested against X3DOM, the result matches, still not sure :(
-                    
+
             if scale:
                 mscale = scale[i] if len(scale) > 1 else scale[0]
                 if not mscale is None:
                     m = m.dot(mscale)
-                    
+
             # First the cross-section 2-vector is scaled,
             # then rotated (which may make it a 3-vector),
             # then applied to the xz plane unit vectors
-                    
+
             sptv3 = numpy.array(spt.getData()[:3])
             for cpt in cross:
                 v = sptv3 + m.dot(cpt)
                 self.addVertex(*v)
-    
+
         if begin_cap:
             self.addFace([x for x in range(nc - 1, -1, -1)], ccw)
-    
+
         # Order of edges in the face: forward along cross, forward along spine,
         # backward along cross, backward along spine, flipped if now ccw.
         # This order is assumed later in the texture coordinate assignment;
         # please don't change without syncing.
-    
+
         for s in range(ns - 1):
             for c in range(ncf):
                 self.addQuadFlip(s * nc + c, s * nc + (c + 1) % nc,
                     (s + 1) * nc + (c + 1) % nc, (s + 1) * nc + c, ccw)
-    
+
         if spine_closed:
             # The faces between the last and the first spine points
             b = (ns - 1) * nc
             for c in range(ncf):
                 self.addQuadFlip(b + c, b + (c + 1) % nc,
                     (c + 1) % nc, c, ccw)
-                        
+
         if end_cap:
             self.addFace([(ns - 1) * nc + x for x in range(0, nc)], ccw)
-    
+
 # Triangle meshes
 
     # Helper for numerous nodes with a Coordinate subnode holding vertices
     # That all triangle meshes and IndexedFaceSet
-    # num_faces can be a function, in case the face count is a function of vertex count 
+    # num_faces can be a function, in case the face count is a function of vertex count
     def startCoordMesh(self, node, num_faces):
         ccw = readBoolean(node, "ccw", True)
         self.readVertices(node) # This will allocate and fill the vertex array
         if hasattr(num_faces, "__call__"):
             num_faces = num_faces(self.getVertexCount())
         self.reserveFaceCount(num_faces)
-            
+
         return ccw
-        
+
 
     def processGeometryIndexedTriangleSet(self, node):
         index = readIntArray(node, "index", [])
         num_faces = len(index) // 3
         ccw = int(self.startCoordMesh(node, num_faces))
-        
+
         for i in range(0, num_faces*3, 3):
             self.addTri(index[i + 1 - ccw], index[i + ccw], index[i+2])
-    
+
     def processGeometryIndexedTriangleStripSet(self, node):
         strips = readIndex(node, "index")
         ccw = int(self.startCoordMesh(node, sum([len(strip) - 2 for strip in strips])))
-            
+
         for strip in strips:
             sccw = ccw # Running CCW value, reset for each strip
             for i in range(len(strip) - 2):
                 self.addTri(strip[i + 1 - sccw], strip[i + sccw], strip[i+2])
                 sccw = 1 - sccw
-    
+
     def processGeometryIndexedTriangleFanSet(self, node):
         fans = readIndex(node, "index")
         ccw = int(self.startCoordMesh(node, sum([len(fan) - 2 for fan in fans])))
-        
+
         for fan in fans:
             for i in range(1, len(fan) - 1):
                 self.addTri(fan[0], fan[i + 1 - ccw], fan[i + ccw])
-   
+
     def processGeometryTriangleSet(self, node):
         ccw = int(self.startCoordMesh(node, lambda num_vert: num_vert // 3))
         for i in range(0, self.getVertexCount(), 3):
             self.addTri(i + 1 - ccw, i + ccw, i+2)
-    
+
     def processGeometryTriangleStripSet(self, node):
         strips = readIntArray(node, "stripCount", [])
         ccw = int(self.startCoordMesh(node, sum([n-2 for n in strips])))
-            
+
         vb = 0
         for n in strips:
             sccw = ccw
-            for i in range(n-2): 
+            for i in range(n-2):
                 self.addTri(vb + i + 1 - sccw, vb + i + sccw, vb + i + 2)
                 sccw = 1 - sccw
             vb += n
-    
+
     def processGeometryTriangleFanSet(self, node):
         fans = readIntArray(node, "fanCount", [])
         ccw = int(self.startCoordMesh(node, sum([n-2 for n in fans])))
-        
+
         vb = 0
         for n in fans:
-            for i in range(1, n-1): 
+            for i in range(1, n-1):
                 self.addTri(vb, vb + i + 1 - ccw, vb + i + ccw)
             vb += n
-            
+
     # Quad geometries from the CAD module, might be relevant for printing
-    
+
     def processGeometryQuadSet(self, node):
         ccw = self.startCoordMesh(node, lambda num_vert: 2*(num_vert // 4))
         for i in range(0, self.getVertexCount(), 4):
             self.addQuadFlip(i, i+1, i+2, i+3, ccw)
-            
+
     def processGeometryIndexedQuadSet(self, node):
         index = readIntArray(node, "index", [])
         num_quads = len(index) // 4
         ccw = self.startCoordMesh(node, num_quads*2)
-        
+
         for i in range(0, num_quads*4, 4):
             self.addQuadFlip(index[i], index[i+1], index[i+2], index[i+3], ccw)
-            
+
     # 2D polygon geometries
     # Won't work for now, since Cura expects every mesh to have a nontrivial convex hull
     # The only way around that is merging meshes.
-    
+
     def processGeometryDisk2D(self, node):
         innerRadius = readFloat(node, "innerRadius", 0)
         outerRadius = readFloat(node, "outerRadius", 1)
         n = readInt(node, "subdivision", DEFAULT_SUBDIV)
-        
+
         angle = 2 * pi / n
-        
+
         self.reserveFaceAndVertexCount(n*4 if innerRadius else n-2, n*2 if innerRadius else n)
-            
+
         for i in range(n):
             s = sin(angle * i)
             c = cos(angle * i)
@@ -635,11 +635,11 @@ class X3DReader(MeshReader):
                 self.addVertex(innerRadius*c, innerRadius*s, 0)
                 ni = (i+1) % n
                 self.addQuad(2*i, 2*ni, 2*ni+1, 2*i+1)
-                
+
         if not innerRadius:
             for i in range(2, n):
                 self.addTri(0, i-1, i)
-                
+
     def processGeometryRectangle2D(self, node):
         (x, y) = readFloatArray(node, "size", (2, 2))
         self.reserveFaceAndVertexCount(2, 4)
@@ -648,7 +648,7 @@ class X3DReader(MeshReader):
         self.addVertex(x/2, y/2, 0)
         self.addVertex(-x/2, y/2, 0)
         self.addQuad(0, 1, 2, 3)
-        
+
     def processGeometryTriangleSet2D(self, node):
         verts = readFloatArray(node, "vertices", ())
         num_faces = len(verts) // 6;
@@ -656,25 +656,25 @@ class X3DReader(MeshReader):
         self.reserveFaceAndVertexCount(num_faces, num_faces * 3)
         for vert in verts:
             self.addVertex(*vert)
-        
+
         # The front face is on the +Z side, so CCW is a variable
         for i in range(0, num_faces*3, 3):
             a = Vector(*verts[i+2]) - Vector(*verts[i])
             b = Vector(*verts[i+1]) - Vector(*verts[i])
             self.addTriFlip(i, i+1, i+2, a.x*b.y > a.y*b.x)
-    
+
     # General purpose polygon mesh
 
     def processGeometryIndexedFaceSet(self, node):
         faces = readIndex(node, "coordIndex")
         ccw = self.startCoordMesh(node, sum([len(face) - 2 for face in faces]))
-            
+
         for face in faces:
             if len(face) == 3:
                 self.addTriFlip(face[0], face[1], face[2], ccw)
             elif len(face) > 3:
                 self.addFace(face, ccw)
-                
+
     geometry_importers = {
         "IndexedFaceSet": processGeometryIndexedFaceSet,
         "IndexedTriangleSet": processGeometryIndexedTriangleSet,
@@ -695,7 +695,7 @@ class X3DReader(MeshReader):
         "Cylinder": processGeometryCylinder,
         "Cone": processGeometryCone
     }
-    
+
     # Parses the Coordinate.@point field, fills the verts array.
     def readVertices(self, node):
         for c in node:
@@ -704,9 +704,9 @@ class X3DReader(MeshReader):
                 if not c is None:
                     pt = c.attrib.get("point")
                     if pt:
-                        # allow the list of float values in 'point' attribute to 
+                        # allow the list of float values in 'point' attribute to
-                        # be separated by commas or whitespace as per spec of 
+                        # be separated by commas or whitespace as per spec of
-                        # XML encoding of X3D 
+                        # XML encoding of X3D
                         # Ref  ISO/IEC 19776-1:2015 : Section 5.1.2
                         co = [float(x) for vec in pt.split(',') for x in vec.split()]
                         num_verts = len(co) // 3
@@ -715,57 +715,57 @@ class X3DReader(MeshReader):
                         # Group by three
                         for i in range(num_verts):
                             self.verts[:3,i] = co[3*i:3*i+3]
-    
+
     # Mesh builder helpers
-    
+
     def reserveFaceAndVertexCount(self, num_faces, num_verts):
         # Unlike the Cura MeshBuilder, we use 4-vectors stored as columns for easier transform
         self.verts = numpy.zeros((4, num_verts), dtype=numpy.float32)
         self.verts[3,:] = numpy.ones((num_verts), dtype=numpy.float32)
         self.num_verts = 0
         self.reserveFaceCount(num_faces)
-        
+
     def reserveFaceCount(self, num_faces):
         self.faces = numpy.zeros((num_faces, 3), dtype=numpy.int32)
         self.num_faces = 0
-        
+
     def getVertexCount(self):
         return self.verts.shape[1]
-        
+
     def addVertex(self, x, y, z):
         self.verts[0, self.num_verts] = x
         self.verts[1, self.num_verts] = y
         self.verts[2, self.num_verts] = z
         self.num_verts += 1
-    
+
     # Indices are 0-based for this shape, but they won't be zero-based in the merged mesh
     def addTri(self, a, b, c):
         self.faces[self.num_faces, 0] = self.index_base + a
         self.faces[self.num_faces, 1] = self.index_base + b
         self.faces[self.num_faces, 2] = self.index_base + c
         self.num_faces += 1
-        
+
     def addTriFlip(self, a, b, c, ccw):
         if ccw:
             self.addTri(a, b, c)
         else:
             self.addTri(b, a, c)
-        
+
     # Needs to be convex, but not necessaily planar
     # Assumed ccw, cut along the ac diagonal
     def addQuad(self, a, b, c, d):
         self.addTri(a, b, c)
         self.addTri(c, d, a)
-        
+
     def addQuadFlip(self, a, b, c, d, ccw):
         if ccw:
             self.addTri(a, b, c)
             self.addTri(c, d, a)
         else:
             self.addTri(a, c, b)
-            self.addTri(c, a, d)    
+            self.addTri(c, a, d)
-    
+
-    
+
     # Arbitrary polygon triangulation.
     # Doesn't assume convexity and doesn't check the "convex" flag in the file.
     # Works by the "cutting of ears" algorithm:
@@ -776,13 +776,13 @@ class X3DReader(MeshReader):
     def addFace(self, indices, ccw):
         # Resolve indices to coordinates for faster math
         face = [Vector(data=self.verts[0:3, i]) for i in indices]
-        
+
         # Need a normal to the plane so that we can know which vertices form inner angles
         normal = findOuterNormal(face)
-            
+
         if not normal: # Couldn't find an outer edge, non-planar polygon maybe?
             return
-        
+
         # Find the vertex with the smallest inner angle and no points inside, cut off. Repeat until done
         n = len(face)
         vi = [i for i in range(n)] # We'll be using this to kick vertices from the face
@@ -807,17 +807,17 @@ class X3DReader(MeshReader):
                                 if pointInsideTriangle(vx, next, prev, nextXprev):
                                     no_points_inside = False
                                     break
-                                
+
                         if no_points_inside:
                             max_cos = cos
                             i_min = i
-                            
+
             self.addTriFlip(indices[vi[(i_min + n - 1) % n]], indices[vi[i_min]], indices[vi[(i_min + 1) % n]], ccw)
             vi.pop(i_min)
             n -= 1
         self.addTriFlip(indices[vi[0]], indices[vi[1]], indices[vi[2]], ccw)
 
-    
+
 # ------------------------------------------------------------
 # X3D field parsers
 # ------------------------------------------------------------
@@ -844,7 +844,7 @@ def readInt(node, attr, default):
     if not s:
         return default
     return int(s, 0)
-     
+
 def readBoolean(node, attr, default):
     s = node.attrib.get(attr)
     if not s:
@@ -873,8 +873,8 @@ def readIndex(node, attr):
             chunk.append(v[i])
     if chunk:
         chunks.append(chunk)
-    return chunks  
+    return chunks
-  
+
 # Given a face as a sequence of vectors, returns a normal to the polygon place that forms a right triple
 # with a vector along the polygon sequence and a vector backwards
 def findOuterNormal(face):
@@ -894,25 +894,25 @@ def findOuterNormal(face):
                         if rejection.dot(prev_rejection) < -EPSILON: # points on both sides of the edge - not an outer one
                             is_outer = False
                             break
-                        elif rejection.length() > prev_rejection.length(): # Pick a greater rejection for numeric stability 
+                        elif rejection.length() > prev_rejection.length(): # Pick a greater rejection for numeric stability
                             prev_rejection = rejection
-                        
+
                 if is_outer: # Found an outer edge, prev_rejection is the rejection inside the face. Generate a normal.
                     return edge.cross(prev_rejection)
 
     return False
 
-# Given two *collinear* vectors a and b, returns the coefficient that takes b to a.    
+# Given two *collinear* vectors a and b, returns the coefficient that takes b to a.
 # No error handling.
-# For stability, taking the ration between the biggest coordinates would be better...   
+# For stability, taking the ration between the biggest coordinates would be better...
 def ratio(a, b):
     if b.x > EPSILON or b.x < -EPSILON:
         return a.x / b.x
     elif b.y > EPSILON or b.y < -EPSILON:
         return a.y / b.y
     else:
-        return a.z / b.z    
+        return a.z / b.z
-    
+
 def pointInsideTriangle(vx, next, prev, nextXprev):
     vxXprev = vx.cross(prev)
     r = ratio(vxXprev, nextXprev)
@@ -921,4 +921,4 @@ def pointInsideTriangle(vx, next, prev, nextXprev):
     vxXnext = vx.cross(next);
     s = -ratio(vxXnext, nextXprev)
     return s > 0 and (s + r) < 1
-     
+

resources/qml/Actions.qml

@@ -41,6 +41,7 @@ Item
     property alias selectAll: selectAllAction;
     property alias deleteAll: deleteAllAction;
     property alias reloadAll: reloadAllAction;
+    property alias arrangeAllBuildPlates: arrangeAllBuildPlatesAction;
     property alias arrangeAll: arrangeAllAction;
     property alias arrangeSelection: arrangeSelectionAction;
     property alias resetAllTranslation: resetAllTranslationAction;
@@ -344,6 +345,13 @@ Item
         onTriggered: CuraApplication.reloadAll();
     }
 
+    Action
+    {
+        id: arrangeAllBuildPlatesAction;
+        text: catalog.i18nc("@action:inmenu menubar:edit","Arrange All Models To All Build Plates");
+        onTriggered: Printer.arrangeObjectsToAllBuildPlates();
+    }
+
     Action
     {
         id: arrangeAllAction;

resources/qml/Cura.qml

@@ -375,6 +375,18 @@ UM.MainWindow
                 }
             }
 
+            ObjectsList
+            {
+                id: objectsList;
+                visible: UM.Preferences.getValue("cura/use_multi_build_plate");
+                anchors
+                {
+                    bottom: parent.bottom;
+                    left: parent.left;
+                }
+
+            }
+
             Topbar
             {
                 id: topbar

resources/qml/Menus/ContextMenu.qml

@@ -7,7 +7,7 @@ import QtQuick.Dialogs 1.2
 import QtQuick.Window 2.1
 
 import UM 1.2 as UM
-import Cura 1.0 as Cura
+import Cura 1.2 as Cura
 
 Menu
 {
@@ -39,6 +39,35 @@ Menu
         onObjectRemoved: base.removeItem(object)
     }
 
+    MenuSeparator {
+        visible: UM.Preferences.getValue("cura/use_multi_build_plate")
+    }
+
+    Instantiator
+    {
+        model: Cura.BuildPlateModel
+        MenuItem {
+            text: Cura.BuildPlateModel.getItem(index).name;
+            onTriggered: CuraActions.setBuildPlateForSelection(Cura.BuildPlateModel.getItem(index).buildPlateNumber);
+            checkable: true
+            checked: Cura.BuildPlateModel.selectionBuildPlates.indexOf(Cura.BuildPlateModel.getItem(index).buildPlateNumber) != -1;
+            visible: UM.Preferences.getValue("cura/use_multi_build_plate")
+        }
+        onObjectAdded: base.insertItem(index, object);
+        onObjectRemoved: base.removeItem(object);
+    }
+
+    MenuItem {
+        text: "New build plate";
+        onTriggered: {
+            CuraActions.setBuildPlateForSelection(Cura.BuildPlateModel.maxBuildPlate + 1);
+            checked = false;
+        }
+        checkable: true
+        checked: false
+        visible: UM.Preferences.getValue("cura/use_multi_build_plate")
+    }
+
     // Global actions
     MenuSeparator {}
     MenuItem { action: Cura.Actions.selectAll; }

resources/qml/Menus/ViewMenu.qml

@@ -5,12 +5,12 @@ import QtQuick 2.2
 import QtQuick.Controls 1.1
 
 import UM 1.2 as UM
-import Cura 1.0 as Cura
+import Cura 1.2 as Cura
 
 Menu
 {
     title: catalog.i18nc("@title:menu menubar:toplevel", "&View");
-    id: menu
+    id: base
     enabled: !PrintInformation.preSliced
 
     // main views
@@ -25,12 +25,13 @@ Menu
             exclusiveGroup: group
             onTriggered: UM.Controller.setActiveView(model.id)
         }
-        onObjectAdded: menu.insertItem(index, object)
+        onObjectAdded: base.insertItem(index, object)
-        onObjectRemoved: menu.removeItem(object)
+        onObjectRemoved: base.removeItem(object)
     }
     ExclusiveGroup { id: group }
 
     MenuSeparator {}
+
     Menu
     {
         title: catalog.i18nc("@action:inmenu menubar:view","&Camera position");
@@ -40,5 +41,33 @@ Menu
         MenuItem { action: Cura.Actions.viewLeftSideCamera; }
         MenuItem { action: Cura.Actions.viewRightSideCamera; }
     }
+
+    MenuSeparator {
+        visible: UM.Preferences.getValue("cura/use_multi_build_plate")
+    }
+
+    Menu
+    {
+        id: buildPlateMenu;
+        title: catalog.i18nc("@action:inmenu menubar:view","&Build plate");
+        Instantiator
+        {
+            model: Cura.BuildPlateModel
+            MenuItem {
+                text: Cura.BuildPlateModel.getItem(index).name;
+                onTriggered: Cura.SceneController.setActiveBuildPlate(Cura.BuildPlateModel.getItem(index).buildPlateNumber);
+                checkable: true;
+                checked: Cura.BuildPlateModel.getItem(index).buildPlateNumber == Cura.BuildPlateModel.activeBuildPlate;
+                exclusiveGroup: buildPlateGroup;
+                visible: UM.Preferences.getValue("cura/use_multi_build_plate")
+            }
+            onObjectAdded: buildPlateMenu.insertItem(index, object);
+            onObjectRemoved: buildPlateMenu.removeItem(object)
+        }
+        ExclusiveGroup { id: buildPlateGroup; }
+    }
+
+    MenuSeparator {}
+
     MenuItem { action: Cura.Actions.expandSidebar; }
 }

resources/qml/ObjectsList.qml

@@ -0,0 +1,267 @@
+// Copyright (c) 2017 Ultimaker B.V.
+// Cura is released under the terms of the LGPLv3 or higher.
+
+import QtQuick 2.2
+import QtQuick.Controls 1.1
+import QtQuick.Controls.Styles 1.1
+import QtQuick.Layouts 1.1
+import QtQuick.Dialogs 1.1
+
+import UM 1.3 as UM
+import Cura 1.2 as Cura
+
+import "Menus"
+
+Rectangle
+{
+    id: base;
+
+    color: UM.Theme.getColor("tool_panel_background")
+
+    width: UM.Theme.getSize("objects_menu_size").width
+    height: {
+        if (collapsed) {
+            return UM.Theme.getSize("objects_menu_size_collapsed").height;
+        } else {
+            return UM.Theme.getSize("objects_menu_size").height;
+        }
+    }
+    Behavior on height { NumberAnimation { duration: 100 } }
+
+    border.width: UM.Theme.getSize("default_lining").width
+    border.color: UM.Theme.getColor("lining")
+
+    property bool collapsed: false;
+
+    SystemPalette { id: palette }
+
+    Button {
+        id: collapseButton
+        anchors.top: parent.top
+        anchors.topMargin: Math.floor(UM.Theme.getSize("default_margin").height + (UM.Theme.getSize("layerview_row").height - UM.Theme.getSize("default_margin").height) / 2)
+        anchors.right: parent.right
+        anchors.rightMargin: UM.Theme.getSize("default_margin").width
+
+        width: UM.Theme.getSize("standard_arrow").width
+        height: UM.Theme.getSize("standard_arrow").height
+
+        onClicked: collapsed = !collapsed
+
+        style: ButtonStyle
+        {
+            background: UM.RecolorImage
+            {
+                width: control.width
+                height: control.height
+                sourceSize.width: width
+                sourceSize.height: width
+                color:  UM.Theme.getColor("setting_control_text")
+                source: collapsed ? UM.Theme.getIcon("arrow_left") : UM.Theme.getIcon("arrow_bottom")
+            }
+            label: Label{ }
+        }
+    }
+
+    Component {
+        id: buildPlateDelegate
+        Rectangle
+            {
+                height: childrenRect.height
+                color: Cura.BuildPlateModel.getItem(index).buildPlateNumber == Cura.BuildPlateModel.activeBuildPlate ? palette.highlight : index % 2 ? palette.base : palette.alternateBase
+                width: parent.width
+                Label
+                {
+                    id: buildPlateNameLabel
+                    anchors.left: parent.left
+                    anchors.leftMargin: UM.Theme.getSize("default_margin").width
+                    width: parent.width - 2 * UM.Theme.getSize("default_margin").width - 30
+                    text: Cura.BuildPlateModel.getItem(index) ? Cura.BuildPlateModel.getItem(index).name : "";
+                    color: Cura.BuildPlateModel.activeBuildPlate == index ? palette.highlightedText : palette.text
+                    elide: Text.ElideRight
+                }
+
+                MouseArea
+                {
+                    anchors.fill: parent;
+                    onClicked:
+                    {
+                        Cura.SceneController.setActiveBuildPlate(index);
+                    }
+                }
+            }
+    }
+
+    ScrollView
+    {
+        id: buildPlateSelection
+        frameVisible: true
+        height: UM.Theme.getSize("build_plate_selection_size").height
+        width: parent.width - 2 * UM.Theme.getSize("default_margin").height
+        style: UM.Theme.styles.scrollview
+
+        anchors
+        {
+            top: collapseButton.bottom;
+            topMargin: UM.Theme.getSize("default_margin").height;
+            left: parent.left;
+            leftMargin: UM.Theme.getSize("default_margin").height;
+            //bottom: objectsList.top;
+            bottomMargin: UM.Theme.getSize("default_margin").height;
+        }
+
+        Rectangle
+        {
+            parent: viewport
+            anchors.fill: parent
+            color: palette.light
+        }
+
+        ListView
+        {
+            id: buildPlateListView
+            model: Cura.BuildPlateModel
+            width: parent.width
+            delegate: buildPlateDelegate
+        }
+    }
+
+
+    Component {
+        id: objectDelegate
+        Rectangle
+            {
+                height: childrenRect.height
+                color: Cura.ObjectsModel.getItem(index).isSelected ? palette.highlight : index % 2 ? palette.base : palette.alternateBase
+                width: parent.width
+                Label
+                {
+                    id: nodeNameLabel
+                    anchors.left: parent.left
+                    anchors.leftMargin: UM.Theme.getSize("default_margin").width
+                    width: parent.width - 2 * UM.Theme.getSize("default_margin").width - 30
+                    text: Cura.ObjectsModel.getItem(index) ? Cura.ObjectsModel.getItem(index).name : "";
+                    color: Cura.ObjectsModel.getItem(index).isSelected ? palette.highlightedText : (Cura.ObjectsModel.getItem(index).isOutsideBuildArea ? palette.mid : palette.text)
+                    elide: Text.ElideRight
+                }
+
+                Label
+                {
+                    id: buildPlateNumberLabel
+                    width: 20
+                    anchors.left: nodeNameLabel.right
+                    anchors.leftMargin: UM.Theme.getSize("default_margin").width
+                    anchors.right: parent.right
+                    text: Cura.ObjectsModel.getItem(index).buildPlateNumber != -1 ? Cura.ObjectsModel.getItem(index).buildPlateNumber + 1 : "";
+                    color: Cura.ObjectsModel.getItem(index).isSelected ? palette.highlightedText : palette.text
+                    elide: Text.ElideRight
+                }
+
+                MouseArea
+                {
+                    anchors.fill: parent;
+                    onClicked:
+                    {
+                        Cura.SceneController.changeSelection(index);
+                    }
+                }
+            }
+    }
+
+    // list all the scene nodes
+    ScrollView
+    {
+        id: objectsList
+        frameVisible: true
+        visible: !collapsed
+        width: parent.width - 2 * UM.Theme.getSize("default_margin").height
+
+        anchors
+        {
+            top: buildPlateSelection.bottom;
+            topMargin: UM.Theme.getSize("default_margin").height;
+            left: parent.left;
+            leftMargin: UM.Theme.getSize("default_margin").height;
+            bottom: filterBuildPlateCheckbox.top;
+            bottomMargin: UM.Theme.getSize("default_margin").height;
+        }
+
+        Rectangle
+        {
+            parent: viewport
+            anchors.fill: parent
+            color: palette.light
+        }
+
+        ListView
+        {
+            id: listview
+            model: Cura.ObjectsModel
+            width: parent.width
+            delegate: objectDelegate
+        }
+    }
+
+
+    CheckBox
+    {
+        id: filterBuildPlateCheckbox
+        visible: !collapsed
+        checked: UM.Preferences.getValue("view/filter_current_build_plate")
+        onClicked: UM.Preferences.setValue("view/filter_current_build_plate", checked)
+
+        text: catalog.i18nc("@option:check","See only current build plate");
+        style: UM.Theme.styles.checkbox;
+
+        anchors
+        {
+            left: parent.left;
+            topMargin: UM.Theme.getSize("default_margin").height;
+            bottomMargin: UM.Theme.getSize("default_margin").height;
+            leftMargin: UM.Theme.getSize("default_margin").height;
+            bottom: arrangeAllBuildPlatesButton.top;
+        }
+    }
+
+    Button
+    {
+        id: arrangeAllBuildPlatesButton;
+        text: catalog.i18nc("@action:button","Arrange to all build plates");
+        style: UM.Theme.styles.sidebar_action_button
+        height: UM.Theme.getSize("objects_menu_button").height;
+        tooltip: '';
+        anchors
+        {
+            //top: buildPlateSelection.bottom;
+            topMargin: UM.Theme.getSize("default_margin").height;
+            left: parent.left;
+            leftMargin: UM.Theme.getSize("default_margin").height;
+            right: parent.right;
+            rightMargin: UM.Theme.getSize("default_margin").height;
+            bottom: arrangeBuildPlateButton.top;
+            bottomMargin: UM.Theme.getSize("default_margin").height;
+        }
+        action: Cura.Actions.arrangeAllBuildPlates;
+    }
+
+    Button
+    {
+        id: arrangeBuildPlateButton;
+        text: catalog.i18nc("@action:button","Arrange current build plate");
+        style: UM.Theme.styles.sidebar_action_button
+        height: UM.Theme.getSize("objects_menu_button").height;
+        tooltip: '';
+        anchors
+        {
+            topMargin: UM.Theme.getSize("default_margin").height;
+            left: parent.left;
+            leftMargin: UM.Theme.getSize("default_margin").height;
+            right: parent.right;
+            rightMargin: UM.Theme.getSize("default_margin").height;
+            bottom: parent.bottom;
+            bottomMargin: UM.Theme.getSize("default_margin").height;
+        }
+        action: Cura.Actions.arrangeAll;
+    }
+
+
+}

resources/qml/Preferences/GeneralPage.qml

@@ -306,7 +306,7 @@ UM.PreferencesPage
                     text: catalog.i18nc("@option:check","Slice automatically");
                 }
             }
-            
+
             Item
             {
                 //: Spacer
@@ -453,6 +453,34 @@ UM.PreferencesPage
                 text: catalog.i18nc("@label","Opening and saving files")
             }
 
+            UM.TooltipArea {
+                width: childrenRect.width
+                height: childrenRect.height
+                text: catalog.i18nc("@info:tooltip","Use multi build plate functionality (EXPERIMENTAL)")
+
+                CheckBox
+                {
+                    id: useMultiBuildPlateCheckbox
+                    text: catalog.i18nc("@option:check","Use multi build plate functionality (EXPERIMENTAL, restart)")
+                    checked: boolCheck(UM.Preferences.getValue("cura/use_multi_build_plate"))
+                    onCheckedChanged: UM.Preferences.setValue("cura/use_multi_build_plate", checked)
+                }
+            }
+
+            UM.TooltipArea {
+                width: childrenRect.width
+                height: childrenRect.height
+                text: catalog.i18nc("@info:tooltip","Should newly loaded models be arranged on the build plate? Used in conjunction with multi build plate (EXPERIMENTAL)")
+
+                CheckBox
+                {
+                    id: arrangeOnLoadCheckbox
+                    text: catalog.i18nc("@option:check","Arrange objects on load (EXPERIMENTAL)")
+                    checked: boolCheck(UM.Preferences.getValue("cura/arrange_objects_on_load"))
+                    onCheckedChanged: UM.Preferences.setValue("cura/arrange_objects_on_load", checked)
+                }
+            }
+
             UM.TooltipArea {
                 width: childrenRect.width
                 height: childrenRect.height

resources/themes/cura-light/theme.json

@@ -391,6 +391,11 @@
 
         "infill_button_margin": [0.5, 0.5],
 
-        "jobspecs_line": [2.0, 2.0]
+        "jobspecs_line": [2.0, 2.0],
+
+        "objects_menu_size": [20, 40],
+        "objects_menu_size_collapsed": [20, 17],
+        "build_plate_selection_size": [15, 5],
+        "objects_menu_button": [0.3, 2.7]
     }
 }

tests/TestArrange.py

@@ -1,9 +1,7 @@
-import pytest
 import numpy
-import time
 
-from cura.Arrange import Arrange
+from cura.Arranging.Arrange import Arrange
-from cura.ShapeArray import ShapeArray
+from cura.Arranging.ShapeArray import ShapeArray
 
 
 def gimmeShapeArray():