static GCodeInfo GenerateGCodeForFile(string filename, Action <string, string> errorF, Func <bool> cancelF)
{
GCodeInfo info = new GCodeInfo();
DMesh3 mesh = StandardMeshReader.ReadMesh(filename);
if (mesh == null || mesh.TriangleCount == 0)
{
throw new Exception("File " + filename + " is invalid or empty");
}
bool ENABLE_SUPPORT_ZSHIFT = true;
// configure settings
MakerbotSettings settings = new MakerbotSettings(Makerbot.Models.Replicator2);
//MonopriceSettings settings = new MonopriceSettings(Monoprice.Models.MP_Select_Mini_V2);
//PrintrbotSettings settings = new PrintrbotSettings(Printrbot.Models.Plus);
settings.ExtruderTempC = 200;
settings.Shells = 2;
settings.InteriorSolidRegionShells = 0;
settings.SparseLinearInfillStepX = 10;
settings.ClipSelfOverlaps = false;
settings.GenerateSupport = true;
settings.EnableSupportShell = true;
PrintMeshAssembly meshes = new PrintMeshAssembly();
meshes.AddMesh(mesh);
// slice meshes
MeshPlanarSlicerPro slicer = new MeshPlanarSlicerPro()
{
LayerHeightMM = settings.LayerHeightMM,
SliceFactoryF = PlanarSlicePro.FactoryF
};
slicer.Add(meshes);
slicer.CancelF = cancelF;
PlanarSliceStack slices = slicer.Compute();
if (slicer.WasCancelled)
{
return(info);
}
info.SliceCount = slices.Count;
info.SliceBounds = slices.Bounds;
// run print generator
SingleMaterialFFFPrintGenPro printGen =
new SingleMaterialFFFPrintGenPro(meshes, slices, settings);
printGen.ErrorF = errorF;
printGen.CancelF = cancelF;
if (ENABLE_SUPPORT_ZSHIFT)
{
printGen.LayerPostProcessor = new SupportConnectionPostProcessor()
{
ZOffsetMM = 0.2f
}
}
;
printGen.AccumulatePathSet = true;
printGen.Generate();
if (printGen.WasCancelled)
{
return(info);
}
GCodeFile genGCode = printGen.Result;
info.PathBounds = printGen.AccumulatedPaths.Bounds;
info.ExtrudeBounds = printGen.AccumulatedPaths.ExtrudeBounds;
info.TotalLength = CurveUtils.ArcLength(printGen.AccumulatedPaths.AllPositionsItr());
info.GCodeLines = genGCode.LineCount;
// write to in-memory string
StandardGCodeWriter writer = new StandardGCodeWriter();
using (MemoryStream membuf = new MemoryStream()) {
using (StreamWriter w = new StreamWriter(membuf)) {
writer.WriteFile(genGCode, w);
info.GCodeBytes = (int)membuf.Length;
}
}
info.completed = true;
return(info);
}
}
public void Compute()
{
int N = meshToScene.Length;
slicer = new MeshPlanarSlicerPro()
{
LayerHeightMM = CC.Settings.LayerHeightMM,
// [RMS] 1.5 here is a hack. If we don't leave a bit of space then often the filament gets squeezed right at
// inside/outside transitions, which is bad. Need a better way to handle.
OpenPathDefaultWidthMM = CC.Settings.NozzleDiameterMM * 1.5,
SetMinZValue = 0,
SliceFactoryF = PlanarSlicePro.FactoryF
};
if (CC.Settings.OpenMode == PrintSettings.OpenMeshMode.Clipped)
{
slicer.DefaultOpenPathMode = PrintMeshOptions.OpenPathsModes.Clipped;
}
else if (CC.Settings.OpenMode == PrintSettings.OpenMeshMode.Embedded)
{
slicer.DefaultOpenPathMode = PrintMeshOptions.OpenPathsModes.Embedded;
}
else if (CC.Settings.OpenMode == PrintSettings.OpenMeshMode.Ignored)
{
slicer.DefaultOpenPathMode = PrintMeshOptions.OpenPathsModes.Ignored;
}
if (CC.Settings.StartLayers > 0)
{
int start_layers = CC.Settings.StartLayers;
double std_layer_height = CC.Settings.LayerHeightMM;
double start_layer_height = CC.Settings.StartLayerHeightMM;
slicer.LayerHeightF = (layer_i) => {
return((layer_i < start_layers) ? start_layer_height : std_layer_height);
};
}
try {
assembly = new PrintMeshAssembly();
for (int k = 0; k < N; ++k)
{
DMesh3 mesh = meshCopies[k];
Frame3f mapF = meshToScene[k];
PrintMeshSettings settings = meshSettings[k];
PrintMeshOptions options = new PrintMeshOptions();
options.IsSupport = (settings.ObjectType == PrintMeshSettings.ObjectTypes.Support);
options.IsCavity = (settings.ObjectType == PrintMeshSettings.ObjectTypes.Cavity);
options.IsCropRegion = (settings.ObjectType == PrintMeshSettings.ObjectTypes.CropRegion);
options.IsOpen = false;
if (settings.OuterShellOnly)
{
options.IsOpen = true;
}
options.OpenPathMode = PrintMeshSettings.Convert(settings.OpenMeshMode);
options.Extended = new ExtendedPrintMeshOptions()
{
ClearanceXY = settings.Clearance,
OffsetXY = settings.OffsetXY
};
Vector3f scale = localScale[k];
MeshTransforms.Scale(mesh, scale.x, scale.y, scale.z);
MeshTransforms.FromFrame(mesh, mapF);
MeshTransforms.FlipLeftRightCoordSystems(mesh);
MeshTransforms.ConvertYUpToZUp(mesh);
MeshAssembly decomposer = new MeshAssembly(mesh);
decomposer.HasNoVoids = settings.NoVoids;
decomposer.Decompose();
assembly.AddMeshes(decomposer.ClosedSolids, options);
PrintMeshOptions openOptions = options.Clone();
assembly.AddMeshes(decomposer.OpenMeshes, openOptions);
}
if (slicer.Add(assembly) == false)
{
throw new Exception("error adding PrintMeshAssembly to Slicer!!");
}
// set clip box
Box2d clip_box = new Box2d(Vector2d.Zero,
new Vector2d(CC.Settings.BedSizeXMM / 2, CC.Settings.BedSizeYMM / 2));
slicer.ValidRegions = new List <GeneralPolygon2d>()
{
new GeneralPolygon2d(new Polygon2d(clip_box.ComputeVertices()))
};
result = slicer.Compute();
Success = true;
} catch (Exception e) {
DebugUtil.Log("GeometrySlicer.Compute: exception: " + e.Message);
Success = false;
}
Finished = true;
}
static void Main(string[] args)
{
GCodeInfo info = new GCodeInfo();
string filename = args[0];
DMesh3 mesh = StandardMeshReader.ReadMesh(filename);
AxisAlignedBox3d bounds = mesh.CachedBounds;
MeshTransforms.Scale(mesh, MAX_DIM_MM / bounds.MaxDim);
Vector3d basePt = mesh.CachedBounds.Point(0, 0, -1);
MeshTransforms.Translate(mesh, -basePt);
if (mesh.TriangleCount > MAX_TRI_COUNT)
{
Reducer r = new Reducer(mesh);
r.ReduceToTriangleCount(MAX_TRI_COUNT);
mesh = new DMesh3(mesh, true);
}
var start = DateTime.Now;
bool ENABLE_SUPPORT_ZSHIFT = true;
try {
// configure settings
MakerbotSettings settings = new MakerbotSettings(Makerbot.Models.Replicator2);
//MonopriceSettings settings = new MonopriceSettings(Monoprice.Models.MP_Select_Mini_V2);
//PrintrbotSettings settings = new PrintrbotSettings(Printrbot.Models.Plus);
settings.ExtruderTempC = 200;
settings.Shells = 2;
settings.InteriorSolidRegionShells = 0;
settings.SparseLinearInfillStepX = 10;
settings.ClipSelfOverlaps = false;
settings.GenerateSupport = true;
settings.EnableSupportShell = true;
PrintMeshAssembly meshes = new PrintMeshAssembly();
meshes.AddMesh(mesh);
// slice meshes
MeshPlanarSlicerPro slicer = new MeshPlanarSlicerPro()
{
LayerHeightMM = settings.LayerHeightMM,
SliceFactoryF = PlanarSlicePro.FactoryF
};
slicer.Add(meshes);
PlanarSliceStack slices = slicer.Compute();
info.SliceCount = slices.Count;
info.SliceBounds = slices.Bounds;
// run print generator
SingleMaterialFFFPrintGenPro printGen =
new SingleMaterialFFFPrintGenPro(meshes, slices, settings);
if (ENABLE_SUPPORT_ZSHIFT)
{
printGen.LayerPostProcessor = new SupportConnectionPostProcessor()
{
ZOffsetMM = 0.2f
}
}
;
printGen.AccumulatePathSet = true;
printGen.Generate();
GCodeFile genGCode = printGen.Result;
info.PathBounds = printGen.AccumulatedPaths.Bounds;
info.ExtrudeBounds = printGen.AccumulatedPaths.ExtrudeBounds;
info.TotalLength = CurveUtils.ArcLength(printGen.AccumulatedPaths.AllPositionsItr());
info.GCodeLines = genGCode.LineCount;
// write to in-memory string
StandardGCodeWriter writer = new StandardGCodeWriter();
using (MemoryStream membuf = new MemoryStream()) {
using (StreamWriter w = new StreamWriter(membuf)) {
writer.WriteFile(genGCode, w);
info.GCodeBytes = (int)membuf.Length;
}
}
// try to force destructor error
printGen = null;
genGCode = null;
GC.Collect();
} catch (Exception e) {
System.Console.WriteLine("EXCEPTION:" + e.Message);
return;
}
var end = DateTime.Now;
int seconds = (int)(end - start).TotalSeconds;
System.Console.WriteLine("{0},{1},{2},{3},{4},{5},{6},{7},",
filename, mesh.TriangleCount, "OK", seconds, info.SliceCount, info.GCodeLines, info.GCodeBytes, (int)info.TotalLength);
}
static string GenerateGCodeForMeshes(PrintMeshAssembly meshes)
{
bool ENABLE_SUPPORT_ZSHIFT = true;
// configure settings
MakerbotSettings settings = new MakerbotSettings(Makerbot.Models.Replicator2);
//MonopriceSettings settings = new MonopriceSettings(Monoprice.Models.MP_Select_Mini_V2);
//PrintrbotSettings settings = new PrintrbotSettings(Printrbot.Models.Plus);
settings.ExtruderTempC = 200;
settings.Shells = 2;
settings.InteriorSolidRegionShells = 0;
settings.SparseLinearInfillStepX = 10;
settings.ClipSelfOverlaps = false;
//settings.RoofLayers = settings.FloorLayers = 0;
//settings.LayerRangeFilter = new Interval1i(245, 255);
settings.LayerRangeFilter = new Interval1i(6, 40);
settings.GenerateSupport = false;
settings.EnableSupportShell = true;
settings.SupportSolidSpace = 0.35;
//settings.Machine.NozzleDiamMM = 0.75;
//settings.Machine.MaxLayerHeightMM = 0.5;
//settings.FillPathSpacingMM = settings.Machine.NozzleDiamMM;
//settings.LayerHeightMM = 0.5;
//settings.LayerRangeFilter = new Interval1i(130, 140);
LastSettings = settings.CloneAs <SingleMaterialFFFSettings>();
System.Console.WriteLine("Slicing...");
// slice meshes
MeshPlanarSlicerPro slicer = new MeshPlanarSlicerPro()
{
LayerHeightMM = settings.LayerHeightMM,
SliceFactoryF = PlanarSlicePro.FactoryF
};
slicer.Add(meshes);
PlanarSliceStack slices = slicer.Compute();
System.Console.WriteLine("Generating GCode...");
// run print generator
SingleMaterialFFFPrintGenPro printGen =
new SingleMaterialFFFPrintGenPro(meshes, slices, settings);
if (ENABLE_SUPPORT_ZSHIFT)
{
printGen.LayerPostProcessor = new SupportConnectionPostProcessor()
{
ZOffsetMM = 0.2f
}
}
;
printGen.AccumulatePathSet = (SHOW_RELOADED_GCODE_PATHS == false);
printGen.Generate();
GCodeFile genGCode = printGen.Result;
System.Console.WriteLine("Writing GCode...");
string sWritePath = "../../../sample_output/generated.gcode";
StandardGCodeWriter writer = new StandardGCodeWriter();
using (StreamWriter w = new StreamWriter(sWritePath)) {
writer.WriteFile(genGCode, w);
}
if (settings is MakerbotSettings)
{
System.Diagnostics.Process.Start(GPX_PATH, "-p " + sWritePath);
}
if (SHOW_RELOADED_GCODE_PATHS == false)
{
View.SetPaths(printGen.AccumulatedPaths, settings);
}
return(sWritePath);
}
