Source Code for Module plugins.preface

  1  """ 
  2  Preface creates the nested ring structure from the rotated layers, and adds optional start and end gcodes. 
  3   
  4  Credits: 
  5          Original Author: Enrique Perez (http://skeinforge.com) 
  6          Contributors: Please see the documentation in Skeinforge  
  7          Modifed as SFACT: Ahmet Cem Turan (github.com/ahmetcemturan/SFACT)       
  8   
  9  License:  
 10          GNU Affero General Public License http://www.gnu.org/licenses/agpl.html 
 11  """ 
 12   
 13  from config import config 
 14  from entities import NestedRing, GcodeCommand, Layer, BoundaryPerimeter 
 15  from fabmetheus_utilities import euclidean, archive 
 16  from time import strftime 
 17  import gcodes 
 18  import logging 
 19  import os 
 20   
 21  name = __name__ 
 22  logger = logging.getLogger(name) 
 23   
 24 -def performAction(slicedModel): 
 25          "Preface and converts the layers." 
 26          PrefaceSkein(slicedModel).preface() 
 27   
 28 -class PrefaceSkein: 
 29          "A class to preface a skein of extrusions." 
 30 -        def __init__(self, slicedModel): 
 31                  self.slicedModel = slicedModel 
 32                  self.setPositioningToAbsolute = config.getboolean(name, 'positioning.absolute') 
 33                  self.setUnitsToMillimeters = config.getboolean(name, 'units.millimeters') 
 34                  self.startAtHome = config.getboolean(name, 'startup.at.home') 
 35                  self.resetExtruder = config.getboolean(name, 'startup.extruder.reset') 
 36                  self.endFile = config.get(name, 'end.file') 
 37                  self.startFile = config.get(name, 'start.file') 
 38                   
 39 -        def preface(self): 
 40                  "Prefaces and converts the svg text to Gcode." 
 41                   
 42                  self.addStartCommandsToGcode() 
 43                   
 44                  for (index, rotatedLoopLayer) in enumerate(self.slicedModel.rotatedLoopLayers): 
 45                          self.addPrefaceToGcode(index, rotatedLoopLayer) 
 46                   
 47                  self.addEndCommandsToGcode()             
 48           
 49           
 50 -        def addPrefaceToGcode(self, index, rotatedLoopLayer): 
 51                  decimalPlaces = self.slicedModel.runtimeParameters.decimalPlaces 
 52                  z = round(rotatedLoopLayer.z, 3) 
 53                  layer = Layer(z, index, self.slicedModel.runtimeParameters)              
 54                   
 55                  if rotatedLoopLayer.rotation != None: 
 56                          layer.bridgeRotation = complex(rotatedLoopLayer.rotation) 
 57                   
 58                  loops = rotatedLoopLayer.loops 
 59                  internalLoops = self.createLoopHierarchy(loops) 
 60                   
 61                  nestRingPlaceholder = {} 
 62                  for loop in loops: 
 63                          nestedRing = NestedRing(z, self.slicedModel.runtimeParameters) 
 64                          nestedRing.setBoundaryPerimeter(loop) 
 65                          nestRingPlaceholder[str(loop)] = nestedRing  
 66                   
 67                  for internalLoop in internalLoops: 
 68                          parent = internalLoops[internalLoop] 
 69                          child = loops[internalLoop] 
 70                          childNestedRing = nestRingPlaceholder[str(loops[internalLoop])] 
 71                           
 72                          if parent == None: 
 73                                  layer.addNestedRing(childNestedRing) 
 74                          else: 
 75                                  parentNestedRing = nestRingPlaceholder[str(internalLoops[internalLoop])] 
 76                                  parentNestedRing.innerNestedRings.append(childNestedRing) 
 77                                    
 78                  self.slicedModel.layers[z] = layer 
 79   
 80 -        def createLoopHierarchy(self, loops): 
 81                  internalLoops = {} 
 82                   
 83                  for (loopIndex, loop) in enumerate(loops): 
 84                          internalLoops[loopIndex] = [] 
 85                          otherLoops = [] 
 86                          for beforeIndex in xrange(loopIndex): 
 87                                  otherLoops.append(loops[beforeIndex]) 
 88                          for afterIndex in xrange(loopIndex + 1, len(loops)): 
 89                                  otherLoops.append(loops[afterIndex]) 
 90                          internalLoops[loopIndex] = euclidean.getClosestEnclosingLoop(otherLoops, loop) 
 91                  return internalLoops 
 92           
 93 -        def addStartCommandsToGcode(self):               
 94                  if config.get(name, 'start.file') != None: 
 95                          for line in archive.getLinesFromAlterationsFile(self.startFile): 
 96                                  self.slicedModel.startGcodeCommands.append(line) 
 97                   
 98                  if self.setPositioningToAbsolute: 
 99                          self.slicedModel.startGcodeCommands.append(GcodeCommand(gcodes.ABSOLUTE_POSITIONING)) 
100                  if self.setUnitsToMillimeters: 
101                          self.slicedModel.startGcodeCommands.append(GcodeCommand(gcodes.UNITS_IN_MILLIMETERS)) 
102                  if self.startAtHome: 
103                          self.slicedModel.startGcodeCommands.append(GcodeCommand(gcodes.START_AT_HOME)) 
104                  if self.resetExtruder: 
105                          self.slicedModel.startGcodeCommands.append(GcodeCommand(gcodes.RESET_EXTRUDER_DISTANCE, [('E', '0')])) 
106                   
107 -        def addEndCommandsToGcode(self): 
108                  if config.get(name, 'end.file') != None: 
109                          for line in archive.getLinesFromAlterationsFile(self.endFile): 
110                                  self.slicedModel.endGcodeCommands.append(line) 
111