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                 self._drawOffset = (self._transformedMax + self._transformedMin) / 2
  50                 self._drawOffset[2] = self._transformedMin[2]
  51                 self._transformedMax -= self._drawOffset
  52                 self._transformedMin -= self._drawOffset
  53
  54         def getMaximum(self):
  55                 return self._transformedMax
  56         def getMinimum(self):
  57                 return self._transformedMin
  58         def getSize(self):
  59                 return self._transformedSize
  60         def getDrawOffset(self):
  61                 return self._drawOffset
  62         def getBoundaryCircle(self):
  63                 return self._boundaryCircleSize
  64
  65 class mesh(object):
  66         def __init__(self):
  67                 self.vertexes = None
  68                 self.vertexCount = 0
  69                 self.vbo = None
  70
  71         def _addFace(self, x0, y0, z0, x1, y1, z1, x2, y2, z2):
  72                 n = self.vertexCount
  73                 self.vertexes[n][0] = x0
  74                 self.vertexes[n][1] = y0
  75                 self.vertexes[n][2] = z0
  76                 n += 1
  77                 self.vertexes[n][0] = x1
  78                 self.vertexes[n][1] = y1
  79                 self.vertexes[n][2] = z1
  80                 n += 1
  81                 self.vertexes[n][0] = x2
  82                 self.vertexes[n][1] = y2
  83                 self.vertexes[n][2] = z2
  84                 self.vertexCount += 3
  85
  86         def _prepareFaceCount(self, faceNumber):
  87                 #Set the amount of faces before loading data in them. This way we can create the numpy arrays before we fill them.
  88                 self.vertexes = numpy.zeros((faceNumber*3, 3), numpy.float32)
  89                 self.normal = numpy.zeros((faceNumber*3, 3), numpy.float32)
  90                 self.vertexCount = 0
  91
  92         def _calculateNormals(self):
  93                 #Calculate the normals
  94                 tris = self.vertexes.reshape(self.vertexCount / 3, 3, 3)
  95                 normals = numpy.cross( tris[::,1 ] - tris[::,0]  , tris[::,2 ] - tris[::,0] )
  96                 lens = numpy.sqrt( normals[:,0]**2 + normals[:,1]**2 + normals[:,2]**2 )
  97                 normals[:,0] /= lens
  98                 normals[:,1] /= lens
  99                 normals[:,2] /= lens
 100
 101                 n = numpy.zeros((self.vertexCount / 3, 9), numpy.float32)
 102                 n[:,0:3] = normals
 103                 n[:,3:6] = normals
 104                 n[:,6:9] = normals
 105                 self.normal = n.reshape(self.vertexCount, 3)
 106                 self.invNormal = -self.normal
 107
 108         def splitToParts(self, callback = None):
 109                 t0 = time.time()
 110
 111                 #print "%f: " % (time.time() - t0), "Splitting a model with %d vertexes." % (len(self.vertexes))
 112                 removeDict = {}
 113                 tree = util3d.AABBTree()
 114                 off = numpy.array([0.0001,0.0001,0.0001])
 115                 for idx in xrange(0, self.vertexCount):
 116                         v = self.vertexes[idx]
 117                         e = util3d.AABB(v-off, v+off)
 118                         q = tree.query(e)
 119                         if len(q) < 1:
 120                                 e.idx = idx
 121                                 tree.insert(e)
 122                         else:
 123                                 removeDict[idx] = q[0].idx
 124                         if callback is not None and (idx % 100) == 0:
 125                                 callback(idx)
 126                 #print "%f: " % (time.time() - t0), "Marked %d duplicate vertexes for removal." % (len(removeDict))
 127
 128                 faceList = []
 129                 for idx in xrange(0, self.vertexCount, 3):
 130                         f = [idx, idx + 1, idx + 2]
 131                         if removeDict.has_key(f[0]):
 132                                 f[0] = removeDict[f[0]]
 133                         if removeDict.has_key(f[1]):
 134                                 f[1] = removeDict[f[1]]
 135                         if removeDict.has_key(f[2]):
 136                                 f[2] = removeDict[f[2]]
 137                         faceList.append(f)
 138
 139                 #print "%f: " % (time.time() - t0), "Building face lists after vertex removal."
 140                 vertexFaceList = []
 141                 for idx in xrange(0, self.vertexCount):
 142                         vertexFaceList.append([])
 143                 for idx in xrange(0, len(faceList)):
 144                         f = faceList[idx]
 145                         vertexFaceList[f[0]].append(idx)
 146                         vertexFaceList[f[1]].append(idx)
 147                         vertexFaceList[f[2]].append(idx)
 148
 149                 #print "%f: " % (time.time() - t0), "Building parts."
 150                 self._vertexFaceList = vertexFaceList
 151                 self._faceList = faceList
 152                 partList = []
 153                 doneSet = set()
 154                 for idx in xrange(0, len(faceList)):
 155                         if not idx in doneSet:
 156                                 partList.append(self._createPartFromFacewalk(idx, doneSet))
 157                 #print "%f: " % (time.time() - t0), "Split into %d parts" % (len(partList))
 158                 self._vertexFaceList = None
 159                 self._faceList = None
 160                 return partList
 161
 162         def _createPartFromFacewalk(self, startFaceIdx, doneSet):
 163                 m = mesh()
 164                 m._prepareVertexCount(self.vertexCount)
 165                 todoList = [startFaceIdx]
 166                 doneSet.add(startFaceIdx)
 167                 while len(todoList) > 0:
 168                         faceIdx = todoList.pop()
 169                         self._partAddFacewalk(m, faceIdx, doneSet, todoList)
 170                 return m
 171
 172         def _partAddFacewalk(self, part, faceIdx, doneSet, todoList):
 173                 f = self._faceList[faceIdx]
 174                 v0 = self.vertexes[f[0]]
 175                 v1 = self.vertexes[f[1]]
 176                 v2 = self.vertexes[f[2]]
 177                 part.addVertex(v0[0], v0[1], v0[2])
 178                 part.addVertex(v1[0], v1[1], v1[2])
 179                 part.addVertex(v2[0], v2[1], v2[2])
 180                 for f1 in self._vertexFaceList[f[0]]:
 181                         if f1 not in doneSet:
 182                                 todoList.append(f1)
 183                                 doneSet.add(f1)
 184                 for f1 in self._vertexFaceList[f[1]]:
 185                         if f1 not in doneSet:
 186                                 todoList.append(f1)
 187                                 doneSet.add(f1)
 188                 for f1 in self._vertexFaceList[f[2]]:
 189                         if f1 not in doneSet:
 190                                 todoList.append(f1)
 191                                 doneSet.add(f1)