chiark / gitweb /
Fix typo
[cura.git] / Cura / util / objectScene.py
1 __copyright__ = "Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License"
2 import random
3 import numpy
4
5 from Cura.util import profile
6 from Cura.util import polygon
7
8 class _objectOrder(object):
9         def __init__(self, order, todo):
10                 self.order = order
11                 self.todo = todo
12
13 class _objectOrderFinder(object):
14         def __init__(self, scene, leftToRight, frontToBack, gantryHeight):
15                 self._scene = scene
16                 self._objs = scene.objects()
17                 self._leftToRight = leftToRight
18                 self._frontToBack = frontToBack
19                 initialList = []
20                 for n in xrange(0, len(self._objs)):
21                         if scene.checkPlatform(self._objs[n]):
22                                 initialList.append(n)
23                 for n in initialList:
24                         if self._objs[n].getSize()[2] > gantryHeight and len(initialList) > 1:
25                                 self.order = None
26                                 return
27                 if len(initialList) == 0:
28                         self.order = []
29                         return
30
31                 self._hitMap = [None] * (max(initialList)+1)
32                 for a in initialList:
33                         self._hitMap[a] = [False] * (max(initialList)+1)
34                         for b in initialList:
35                                 self._hitMap[a][b] = self._checkHit(a, b)
36
37                 #Check if we have 2 files that overlap so that they can never be printed one at a time.
38                 for a in initialList:
39                         for b in initialList:
40                                 if a != b and self._hitMap[a][b] and self._hitMap[b][a]:
41                                         self.order = None
42                                         return
43
44                 initialList.sort(self._objIdxCmp)
45
46                 n = 0
47                 self._todo = [_objectOrder([], initialList)]
48                 while len(self._todo) > 0:
49                         n += 1
50                         current = self._todo.pop()
51                         #print len(self._todo), len(current.order), len(initialList), current.order
52                         for addIdx in current.todo:
53                                 if not self._checkHitFor(addIdx, current.order) and not self._checkBlocks(addIdx, current.todo):
54                                         todoList = current.todo[:]
55                                         todoList.remove(addIdx)
56                                         order = current.order[:] + [addIdx]
57                                         if len(todoList) == 0:
58                                                 self._todo = None
59                                                 self.order = order
60                                                 return
61                                         self._todo.append(_objectOrder(order, todoList))
62                 self.order = None
63
64         def _objIdxCmp(self, a, b):
65                 scoreA = sum(self._hitMap[a])
66                 scoreB = sum(self._hitMap[b])
67                 return scoreA - scoreB
68
69         def _checkHitFor(self, addIdx, others):
70                 for idx in others:
71                         if self._hitMap[addIdx][idx]:
72                                 return True
73                 return False
74
75         def _checkBlocks(self, addIdx, others):
76                 for idx in others:
77                         if addIdx != idx and self._hitMap[idx][addIdx]:
78                                 return True
79                 return False
80
81         #Check if printing one object will cause printhead colission with other object.
82         def _checkHit(self, addIdx, idx):
83                 obj = self._scene._objectList[idx]
84                 addObj = self._scene._objectList[addIdx]
85                 return polygon.polygonCollision(obj._boundaryHull + obj.getPosition(), addObj._headAreaHull + addObj.getPosition())
86
87 class Scene(object):
88         def __init__(self):
89                 self._objectList = []
90                 self._sizeOffsets = numpy.array([0.0,0.0], numpy.float32)
91                 self._machineSize = numpy.array([100,100,100], numpy.float32)
92                 self._headSizeOffsets = numpy.array([18.0,18.0], numpy.float32)
93                 self._minExtruderCount = None
94                 self._extruderOffset = [numpy.array([0,0], numpy.float32)] * 4
95
96                 #Print order variables
97                 self._leftToRight = False
98                 self._frontToBack = True
99                 self._gantryHeight = 60
100                 self._oneAtATime = True
101
102         # update the physical machine dimensions
103         def updateMachineDimensions(self):
104                 self._machineSize = numpy.array([profile.getMachineSettingFloat('machine_width'), profile.getMachineSettingFloat('machine_depth'), profile.getMachineSettingFloat('machine_height')])
105                 self._machinePolygons = profile.getMachineSizePolygons()
106                 self.updateHeadSize()
107
108         # Size offsets are offsets caused by brim, skirt, etc.
109         def updateSizeOffsets(self, force=False):
110                 newOffsets = numpy.array(profile.calculateObjectSizeOffsets(), numpy.float32)
111                 minExtruderCount = profile.minimalExtruderCount()
112                 if not force and numpy.array_equal(self._sizeOffsets, newOffsets) and self._minExtruderCount == minExtruderCount:
113                         return
114                 self._sizeOffsets = newOffsets
115                 self._minExtruderCount = minExtruderCount
116
117                 extends = [numpy.array([[-newOffsets[0],-newOffsets[1]],[ newOffsets[0],-newOffsets[1]],[ newOffsets[0], newOffsets[1]],[-newOffsets[0], newOffsets[1]]], numpy.float32)]
118                 for n in xrange(1, 4):
119                         headOffset = numpy.array([[0, 0], [-profile.getMachineSettingFloat('extruder_offset_x%d' % (n)), -profile.getMachineSettingFloat('extruder_offset_y%d' % (n))]], numpy.float32)
120                         extends.append(polygon.minkowskiHull(extends[n-1], headOffset))
121                 if minExtruderCount > 1:
122                         extends[0] = extends[1]
123
124                 for obj in self._objectList:
125                         obj.setPrintAreaExtends(extends[len(obj._meshList) - 1])
126
127         #size of the printing head.
128         def updateHeadSize(self, obj = None):
129                 xMin = profile.getMachineSettingFloat('extruder_head_size_min_x')
130                 xMax = profile.getMachineSettingFloat('extruder_head_size_max_x')
131                 yMin = profile.getMachineSettingFloat('extruder_head_size_min_y')
132                 yMax = profile.getMachineSettingFloat('extruder_head_size_max_y')
133                 gantryHeight = profile.getMachineSettingFloat('extruder_head_size_height')
134
135                 self._leftToRight = xMin < xMax
136                 self._frontToBack = yMin < yMax
137                 self._headSizeOffsets[0] = min(xMin, xMax)
138                 self._headSizeOffsets[1] = min(yMin, yMax)
139                 self._gantryHeight = gantryHeight
140                 self._oneAtATime = self._gantryHeight > 0
141
142                 headArea = numpy.array([[-xMin,-yMin],[ xMax,-yMin],[ xMax, yMax],[-xMin, yMax]], numpy.float32)
143
144                 if obj is None:
145                         for obj in self._objectList:
146                                 obj.setHeadArea(headArea, self._headSizeOffsets)
147                 else:
148                         obj.setHeadArea(headArea, self._headSizeOffsets)
149
150         def setExtruderOffset(self, extruderNr, offsetX, offsetY):
151                 self._extruderOffset[extruderNr] = numpy.array([offsetX, offsetY], numpy.float32)
152
153         def objects(self):
154                 return self._objectList
155
156         #Add new object to print area
157         def add(self, obj):
158                 if numpy.max(obj.getSize()[0:2]) > numpy.max(self._machineSize[0:2]) * 2.5:
159                         scale = numpy.max(self._machineSize[0:2]) * 2.5 / numpy.max(obj.getSize()[0:2])
160                         matrix = [[scale,0,0], [0, scale, 0], [0, 0, scale]]
161                         obj.applyMatrix(numpy.matrix(matrix, numpy.float64))
162                 self._findFreePositionFor(obj)
163                 self._objectList.append(obj)
164                 self.updateHeadSize(obj)
165                 self.updateSizeOffsets(True)
166                 self.pushFree()
167
168         def remove(self, obj):
169                 self._objectList.remove(obj)
170
171         #Dual(multiple) extrusion merge
172         def merge(self, obj1, obj2):
173                 self.remove(obj2)
174                 obj1._meshList += obj2._meshList
175                 for m in obj2._meshList:
176                         m._obj = obj1
177                 obj1.processMatrix()
178                 obj1.setPosition((obj1.getPosition() + obj2.getPosition()) / 2)
179                 self.pushFree()
180
181         def pushFree(self):
182                 n = 10
183                 while self._pushFree():
184                         n -= 1
185                         if n < 0:
186                                 return
187
188         def arrangeAll(self):
189                 oldList = self._objectList
190                 self._objectList = []
191                 for obj in oldList:
192                         obj.setPosition(numpy.array([0,0], numpy.float32))
193                         self.add(obj)
194
195         def centerAll(self):
196                 minPos = numpy.array([9999999,9999999], numpy.float32)
197                 maxPos = numpy.array([-9999999,-9999999], numpy.float32)
198                 for obj in self._objectList:
199                         pos = obj.getPosition()
200                         size = obj.getSize()
201                         minPos[0] = min(minPos[0], pos[0] - size[0] / 2)
202                         minPos[1] = min(minPos[1], pos[1] - size[1] / 2)
203                         maxPos[0] = max(maxPos[0], pos[0] + size[0] / 2)
204                         maxPos[1] = max(maxPos[1], pos[1] + size[1] / 2)
205                 offset = -(maxPos + minPos) / 2
206                 for obj in self._objectList:
207                         obj.setPosition(obj.getPosition() + offset)
208
209         def printOrder(self):
210                 if self._oneAtATime:
211                         order = _objectOrderFinder(self, self._leftToRight, self._frontToBack, self._gantryHeight).order
212                 else:
213                         order = None
214                 return order
215
216         def _pushFree(self):
217                 for a in self._objectList:
218                         for b in self._objectList:
219                                 if a == b or not self.checkPlatform(a) or not self.checkPlatform(b):
220                                         continue
221                                 if self._oneAtATime:
222                                         v = polygon.polygonCollisionPushVector(a._headAreaMinHull + a.getPosition(), b._boundaryHull + b.getPosition())
223                                 else:
224                                         v = polygon.polygonCollisionPushVector(a._boundaryHull + a.getPosition(), b._boundaryHull + b.getPosition())
225                                 if type(v) is bool:
226                                         continue
227                                 a.setPosition(a.getPosition() + v * 0.4)
228                                 b.setPosition(b.getPosition() - v * 0.6)
229                                 return True
230                 return False
231
232         #Check if two objects are hitting each-other (+ head space).
233         def _checkHit(self, a, b):
234                 if a == b:
235                         return False
236                 if self._oneAtATime:
237                         return polygon.polygonCollision(a._headAreaMinHull + a.getPosition(), b._boundaryHull + b.getPosition())
238                 else:
239                         return polygon.polygonCollision(a._boundaryHull + a.getPosition(), b._boundaryHull + b.getPosition())
240
241         def checkPlatform(self, obj):
242                 area = obj._printAreaHull + obj.getPosition()
243                 if not polygon.fullInside(area, self._machinePolygons[0]):
244                         return False
245                 #Check the "no go zones"
246                 for poly in self._machinePolygons[1:]:
247                         if polygon.polygonCollision(poly, area):
248                                 return False
249                 return True
250
251         def _findFreePositionFor(self, obj):
252                 posList = []
253                 for a in self._objectList:
254                         p = a.getPosition()
255                         if self._oneAtATime:
256                                 s = (a.getSize()[0:2] + obj.getSize()[0:2]) / 2 + self._sizeOffsets + self._headSizeOffsets + numpy.array([3,3], numpy.float32)
257                         else:
258                                 s = (a.getSize()[0:2] + obj.getSize()[0:2]) / 2 + numpy.array([3,3], numpy.float32)
259                         posList.append(p + s * ( 1.0, 1.0))
260                         posList.append(p + s * ( 0.0, 1.0))
261                         posList.append(p + s * (-1.0, 1.0))
262                         posList.append(p + s * ( 1.0, 0.0))
263                         posList.append(p + s * (-1.0, 0.0))
264                         posList.append(p + s * ( 1.0,-1.0))
265                         posList.append(p + s * ( 0.0,-1.0))
266                         posList.append(p + s * (-1.0,-1.0))
267
268                 best = None
269                 bestDist = None
270                 for p in posList:
271                         obj.setPosition(p)
272                         ok = True
273                         for a in self._objectList:
274                                 if self._checkHit(a, obj):
275                                         ok = False
276                                         break
277                         if not ok:
278                                 continue
279                         dist = numpy.linalg.norm(p)
280                         if not self.checkPlatform(obj):
281                                 dist *= 3
282                         if best is None or dist < bestDist:
283                                 best = p
284                                 bestDist = dist
285                 if best is not None:
286                         obj.setPosition(best)