Cura/util/mesh.py

   1 from __future__ import absolute_import
   2
   3 import time
   4 import math
   5
   6 import numpy
   7 numpy.seterr(all='ignore')
   8
   9 from Cura.util import util3d
  10
  11 class printableObject(object):
  12         def __init__(self):
  13                 self._meshList = []
  14                 self._position = [0.0, 0.0]
  15                 self._matrix = numpy.matrix([[1,0,0],[0,1,0],[0,0,1]], numpy.float64)
  16                 self._transformedMin = None
  17                 self._transformedMax = None
  18                 self._boundaryCircleSize = None
  19
  20         def _addMesh(self):
  21                 m = mesh()
  22                 self._meshList.append(m)
  23                 return m
  24
  25         def _postProcessAfterLoad(self):
  26                 for m in self._meshList:
  27                         m._calculateNormals()
  28                 self.processMatrix()
  29
  30         def processMatrix(self):
  31                 self._transformedMin = numpy.array([999999999999,999999999999,999999999999], numpy.float64)
  32                 self._transformedMax = numpy.array([-999999999999,-999999999999,-999999999999], numpy.float64)
  33                 self._boundaryCircleSize = 0
  34
  35                 for m in self._meshList:
  36                         transformedVertexes = (numpy.matrix(m.vertexes, copy = False) * self._matrix).getA()
  37                         transformedMin = transformedVertexes.min(0)
  38                         transformedMax = transformedVertexes.max(0)
  39                         for n in xrange(0, 3):
  40                                 self._transformedMin[n] = min(transformedMin[n], self._transformedMin[n])
  41                                 self._transformedMax[n] = max(transformedMax[n], self._transformedMax[n])
  42
  43                         #Calculate the boundary circle
  44                         transformedSize = transformedMax - transformedMin
  45                         center = transformedMin + transformedSize / 2.0
  46                         boundaryCircleSize = round(math.sqrt(numpy.max(((transformedVertexes[::,0] - center[0]) * (transformedVertexes[::,0] - center[0])) + ((transformedVertexes[::,1] - center[1]) * (transformedVertexes[::,1] - center[1])) + ((transformedVertexes[::,2] - center[2]) * (transformedVertexes[::,2] - center[2])))), 3)
  47                         self._boundaryCircleSize = max(self._boundaryCircleSize, boundaryCircleSize)
  48                 self._transformedSize = self._transformedMax - self._transformedMin
  49
  50         def getMaximum(self):
  51                 return self._transformedMax
  52         def getMinimum(self):
  53                 return self._transformedMin
  54         def getSize(self):
  55                 return self._transformedSize
  56         def getBoundaryCircle(self):
  57                 return self._boundaryCircleSize
  58
  59 class mesh(object):
  60         def __init__(self):
  61                 self.vertexes = None
  62                 self.vertexCount = 0
  63                 self.vbo = None
  64
  65         def _addFace(self, x0, y0, z0, x1, y1, z1, x2, y2, z2):
  66                 n = self.vertexCount
  67                 self.vertexes[n][0] = x0
  68                 self.vertexes[n][1] = y0
  69                 self.vertexes[n][2] = z0
  70                 n += 1
  71                 self.vertexes[n][0] = x1
  72                 self.vertexes[n][1] = y1
  73                 self.vertexes[n][2] = z1
  74                 n += 1
  75                 self.vertexes[n][0] = x2
  76                 self.vertexes[n][1] = y2
  77                 self.vertexes[n][2] = z2
  78                 self.vertexCount += 3
  79
  80         def _prepareFaceCount(self, faceNumber):
  81                 #Set the amount of faces before loading data in them. This way we can create the numpy arrays before we fill them.
  82                 self.vertexes = numpy.zeros((faceNumber*3, 3), numpy.float32)
  83                 self.normal = numpy.zeros((faceNumber*3, 3), numpy.float32)
  84                 self.vertexCount = 0
  85
  86         def _calculateNormals(self):
  87                 #Calculate the normals
  88                 tris = self.vertexes.reshape(self.vertexCount / 3, 3, 3)
  89                 normals = numpy.cross( tris[::,1 ] - tris[::,0]  , tris[::,2 ] - tris[::,0] )
  90                 lens = numpy.sqrt( normals[:,0]**2 + normals[:,1]**2 + normals[:,2]**2 )
  91                 normals[:,0] /= lens
  92                 normals[:,1] /= lens
  93                 normals[:,2] /= lens
  94
  95                 n = numpy.zeros((self.vertexCount / 3, 9), numpy.float32)
  96                 n[:,0:3] = normals
  97                 n[:,3:6] = normals
  98                 n[:,6:9] = normals
  99                 self.normal = n.reshape(self.vertexCount, 3)
 100                 self.invNormal = -self.normal
 101
 102         def splitToParts(self, callback = None):
 103                 t0 = time.time()
 104
 105                 #print "%f: " % (time.time() - t0), "Splitting a model with %d vertexes." % (len(self.vertexes))
 106                 removeDict = {}
 107                 tree = util3d.AABBTree()
 108                 off = numpy.array([0.0001,0.0001,0.0001])
 109                 for idx in xrange(0, self.vertexCount):
 110                         v = self.vertexes[idx]
 111                         e = util3d.AABB(v-off, v+off)
 112                         q = tree.query(e)
 113                         if len(q) < 1:
 114                                 e.idx = idx
 115                                 tree.insert(e)
 116                         else:
 117                                 removeDict[idx] = q[0].idx
 118                         if callback is not None and (idx % 100) == 0:
 119                                 callback(idx)
 120                 #print "%f: " % (time.time() - t0), "Marked %d duplicate vertexes for removal." % (len(removeDict))
 121
 122                 faceList = []
 123                 for idx in xrange(0, self.vertexCount, 3):
 124                         f = [idx, idx + 1, idx + 2]
 125                         if removeDict.has_key(f[0]):
 126                                 f[0] = removeDict[f[0]]
 127                         if removeDict.has_key(f[1]):
 128                                 f[1] = removeDict[f[1]]
 129                         if removeDict.has_key(f[2]):
 130                                 f[2] = removeDict[f[2]]
 131                         faceList.append(f)
 132
 133                 #print "%f: " % (time.time() - t0), "Building face lists after vertex removal."
 134                 vertexFaceList = []
 135                 for idx in xrange(0, self.vertexCount):
 136                         vertexFaceList.append([])
 137                 for idx in xrange(0, len(faceList)):
 138                         f = faceList[idx]
 139                         vertexFaceList[f[0]].append(idx)
 140                         vertexFaceList[f[1]].append(idx)
 141                         vertexFaceList[f[2]].append(idx)
 142
 143                 #print "%f: " % (time.time() - t0), "Building parts."
 144                 self._vertexFaceList = vertexFaceList
 145                 self._faceList = faceList
 146                 partList = []
 147                 doneSet = set()
 148                 for idx in xrange(0, len(faceList)):
 149                         if not idx in doneSet:
 150                                 partList.append(self._createPartFromFacewalk(idx, doneSet))
 151                 #print "%f: " % (time.time() - t0), "Split into %d parts" % (len(partList))
 152                 self._vertexFaceList = None
 153                 self._faceList = None
 154                 return partList
 155
 156         def _createPartFromFacewalk(self, startFaceIdx, doneSet):
 157                 m = mesh()
 158                 m._prepareVertexCount(self.vertexCount)
 159                 todoList = [startFaceIdx]
 160                 doneSet.add(startFaceIdx)
 161                 while len(todoList) > 0:
 162                         faceIdx = todoList.pop()
 163                         self._partAddFacewalk(m, faceIdx, doneSet, todoList)
 164                 return m
 165
 166         def _partAddFacewalk(self, part, faceIdx, doneSet, todoList):
 167                 f = self._faceList[faceIdx]
 168                 v0 = self.vertexes[f[0]]
 169                 v1 = self.vertexes[f[1]]
 170                 v2 = self.vertexes[f[2]]
 171                 part.addVertex(v0[0], v0[1], v0[2])
 172                 part.addVertex(v1[0], v1[1], v1[2])
 173                 part.addVertex(v2[0], v2[1], v2[2])
 174                 for f1 in self._vertexFaceList[f[0]]:
 175                         if f1 not in doneSet:
 176                                 todoList.append(f1)
 177                                 doneSet.add(f1)
 178                 for f1 in self._vertexFaceList[f[1]]:
 179                         if f1 not in doneSet:
 180                                 todoList.append(f1)
 181                                 doneSet.add(f1)
 182                 for f1 in self._vertexFaceList[f[2]]:
 183                         if f1 not in doneSet:
 184                                 todoList.append(f1)
 185                                 doneSet.add(f1)