Cura/util/objectScene.py

   1 import random
   2 import numpy
   3
   4 class _objectOrder(object):
   5         def __init__(self, order, todo):
   6                 self.order = order
   7                 self.todo = todo
   8
   9 class _objectOrderFinder(object):
  10         def __init__(self, scene, offset, leftToRight, frontToBack, gantryHeight):
  11                 self._scene = scene
  12                 self._offset = offset - numpy.array([0.1,0.1])
  13                 self._objs = scene.objects()
  14                 self._leftToRight = leftToRight
  15                 self._frontToBack = frontToBack
  16                 initialList = []
  17                 for n in xrange(0, len(self._objs)):
  18                         if scene.checkPlatform(self._objs[n]):
  19                                 initialList.append(n)
  20                 for n in initialList:
  21                         if self._objs[n].getSize()[2] > gantryHeight and len(initialList) > 1:
  22                                 self.order = None
  23                                 return
  24                 if len(initialList) == 0:
  25                         self.order = []
  26                         return
  27
  28
  29                 self._hitMap = [None] * (max(initialList)+1)
  30                 for a in initialList:
  31                         self._hitMap[a] = [False] * (max(initialList)+1)
  32                         for b in initialList:
  33                                 self._hitMap[a][b] = self._checkHit(a, b)
  34
  35                 initialList.sort(self._objIdxCmp)
  36
  37                 n = 0
  38                 self._todo = [_objectOrder([], initialList)]
  39                 while len(self._todo) > 0:
  40                         n += 1
  41                         current = self._todo.pop()
  42                         #print len(self._todo), len(current.order), len(initialList), current.order
  43                         for addIdx in current.todo:
  44                                 if not self._checkHitFor(addIdx, current.order) and not self._checkBlocks(addIdx, current.todo):
  45                                         todoList = current.todo[:]
  46                                         todoList.remove(addIdx)
  47                                         order = current.order[:] + [addIdx]
  48                                         if len(todoList) == 0:
  49                                                 self._todo = None
  50                                                 self.order = order
  51                                                 return
  52                                         self._todo.append(_objectOrder(order, todoList))
  53                 self.order = None
  54
  55         def _objIdxCmp(self, a, b):
  56                 scoreA = sum(self._hitMap[a])
  57                 scoreB = sum(self._hitMap[b])
  58                 return scoreA - scoreB
  59
  60         def _checkHitFor(self, addIdx, others):
  61                 for idx in others:
  62                         if self._hitMap[addIdx][idx]:
  63                                 return True
  64                 return False
  65
  66         def _checkBlocks(self, addIdx, others):
  67                 for idx in others:
  68                         if addIdx != idx and self._hitMap[idx][addIdx]:
  69                                 return True
  70                 return False
  71
  72         def _checkHit(self, addIdx, idx):
  73                 addPos = self._scene._objectList[addIdx].getPosition()
  74                 addSize = self._scene._objectList[addIdx].getSize()
  75                 pos = self._scene._objectList[idx].getPosition()
  76                 size = self._scene._objectList[idx].getSize()
  77
  78                 if self._leftToRight:
  79                         if addPos[0] - addSize[0] / 2 - self._offset[0] <= pos[0] + size[0] / 2:
  80                                 return False
  81                 else:
  82                         if addPos[0] + addSize[0] / 2 + self._offset[0] <= pos[0] - size[0] / 2:
  83                                 return False
  84
  85                 if self._frontToBack:
  86                         if addPos[1] - addSize[1] / 2 - self._offset[1] >= pos[1] + size[1] / 2:
  87                                 return False
  88                 else:
  89                         if addPos[1] + addSize[1] / 2 + self._offset[1] >= pos[1] - size[1] / 2:
  90                                 return False
  91
  92                 return True
  93
  94 class Scene(object):
  95         def __init__(self):
  96                 self._objectList = []
  97                 self._sizeOffsets = numpy.array([0.0,0.0], numpy.float32)
  98                 self._machineSize = numpy.array([100,100,100], numpy.float32)
  99                 self._headOffsets = numpy.array([18.0,18.0], numpy.float32)
 100                 self._leftToRight = False
 101                 self._frontToBack = True
 102                 self._gantryHeight = 60
 103
 104         def setMachineSize(self, machineSize):
 105                 self._machineSize = machineSize
 106
 107         def setSizeOffsets(self, sizeOffsets):
 108                 self._sizeOffsets = sizeOffsets
 109
 110         def setHeadSize(self, xMin, xMax, yMin, yMax, gantryHeight):
 111                 self._leftToRight = xMin < xMax
 112                 self._frontToBack = yMin < yMax
 113                 self._headOffsets[0] = min(xMin, xMax)
 114                 self._headOffsets[1] = min(yMin, yMax)
 115                 self._gantryHeight = gantryHeight
 116
 117         def getObjectExtend(self):
 118                 return self._sizeOffsets + self._headOffsets
 119
 120         def objects(self):
 121                 return self._objectList
 122
 123         def add(self, obj):
 124                 self._findFreePositionFor(obj)
 125                 self._objectList.append(obj)
 126                 self.pushFree()
 127
 128         def remove(self, obj):
 129                 self._objectList.remove(obj)
 130
 131         def merge(self, obj1, obj2):
 132                 self.remove(obj2)
 133                 obj1._meshList += obj2._meshList
 134                 obj1.processMatrix()
 135                 obj1.setPosition((obj1.getPosition() + obj2.getPosition()) / 2)
 136                 self.pushFree()
 137
 138         def pushFree(self):
 139                 n = 1000
 140                 while self._pushFree():
 141                         n -= 1
 142                         if n < 0:
 143                                 return
 144
 145         def arrangeAll(self):
 146                 oldList = self._objectList
 147                 self._objectList = []
 148                 for obj in oldList:
 149                         obj.setPosition(numpy.array([0,0], numpy.float32))
 150                         self.add(obj)
 151
 152         def centerAll(self):
 153                 minPos = numpy.array([9999999,9999999], numpy.float32)
 154                 maxPos = numpy.array([-9999999,-9999999], numpy.float32)
 155                 for obj in self._objectList:
 156                         pos = obj.getPosition()
 157                         size = obj.getSize()
 158                         minPos[0] = min(minPos[0], pos[0] - size[0] / 2)
 159                         minPos[1] = min(minPos[1], pos[1] - size[1] / 2)
 160                         maxPos[0] = max(maxPos[0], pos[0] + size[0] / 2)
 161                         maxPos[1] = max(maxPos[1], pos[1] + size[1] / 2)
 162                 offset = -(maxPos + minPos) / 2
 163                 for obj in self._objectList:
 164                         obj.setPosition(obj.getPosition() + offset)
 165
 166         def printOrder(self):
 167                 order = _objectOrderFinder(self, self._headOffsets + self._sizeOffsets, self._leftToRight, self._frontToBack, self._gantryHeight).order
 168                 if order is None:
 169                         print "ODD! Cannot find out proper printing order!!!"
 170                         for obj in self._objectList:
 171                                 print obj.getPosition(), obj.getSize()
 172                 return order
 173
 174         def _pushFree(self):
 175                 for a in self._objectList:
 176                         for b in self._objectList:
 177                                 if not self._checkHit(a, b):
 178                                         continue
 179                                 posDiff = a.getPosition() - b.getPosition()
 180                                 if posDiff[0] == 0.0 and posDiff[1] == 0.0:
 181                                         posDiff[1] = 1.0
 182                                 if abs(posDiff[0]) > abs(posDiff[1]):
 183                                         axis = 0
 184                                 else:
 185                                         axis = 1
 186                                 aPos = a.getPosition()
 187                                 bPos = b.getPosition()
 188                                 center = (aPos[axis] + bPos[axis]) / 2
 189                                 distance = (a.getSize()[axis] + b.getSize()[axis]) / 2 + 0.1 + self._sizeOffsets[axis] + self._headOffsets[axis]
 190                                 if posDiff[axis] < 0:
 191                                         distance = -distance
 192                                 aPos[axis] = center + distance / 2
 193                                 bPos[axis] = center - distance / 2
 194                                 a.setPosition(aPos)
 195                                 b.setPosition(bPos)
 196                                 return True
 197                 return False
 198
 199         def _checkHit(self, a, b):
 200                 if a == b:
 201                         return False
 202                 posDiff = a.getPosition() - b.getPosition()
 203                 if abs(posDiff[0]) < (a.getSize()[0] + b.getSize()[0]) / 2 + self._sizeOffsets[0] + self._headOffsets[0]:
 204                         if abs(posDiff[1]) < (a.getSize()[1] + b.getSize()[1]) / 2 + self._sizeOffsets[1] + self._headOffsets[1]:
 205                                 return True
 206                 return False
 207
 208         def checkPlatform(self, obj):
 209                 p = obj.getPosition()
 210                 s = obj.getSize()[0:2] / 2 + self._sizeOffsets
 211                 if p[0] - s[0] < -self._machineSize[0] / 2:
 212                         return False
 213                 if p[0] + s[0] > self._machineSize[0] / 2:
 214                         return False
 215                 if p[1] - s[1] < -self._machineSize[1] / 2:
 216                         return False
 217                 if p[1] + s[1] > self._machineSize[1] / 2:
 218                         return False
 219                 return True
 220
 221         def _findFreePositionFor(self, obj):
 222                 posList = []
 223                 for a in self._objectList:
 224                         p = a.getPosition()
 225                         s = (a.getSize()[0:2] + obj.getSize()[0:2]) / 2 + self._sizeOffsets + self._headOffsets
 226                         posList.append(p + s * ( 1.0, 1.0))
 227                         posList.append(p + s * ( 0.0, 1.0))
 228                         posList.append(p + s * (-1.0, 1.0))
 229                         posList.append(p + s * ( 1.0, 0.0))
 230                         posList.append(p + s * (-1.0, 0.0))
 231                         posList.append(p + s * ( 1.0,-1.0))
 232                         posList.append(p + s * ( 0.0,-1.0))
 233                         posList.append(p + s * (-1.0,-1.0))
 234
 235                 best = None
 236                 bestDist = None
 237                 for p in posList:
 238                         obj.setPosition(p)
 239                         ok = True
 240                         for a in self._objectList:
 241                                 if self._checkHit(a, obj):
 242                                         ok = False
 243                                         break
 244                         if not ok:
 245                                 continue
 246                         dist = numpy.linalg.norm(p)
 247                         if not self.checkPlatform(obj):
 248                                 dist *= 3
 249                         if best is None or dist < bestDist:
 250                                 best = p
 251                                 bestDist = dist
 252                 if best is not None:
 253                         obj.setPosition(best)