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.setHeadSize(profile.getMachineSettingFloat('extruder_head_size_min_x'), profile.getMachineSettingFloat('extruder_head_size_max_x'), profile.getMachineSettingFloat('extruder_head_size_min_y'), profile.getMachineSettingFloat('extruder_head_size_max_y'), profile.getMachineSettingFloat('extruder_head_size_height'))
 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 setHeadSize(self, xMin, xMax, yMin, yMax, gantryHeight):
 129                 self._leftToRight = xMin < xMax
 130                 self._frontToBack = yMin < yMax
 131                 self._headSizeOffsets[0] = min(xMin, xMax)
 132                 self._headSizeOffsets[1] = min(yMin, yMax)
 133                 self._gantryHeight = gantryHeight
 134                 self._oneAtATime = self._gantryHeight > 0
 135
 136                 headArea = numpy.array([[-xMin,-yMin],[ xMax,-yMin],[ xMax, yMax],[-xMin, yMax]], numpy.float32)
 137
 138                 for obj in self._objectList:
 139                         obj.setHeadArea(headArea, self._headSizeOffsets)
 140
 141         def setExtruderOffset(self, extruderNr, offsetX, offsetY):
 142                 self._extruderOffset[extruderNr] = numpy.array([offsetX, offsetY], numpy.float32)
 143
 144         def objects(self):
 145                 return self._objectList
 146
 147         #Add new object to print area
 148         def add(self, obj):
 149                 if numpy.max(obj.getSize()[0:2]) > numpy.max(self._machineSize[0:2]) * 2.5:
 150                         scale = numpy.max(self._machineSize[0:2]) * 2.5 / numpy.max(obj.getSize()[0:2])
 151                         matrix = [[scale,0,0], [0, scale, 0], [0, 0, scale]]
 152                         obj.applyMatrix(numpy.matrix(matrix, numpy.float64))
 153                 self._findFreePositionFor(obj)
 154                 self._objectList.append(obj)
 155                 self.updateSizeOffsets(True)
 156                 self.pushFree()
 157
 158         def remove(self, obj):
 159                 self._objectList.remove(obj)
 160
 161         #Dual(multiple) extrusion merge
 162         def merge(self, obj1, obj2):
 163                 self.remove(obj2)
 164                 obj1._meshList += obj2._meshList
 165                 for m in obj2._meshList:
 166                         m._obj = obj1
 167                 obj1.processMatrix()
 168                 obj1.setPosition((obj1.getPosition() + obj2.getPosition()) / 2)
 169                 self.pushFree()
 170
 171         def pushFree(self):
 172                 n = 10
 173                 while self._pushFree():
 174                         n -= 1
 175                         if n < 0:
 176                                 return
 177
 178         def arrangeAll(self):
 179                 oldList = self._objectList
 180                 self._objectList = []
 181                 for obj in oldList:
 182                         obj.setPosition(numpy.array([0,0], numpy.float32))
 183                         self.add(obj)
 184
 185         def centerAll(self):
 186                 minPos = numpy.array([9999999,9999999], numpy.float32)
 187                 maxPos = numpy.array([-9999999,-9999999], numpy.float32)
 188                 for obj in self._objectList:
 189                         pos = obj.getPosition()
 190                         size = obj.getSize()
 191                         minPos[0] = min(minPos[0], pos[0] - size[0] / 2)
 192                         minPos[1] = min(minPos[1], pos[1] - size[1] / 2)
 193                         maxPos[0] = max(maxPos[0], pos[0] + size[0] / 2)
 194                         maxPos[1] = max(maxPos[1], pos[1] + size[1] / 2)
 195                 offset = -(maxPos + minPos) / 2
 196                 for obj in self._objectList:
 197                         obj.setPosition(obj.getPosition() + offset)
 198
 199         def printOrder(self):
 200                 if self._oneAtATime:
 201                         order = _objectOrderFinder(self, self._leftToRight, self._frontToBack, self._gantryHeight).order
 202                 else:
 203                         order = None
 204                 return order
 205
 206         def _pushFree(self):
 207                 for a in self._objectList:
 208                         for b in self._objectList:
 209                                 if a == b or not self.checkPlatform(a) or not self.checkPlatform(b):
 210                                         continue
 211                                 if self._oneAtATime:
 212                                         v = polygon.polygonCollisionPushVector(a._headAreaMinHull + a.getPosition(), b._boundaryHull + b.getPosition())
 213                                 else:
 214                                         v = polygon.polygonCollisionPushVector(a._boundaryHull + a.getPosition(), b._boundaryHull + b.getPosition())
 215                                 if type(v) is bool:
 216                                         continue
 217                                 a.setPosition(a.getPosition() + v * 0.4)
 218                                 b.setPosition(b.getPosition() - v * 0.6)
 219                                 return True
 220                 return False
 221
 222         #Check if two objects are hitting each-other (+ head space).
 223         def _checkHit(self, a, b):
 224                 if a == b:
 225                         return False
 226                 if self._oneAtATime:
 227                         return polygon.polygonCollision(a._headAreaMinHull + a.getPosition(), b._boundaryHull + b.getPosition())
 228                 else:
 229                         return polygon.polygonCollision(a._boundaryHull + a.getPosition(), b._boundaryHull + b.getPosition())
 230
 231         def checkPlatform(self, obj):
 232                 area = obj._printAreaHull + obj.getPosition()
 233                 if not polygon.fullInside(area, self._machinePolygons[0]):
 234                         return False
 235                 #Check the "no go zones"
 236                 for poly in self._machinePolygons[1:]:
 237                         if polygon.polygonCollision(poly, area):
 238                                 return False
 239                 return True
 240
 241         def _findFreePositionFor(self, obj):
 242                 posList = []
 243                 for a in self._objectList:
 244                         p = a.getPosition()
 245                         if self._oneAtATime:
 246                                 s = (a.getSize()[0:2] + obj.getSize()[0:2]) / 2 + self._sizeOffsets + self._headSizeOffsets + numpy.array([3,3], numpy.float32)
 247                         else:
 248                                 s = (a.getSize()[0:2] + obj.getSize()[0:2]) / 2 + numpy.array([3,3], numpy.float32)
 249                         posList.append(p + s * ( 1.0, 1.0))
 250                         posList.append(p + s * ( 0.0, 1.0))
 251                         posList.append(p + s * (-1.0, 1.0))
 252                         posList.append(p + s * ( 1.0, 0.0))
 253                         posList.append(p + s * (-1.0, 0.0))
 254                         posList.append(p + s * ( 1.0,-1.0))
 255                         posList.append(p + s * ( 0.0,-1.0))
 256                         posList.append(p + s * (-1.0,-1.0))
 257
 258                 best = None
 259                 bestDist = None
 260                 for p in posList:
 261                         obj.setPosition(p)
 262                         ok = True
 263                         for a in self._objectList:
 264                                 if self._checkHit(a, obj):
 265                                         ok = False
 266                                         break
 267                         if not ok:
 268                                 continue
 269                         dist = numpy.linalg.norm(p)
 270                         if not self.checkPlatform(obj):
 271                                 dist *= 3
 272                         if best is None or dist < bestDist:
 273                                 best = p
 274                                 bestDist = dist
 275                 if best is not None:
 276                         obj.setPosition(best)