示例#1
0
def readGcode(fname):
    error = None
    fh = None
    try:
        fh = codecs.open(unicode(fname), "rU", 'UTF8')
        text = fh.readlines()
        linemax = len(text)
        printing = False
        lastZ = None
        kind = 'model'
        layerlist = list()
        lino = 18
        for line in text: #avoiding useless information
            if line.startswith('M10'):
            # M101 Turn extruder on forward
            # M103 Turn extruder off
            # M104 Temperature control
                if 'M101' in line: # When starts to extrude a new path is starting
                    printing = True
                    path = Path()
                    path.addVector(vec) # We are in the last point when starting to extrude
                elif 'M103' in line:
                    printing = False
                    try:
                        if kind == 'base':
                            layer.addBasePath(path) # Save path to its layer
                        if kind == 'support':
                            layer.addSupportPath(path) # Save path to its layer
                        if kind == 'model':
                            layer.addModelPath(path) # Save path to its layer
                    except:
                        pass
                elif 'M104' in line: # temperature hack
                    m, s = line.split(' ')
                    s = float(s[1:])
                    if s == 200: # base
                        kind = 'base'
                    elif s == 250: # support
                        kind = 'support'
                    elif s == 300: # model
                        kind = 'model'
                    elif s == 0: # end
                        break
            elif 'G1' in line:
            # G1 Coordinated Motion Implemented - supports X, Y, and Z axes.
                sline = line.split(' ')
                if len(sline) >= 4:
                    if len(sline) == 5:
                        g, x, y, z, f = line.split(' ') # Take all parameters splitting in spaces
                    elif len(sline) == 4:
                        g, x, y, z = line.split(' ') # Same when no SPEED is active
                    x = float(x[1:]) # Avoids the character X, and return a float
                    y = float(y[1:]) # Avoids the character Y, and return a float
                    z = float(z[1:]) # Avoids the character Z, and return a float
                    vec = Vector3(x, y, z) # Creates a vector
                    if printing: # if extruding, adds a vector
                        path.addVector(vec)
                    if not z == lastZ: # Z change = layer change
                        lastZ = z
                        try:
                            layerlist.append(layer)
                        except: # Layer no exists at first execution
                            pass
                        layer = Layer()
            lino += 1
            if lino == linemax:
                layerlist = layerList.append(layer)
            line = fh.readline()
    except (IOError, OSError, ValueError), e:
        error = "Failed to load: %s on line %d" % (e, lino)
        print error
示例#2
0
 def SliceCustom2(self, toolDict, onlycontour = False): ######################################################
     logger.log('Custom slice starting...')
     
     # Get model and apply transformations done
     matrix = vtk.vtkMatrix4x4() 
     self.getActor().GetMatrix(matrix)
     transform = vtk.vtkTransform()
     transform.SetMatrix(matrix)
     t_filter = vtk.vtkTransformPolyDataFilter()
     t_filter.SetInput(self.getPolyData())
     t_filter.SetTransform(transform)
     t_filter.Update()
     vtkmesh = t_filter.GetOutput()
     
     # Get path height and path width
     tool = toolDict[str(self.getModelMaterial())]
     h = float(tool.pathHeight)
     w = float(tool.pathWidth)
     
     # Slice and get polygons of each layer
     layerspoly, zs = slicevtk(vtkmesh, h)
     assert len(layerspoly) == len(zs)
     self.layerValues = zs
     
     # Start gathering points
     deg = 45
     layerList = list()
     total = len(layerspoly)
     for i in range(total):
         print 'processing layer %s/%s' % (i+1, total)
         # Get polygons of each layer
         polygons = layerspoly[i]
         # Get current layer z
         z = zs[i]
         # Create layer
         layer = Layer()
         for polygon in polygons:
             # Extract contours
             #### Exterior
             contour = polygon.exterior.xy
             xs = contour[0]
             ys = contour[1]
             for a in range(len(xs)):
                 if a == 0:
                     path = Path()
                 vec = Vec([xs[a], ys[a], z])
                 path.addVector(vec)
                 if a == len(xs)-1:
                         layer.addModelPath(path)
                         
             #### Interiors = Holes
             interiors = polygon.interiors
             for interior in interiors:
                 xs = interior.xy[0]
                 ys = interior.xy[1]
                 for a in range(len(xs)):
                     if a == 0:
                         path = Path()
                     vec = Vec([xs[a], ys[a], z])
                     path.addVector(vec)
                     if a == len(xs)-1:
                             layer.addModelPath(path)
             
             # Calculate filling paths
             allx,ally = fill2(polygon, w, deg)
             for j in range(len(allx)):
                 # Take each path points
                 xs = allx[j]
                 ys = ally[j]
                 for k in range(len(xs)):
                     # Add points to path
                     if k == 0:
                         path = Path()
                     vec = Vec([xs[k], ys[k], z])
                     path.addVector(vec)
                     if k == len(xs)-1:
                         layer.addModelPath(path)
         layerList.append(layer)
         deg = -deg
         
     # Generate actors for paths
     self.setLayers(layerList)
     self.generatePaths(layerList)