Cura is a AGPL tool chain to generate a GCode path for 3D printing. Older versions of Cura where based on Skeinforge.
Versions up from 13.05 are based on a C++ engine called CuraEngine.
"""
-from __future__ import absolute_import
__copyright__ = "Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License"
from optparse import OptionParser
from Cura.util import profile
def main():
+ """
+ Main Cura entry point. Parses arguments, and starts GUI or slicing process depending on the arguments.
+ """
parser = OptionParser(usage="usage: %prog [options] <filename>.stl")
parser.add_option("-i", "--ini", action="store", type="string", dest="profileini",
help="Load settings from a profile ini file")
- parser.add_option("-r", "--print", action="store", type="string", dest="printfile",
- help="Open the printing interface, instead of the normal cura interface.")
parser.add_option("-p", "--profile", action="store", type="string", dest="profile",
help="Internal option, do not use!")
parser.add_option("-s", "--slice", action="store_true", dest="slice",
help="Slice the given files instead of opening them in Cura")
parser.add_option("-o", "--output", action="store", type="string", dest="output",
help="path to write sliced file to")
+ parser.add_option("--serialCommunication", action="store", type="string", dest="serialCommunication",
+ help="Start commandline serial monitor")
(options, args) = parser.parse_args()
+ if options.serialCommunication:
+ from Cura import serialCommunication
+ port, baud = options.serialCommunication.split(':')
+ serialCommunication.startMonitor(port, baud)
+ return
+
print "load preferences from " + profile.getPreferencePath()
profile.loadPreferences(profile.getPreferencePath())
elif options.profileini is not None:
profile.loadProfile(options.profileini)
else:
- profile.loadProfile(profile.getDefaultProfilePath())
+ profile.loadProfile(profile.getDefaultProfilePath(), True)
- if options.printfile is not None:
- from Cura.gui import printWindow
- printWindow.startPrintInterface(options.printfile)
- elif options.slice is not None:
+ if options.slice is not None:
from Cura.util import sliceEngine
from Cura.util import objectScene
from Cura.util import meshLoader
import shutil
- def commandlineProgressCallback(progress, ready):
- if progress >= 0 and not ready:
- print 'Preparing: %d%%' % (progress * 100)
+ def commandlineProgressCallback(progress):
+ if progress >= 0:
+ #print 'Preparing: %d%%' % (progress * 100)
+ pass
scene = objectScene.Scene()
scene.updateMachineDimensions()
- slicer = sliceEngine.Slicer(commandlineProgressCallback)
+ engine = sliceEngine.Engine(commandlineProgressCallback)
for m in meshLoader.loadMeshes(args[0]):
scene.add(m)
- slicer.runSlicer(scene)
- slicer.wait()
- profile.replaceGCodeTagsFromSlicer(slicer.getGCodeFilename(), slicer)
+ engine.runEngine(scene)
+ engine.wait()
- if options.output:
- shutil.copyfile(slicer.getGCodeFilename(), options.output)
- print 'GCode file saved : %s' % options.output
- else:
- shutil.copyfile(slicer.getGCodeFilename(), args[0] + '.gcode')
- print 'GCode file saved as: %s' % (args[0] + '.gcode')
+ if not options.output:
+ options.output = args[0] + profile.getGCodeExtension()
+ with open(options.output, "wb") as f:
+ gcode = engine.getResult().getGCode()
+ while True:
+ data = gcode.read()
+ if len(data) == 0:
+ break
+ f.write(data)
+ print 'GCode file saved : %s' % options.output
- slicer.cleanup()
+ engine.cleanup()
else:
from Cura.gui import app
app.CuraApp(args).MainLoop()
if __name__ == '__main__':
+ import os
+ import sys
+
+ # On Windows, the PATH variable can cause the search path for dlls
+ # to give priority to dlls from other applications and it will cause
+ # the bundled python dlls not to be loaded.
+ # More specifically, anyone with Haskell Platform installed will not
+ # be able to launch Cura because glut32.dll from Haskell is incompatible
+ # with the bundled py-opengl and will cause Cura to crash
+ if sys.platform.startswith('win'):
+ os.environ['PATH'] = ''
main()