bool process_completed_compute()
{
if (active_compute != null)
{
if (active_compute.Finished)
{
lock (active_compute_lock) {
lock (data_lock) {
SlicerMeshes = active_compute.assembly;
SliceStackValid = true;
SliceSet = active_compute.result;
}
// this recomputes slice polylines, but it could be better...
if (ShowSlicePolylines)
{
discard_slice_polylines();
compute_slice_polylines();
}
active_compute = null;
active_compute_thread = null;
return(true);
}
}
}
return(false);
}
private void BuildToolPaths(GenerationTask generationTask, PrintSettings settings)
{
lock (active_compute_lock)
{
DebugUtil.Log("[ToolpathGenerator] Spawning Compute!!");
generationTask.Compute(settings);
if (generationTask.Success)
{
CurrentGCode = generationTask.gcode;
Toolpaths = generationTask.paths;
LayerInfo = generationTask.layerInfo;
Settings = generationTask.PrintSettings;
Slices = generationTask.SliceSet;
ToolpathsValid = true;
ToolpathsFailed = false;
//CC.Objects.SetToolpaths(this);
}
else
{
CurrentGCode = null;
Toolpaths = null;
LayerInfo = null;
Settings = null;
Slices = null;
ToolpathsValid = false;
ToolpathsFailed = true;
}
}
}
public GenericSLSPrintGenerator(PrintMeshAssembly meshes,
PlanarSliceStack slices,
SingleMaterialFFFSettings settings)
{
file_accumulator = new GCodeFileAccumulator();
//builder = new GCodeBuilder(file_accumulator);
//compiler = new SLSCompiler(builder, settings);
compiler = new SLSCompiler(settings);
base.Initialize(meshes, slices, settings, compiler);
}
public bool ExtractResultsIfValid(out PrintMeshAssembly printMeshes, out PlanarSliceStack slices)
{
bool valid = false;
lock (data_lock) {
printMeshes = SlicerMeshes;
slices = SliceSet;
valid = SliceStackValid;
}
return(valid);
}
public void InvalidateSlicing()
{
//cancel_active_compute();
lock (data_lock)
{
SlicerMeshes = null;
SliceSet = null;
SliceStackValid = false;
}
// discard_slice_polylines();
}
static void Main(string[] args)
{
CappedCylinderGenerator cylgen = new CappedCylinderGenerator()
{
BaseRadius = 10, TopRadius = 5, Height = 20, Slices = 32
};
DMesh3 mesh = cylgen.Generate().MakeDMesh();
MeshTransforms.ConvertYUpToZUp(mesh); // g3 meshes are usually Y-up
// center mesh above origin
AxisAlignedBox3d bounds = mesh.CachedBounds;
Vector3d baseCenterPt = bounds.Center - bounds.Extents.z * Vector3d.AxisZ;
MeshTransforms.Translate(mesh, -baseCenterPt);
// create print mesh set
PrintMeshAssembly meshes = new PrintMeshAssembly();
meshes.AddMesh(mesh, PrintMeshOptions.Default());
// create settings
//MakerbotSettings settings = new MakerbotSettings(Makerbot.Models.Replicator2);
//PrintrbotSettings settings = new PrintrbotSettings(Printrbot.Models.Plus);
//MonopriceSettings settings = new MonopriceSettings(Monoprice.Models.MP_Select_Mini_V2);
RepRapSettings settings = new RepRapSettings(RepRap.Models.Unknown);
// do slicing
MeshPlanarSlicer slicer = new MeshPlanarSlicer()
{
LayerHeightMM = settings.LayerHeightMM
};
slicer.Add(meshes);
PlanarSliceStack slices = slicer.Compute();
// run print generator
SingleMaterialFFFPrintGenerator printGen =
new SingleMaterialFFFPrintGenerator(meshes, slices, settings);
if (printGen.Generate())
{
// export gcode
GCodeFile gcode = printGen.Result;
using (StreamWriter w = new StreamWriter("c:\\demo\\cone.gcode")) {
StandardGCodeWriter writer = new StandardGCodeWriter();
writer.WriteFile(gcode, w);
}
}
}
public void CreateToolPaths(PrintMeshAssembly meshes, PlanarSliceStack slices, PrintSettings settings)
{
// have to wait for valid slice stack
if (slices == null)
{
return;
}
//mark_spawn_time();
this.BuildToolPaths(new GenerationTask
{
PrintSettings = settings.CloneCurrentSettings(),
Meshes = meshes,
SliceSet = slices,
InterpretGCodePaths = ShowActualGCodePaths
}, settings);
}
public void InvalidateToolpaths()
{
cancel_active_compute();
CurrentGCode = null;
Toolpaths = null;
LayerInfo = null;
Settings = null;
Slices = null;
ToolpathsValid = false;
ToolpathsFailed = false;
// [TODO] do via event?
CC.Objects.DiscardToolpaths();
ToolpathsInvalidatedEvent?.Invoke();
}
public void SliceMeshes(List <DMesh3> sourceMeshes, PrintSettings printSettings)
{
SliceStackValid = false;
try
{
var sliceTask = new SliceTask();
sliceTask.meshCopies = sourceMeshes;
sliceTask.Compute(printSettings);
SlicerMeshes = sliceTask.MeshAssembly;
SliceSet = sliceTask.SliceStack;
SliceStackValid = true;
}
catch (Exception ex)
{
}
}
bool process_completed_compute()
{
if (active_compute != null)
{
if (active_compute.Finished)
{
lock (active_compute_lock) {
if (active_compute.Success)
{
CurrentGCode = active_compute.gcode;
Toolpaths = active_compute.paths;
LayerInfo = active_compute.layerInfo;
Settings = active_compute.PrintSettings;
Slices = active_compute.SliceSet;
ToolpathsValid = true;
ToolpathsFailed = false;
ToolpathsProgressEvent?.Invoke(new ToolpathProgressStatus(1, 1));
CC.Objects.SetToolpaths(this);
}
else
{
CurrentGCode = null;
Toolpaths = null;
LayerInfo = null;
Settings = null;
Slices = null;
ToolpathsValid = false;
ToolpathsFailed = true;
// notify of failure here?
ToolpathsProgressEvent?.Invoke(ToolpathProgressStatus.Failed);
}
active_compute = null;
active_compute_thread = null;
return(true);
}
}
}
return(false);
}
public void InvalidateSlicing()
{
cancel_active_compute();
lock (data_lock) {
SlicerMeshes = null;
SliceSet = null;
SliceStackValid = false;
}
discard_slice_polylines();
CC.InvalidateToolPaths();
if (SlicingInvalidatedEvent != null)
{
SlicingInvalidatedEvent();
}
}
private void DrawLayerSlice(PlanarSliceStack stack, SKCanvas canvas, SKPaint paint)
{
SKColor pathColor = SkiaUtil.Color(255, 0, 0, 255);
paint.Color = pathColor;
paint.Style = SKPaintStyle.Stroke;
paint.StrokeWidth = 2.0f;
if (currentLayer >= stack.Slices.Count)
{
return;
}
PlanarSlice slice = stack.Slices[currentLayer];
foreach (GeneralPolygon2d poly in slice.Solids)
{
SKPath path = MakePaths(poly, SceneToSkiaF);
canvas.DrawPath(path, paint);
}
}
public static void Main(string[] args)
{
ExceptionManager.UnhandledException += delegate(UnhandledExceptionArgs expArgs) {
Console.WriteLine(expArgs.ExceptionObject.ToString());
expArgs.ExitApplication = true;
};
Gtk.Application.Init();
MainWindow = new Window("DLPViewer");
MainWindow.SetDefaultSize(900, 600);
MainWindow.SetPosition(WindowPosition.Center);
MainWindow.DeleteEvent += delegate {
Gtk.Application.Quit();
};
DMesh3 mesh = StandardMeshReader.ReadMesh("../../../sample_files/bunny_solid_5cm_min.obj");
MeshPlanarSlicer slicer = new MeshPlanarSlicer();
slicer.LayerHeightMM = 0.2;
slicer.AddMesh(mesh);
PlanarSliceStack sliceStack = slicer.Compute();
View = new DLPViewCanvas();
View.SetSlices(sliceStack);
MainWindow.Add(View);
MainWindow.KeyReleaseEvent += Window_KeyReleaseEvent;
MainWindow.ShowAll();
Gtk.Application.Run();
}
public IEnumerable <Progress> GenerateGCodeFile()
{
// run print generator
// do slicing
var slicer = new MeshPlanarSlicer()
{
LayerHeightMM = settings.LayerHeightMM
};
slicer.Add(meshes);
foreach (var i in slicer.Compute())
{
yield return(i);
}
PlanarSliceStack slices = slicer.Result;
var printGen = new SingleMaterialFFFPrintGenerator(meshes, slices, settings);
foreach (var i in printGen.Generate())
{
yield return(i);
}
gcode = printGen.Result;
}
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);
}
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 GCodeFile generate_cnc_test(MeshPlanarMillSlicer.Result sliceSets, RepRapSettings settings, out ToolpathSet AccumulatedPaths)
{
int PLUNGE_SPEED = 800;
AccumulatedPaths = new ToolpathSet();
GCodeFileAccumulator file_accumulator = new GCodeFileAccumulator();
GCodeBuilder builder = new GCodeBuilder(file_accumulator);
BaseThreeAxisMillingCompiler Compiler = new BaseThreeAxisMillingCompiler(builder, settings, GenericMillingAssembler.Factory);
Compiler.Begin();
/*
* Clearing pass
*/
PlanarSliceStack clearingSlices = sliceSets.Clearing;
int N = clearingSlices.Count;
// assuming origin is at top of stock so we actaully are going down in Z layers
for (int k = 0; k < N; ++k)
{
clearingSlices[k].Z = -(sliceSets.TopZ - clearingSlices[k].Z);
}
for (int layeri = 0; layeri < N; layeri++)
{
PlanarSlice slice = clearingSlices[layeri];
Compiler.AppendComment(string.Format("clearing layer {0} - {1}mm", layeri, slice.Z));
ToolpathSetBuilder layer_builder = new ToolpathSetBuilder()
{
MoveType = ToolpathTypes.Cut
};
layer_builder.Initialize(Compiler.ToolPosition);
// To do a layer-change, we need to plunge down at the first scheduled cutting position.
// However we will not know that until we schedule the first set of paths.
// So, we configure SequentialScheduler2d to call this function when it knows this information,
// and then we can travel to the new XY position before we plunge to new Z
Action <List <FillCurveSet2d>, SequentialScheduler2d> DoZChangeF = (curves, scheduler) => {
Vector2d startPosXY = (curves[0].Loops.Count > 0) ?
curves[0].Loops[0].Start : curves[0].Curves[0].Start;
Vector3d startPosXYZ = new Vector3d(startPosXY.x, startPosXY.y, slice.Z);
// TODO: we should retract at faster speed here? maybe use custom function that does this better?
layer_builder.AppendTravel(startPosXYZ, PLUNGE_SPEED);
scheduler.OnAppendCurveSetsF = null;
};
SequentialScheduler2d layerScheduler = new SequentialScheduler2d(layer_builder, settings)
{
ExtrudeOnShortTravels = true,
ShortTravelDistance = settings.Machine.NozzleDiamMM * 1.5
};
layerScheduler.OnAppendCurveSetsF = DoZChangeF;
GroupScheduler2d groupScheduler = new GroupScheduler2d(layerScheduler, Compiler.ToolPosition.xy);
foreach (GeneralPolygon2d shape in slice.Solids)
{
ShellsFillPolygon shells_gen = new ShellsFillPolygon(shape)
{
PathSpacing = settings.ShellsFillPathSpacingMM(),
ToolWidth = settings.Machine.NozzleDiamMM,
Layers = 10,
OuterShellLast = false,
DiscardTinyPerimterLengthMM = 1, DiscardTinyPolygonAreaMM2 = 1
};
shells_gen.Compute();
groupScheduler.BeginGroup();
groupScheduler.AppendCurveSets(shells_gen.Shells);
groupScheduler.EndGroup();
}
Compiler.AppendPaths(layer_builder.Paths, settings);
AccumulatedPaths.Append(layer_builder.Paths);
}
/*
* Horizontal finish pass
*/
PlanarSliceStack horzSlices = sliceSets.HorizontalFinish;
int NH = horzSlices.Count;
// assuming origin is at top of stock so we actaully are going down in Z layers
for (int k = 0; k < NH; ++k)
{
horzSlices[k].Z = -(sliceSets.TopZ - horzSlices[k].Z);
}
for (int layeri = 0; layeri < NH; layeri++)
{
PlanarSlice slice = horzSlices[layeri];
Compiler.AppendComment(string.Format("horz finish layer {0} - {1}mm", layeri, slice.Z));
ToolpathSetBuilder layer_builder = new ToolpathSetBuilder()
{
MoveType = ToolpathTypes.Cut
};
layer_builder.Initialize(Compiler.ToolPosition);
Action <List <FillCurveSet2d>, SequentialScheduler2d> DoZChangeF = (curves, scheduler) => {
Vector2d startPosXY = (curves[0].Loops.Count > 0) ?
curves[0].Loops[0].Start : curves[0].Curves[0].Start;
Vector3d startPosXYZ = new Vector3d(startPosXY.x, startPosXY.y, slice.Z);
// TODO: we should retract at faster speed here? maybe use custom function that does this better?
layer_builder.AppendTravel(startPosXYZ, PLUNGE_SPEED);
scheduler.OnAppendCurveSetsF = null;
};
SequentialScheduler2d layerScheduler = new SequentialScheduler2d(layer_builder, settings)
{
ExtrudeOnShortTravels = true,
ShortTravelDistance = settings.Machine.NozzleDiamMM * 1.5
};
layerScheduler.OnAppendCurveSetsF = DoZChangeF;
GroupScheduler2d groupScheduler = new GroupScheduler2d(layerScheduler, Compiler.ToolPosition.xy);
foreach (GeneralPolygon2d shape in slice.Solids)
{
ShellsFillPolygon shells_gen = new ShellsFillPolygon(shape)
{
//InsetFromInputPolygonX = 0.0,
PathSpacing = settings.ShellsFillPathSpacingMM(),
ToolWidth = settings.Machine.NozzleDiamMM,
Layers = 10,
OuterShellLast = false,
PreserveInputInsetTopology = false,
DiscardTinyPerimterLengthMM = 1, DiscardTinyPolygonAreaMM2 = 1
};
shells_gen.Compute();
groupScheduler.BeginGroup();
groupScheduler.AppendCurveSets(shells_gen.Shells);
groupScheduler.EndGroup();
}
Compiler.AppendPaths(layer_builder.Paths, settings);
AccumulatedPaths.Append(layer_builder.Paths);
}
// return to home position
ToolpathSetBuilder finishBuilder = new ToolpathSetBuilder()
{
MoveType = ToolpathTypes.Cut
};
finishBuilder.Initialize(Compiler.ToolPosition);
finishBuilder.AppendTravel(Vector3d.Zero, PLUNGE_SPEED);
Compiler.AppendPaths(finishBuilder.Paths, settings);
Compiler.End();
return(file_accumulator.File);
}
public void SetSlices(PlanarSliceStack slices)
{
Slices = slices;
}
static string GenerateGCodeForMeshes(PrintMeshAssembly meshes)
{
AxisAlignedBox3d bounds = meshes.TotalBounds;
double top_z = bounds.Depth;
// configure settings
RepRapSettings settings = new RepRapSettings(RepRap.Models.Unknown);
settings.GenerateSupport = false;
settings.EnableBridging = false;
int nSpeed = 1200; // foam
//int nSpeed = 700; // wood
settings.RapidTravelSpeed = nSpeed;
settings.RapidExtrudeSpeed = nSpeed;
settings.CarefulExtrudeSpeed = nSpeed;
settings.OuterPerimeterSpeedX = 1.0;
settings.ZTravelSpeed = nSpeed;
settings.RetractSpeed = nSpeed;
settings.LayerHeightMM = 4.0;
settings.Machine.NozzleDiamMM = 6.35;
settings.Machine.BedSizeXMM = 240;
settings.Machine.BedSizeYMM = 190;
settings.RetractDistanceMM = 1;
settings.EnableRetraction = true;
settings.ShellsFillNozzleDiamStepX = 0.5;
settings.SolidFillNozzleDiamStepX = 0.9;
settings.SolidFillBorderOverlapX = 0.5;
LastSettings = settings.CloneAs <SingleMaterialFFFSettings>();
System.Console.WriteLine("Slicing...");
// slice meshes
MeshPlanarMillSlicer slicer = new MeshPlanarMillSlicer()
{
LayerHeightMM = settings.LayerHeightMM,
ToolDiameter = settings.Machine.NozzleDiamMM,
ExpandStockAmount = 0.4 * settings.Machine.NozzleDiamMM
};
slicer.Add(meshes);
MeshPlanarMillSlicer.Result sliceResult = slicer.Compute();
PlanarSliceStack slices = sliceResult.Clearing;
System.Console.WriteLine("Generating GCode...");
ToolpathSet accumPaths;
GCodeFile genGCode = generate_cnc_test(sliceResult, settings, out accumPaths);
System.Console.WriteLine("Writing GCode...");
string sWritePath = "../../../sample_output/generated.nc";
StandardGCodeWriter writer = new StandardGCodeWriter()
{
CommentStyle = StandardGCodeWriter.CommentStyles.Bracket
};
using (StreamWriter w = new StreamWriter(sWritePath)) {
writer.WriteFile(genGCode, w);
}
//DMesh3 tube_mesh = GenerateTubeMeshesForGCode(sWritePath, settings.Machine.NozzleDiamMM);
DMesh3 tube_mesh = GenerateTubeMeshesForGCode(sWritePath, 0.4);
StandardMeshWriter.WriteMesh("../../../sample_output/generated_tubes.obj", tube_mesh, WriteOptions.Defaults);
if (SHOW_RELOADED_GCODE_PATHS == false)
{
View.SetPaths(accumPaths, settings);
View.PathDiameterMM = (float)settings.Machine.NozzleDiamMM;
}
slices.Add(sliceResult.HorizontalFinish.Slices);
slices.Slices.Sort((a, b) => { return(a.Z.CompareTo(b.Z)); });
View.SetSlices(slices);
View.CurrentLayer = slices.Slices.Count - 1;
return(sWritePath);
}
public void SetSlices(PlanarSliceStack slices)
{
Stack = slices;
CurrentLayer = 0;
SliceImages = new List <SKBitmap>();
}
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);
}
}
static string GenerateGCodeForMeshes(PrintMeshAssembly meshes)
{
bool ENABLE_SUPPORT_ZSHIFT = true;
// configure settings
//MakerbotSettings settings = new MakerbotSettings(Makerbot.Models.Replicator2);
//FlashforgeSettings settings = new FlashforgeSettings(Flashforge.Models.CreatorPro);
//MonopriceSettings settings = new MonopriceSettings(Monoprice.Models.MP_Select_Mini_V2);
PrintrbotSettings settings = new PrintrbotSettings(Printrbot.Models.Plus);
//PrusaSettings settings = new PrusaSettings(Prusa.Models.i3_MK3);
//settings.ExtruderTempC = 215;
//settings.Machine.NozzleDiamMM = 0.4;
settings.Shells = 2;
settings.InteriorSolidRegionShells = 0;
settings.SparseLinearInfillStepX = 5;
//settings.SolidFillNozzleDiamStepX = 0;
//settings.SolidFillBorderOverlapX = 0;
//settings.SparseFillBorderOverlapX = 0;
settings.ClipSelfOverlaps = false;
//settings.RoofLayers = settings.FloorLayers = 0;
//settings.LayerRangeFilter = new Interval1i(245, 255);
//settings.LayerRangeFilter = new Interval1i(0, 0);
settings.EnableBridging = true;
settings.GenerateSupport = false;
settings.EnableSupportShell = true;
settings.SupportMinZTips = false;
settings.SupportSolidSpace = 0.35;
settings.SupportOverhangAngleDeg = 25;
//settings.OuterShellLast = true;
//settings.Shells = 0;
//settings.Machine.NozzleDiamMM = 0.75;
//settings.Machine.MaxLayerHeightMM = 0.5;
//settings.FillPathSpacingMM = settings.Machine.NozzleDiamMM;
//settings.LayerHeightMM = 0.5;
settings.StartLayers = 0;
settings.StartLayerHeightMM = 0.3;
//settings.LayerRangeFilter = new Interval1i(130, 140);
LastSettings = settings.CloneAs <SingleMaterialFFFSettings>();
System.Console.WriteLine("Slicing...");
// slice meshes
MeshPlanarSlicer slicer = new MeshPlanarSlicer()
{
LayerHeightMM = settings.LayerHeightMM
};
if (settings.StartLayers > 0)
{
int start_layers = settings.StartLayers;
double std_layer_height = settings.LayerHeightMM;
double start_layer_height = settings.StartLayerHeightMM;
slicer.LayerHeightF = (layer_i) => {
return((layer_i < start_layers) ? start_layer_height : std_layer_height);
};
}
slicer.Add(meshes);
PlanarSliceStack slices = slicer.Compute();
System.Console.WriteLine("Generating GCode...");
// run print generator
SingleMaterialFFFPrintGenerator printGen =
new SingleMaterialFFFPrintGenerator(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 ISailfishSettings)
{
System.Diagnostics.Process.Start(GPX_PATH, (settings as ISailfishSettings).GPXModelFlag + " -p " + sWritePath);
}
View.PathDiameterMM = (float)settings.Machine.NozzleDiamMM - 0.005f;
if (SHOW_RELOADED_GCODE_PATHS == false)
{
View.SetPaths(printGen.AccumulatedPaths, settings);
View.SetSlices(slices);
}
return(sWritePath);
}
static void GenerateGCodeForSliceFile(string sliceFile)
{
PlanarSliceStack slices = new PlanarSliceStack();
using (TextReader reader = new StreamReader(sliceFile)) {
slices.ReadSimpleSliceFormat(reader);
}
// 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.Shells = 2;
settings.SparseLinearInfillStepX = 10;
settings.InteriorSolidRegionShells = 1;
settings.ClipSelfOverlaps = true;
settings.GenerateSupport = true;
settings.SupportSpacingStepX = 5.0;
settings.SupportVolumeScale = 1.0;
//settings.LayerRangeFilter = new Interval1i(0,10);
LastSettings = settings.CloneAs <SingleMaterialFFFSettings>();
// empty...
PrintMeshAssembly meshes = new PrintMeshAssembly();
// run print generator
SingleMaterialFFFPrintGenerator printGen =
new SingleMaterialFFFPrintGenerator(meshes, slices, settings);
printGen.LayerPostProcessor = new SupportConnectionPostProcessor()
{
ZOffsetMM = 0.15f
};
printGen.AccumulatePathSet = (SHOW_RELOADED_GCODE_PATHS == false);
printGen.Generate();
GCodeFile genGCode = printGen.Result;
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)
{
LoadGeneratedGCodeFile(sWritePath);
}
else
{
View.SetPaths(printGen.AccumulatedPaths, settings);
}
}
private void update_slice_height_gizmo()
{
if (CurrentToolpaths == null)
{
if (SliceHeightGizmo != null && SceneUtil.IsVisible(SliceHeightGizmo))
{
SceneUtil.SetVisible(SliceHeightGizmo, false);
}
slice_gizmo_valid = false;
return;
}
if (slice_gizmo_valid)
{
return;
}
AxisAlignedBox3f bounds = GetPrintMeshesBounds(true);
if (bounds == AxisAlignedBox3f.Empty)
{
return; // will be rectified next frame?
}
int nSlices = CurrentToolpaths.GetSlices().Count;
PlanarSliceStack slices = CurrentToolpaths.GetSlices();
// line is floating
//bounds.Min.y = (float)slices[0].Z;
//bounds.Max.y = (float)slices[slices.Count - 1].Z;
// line at ground
bounds.Min.y = 0;
bounds.Max.y = (float)(slices[slices.Count - 1].Z - slices[0].Z);
Vector3f basePos = new Vector3f(bounds.Max.x, bounds.Min.y, bounds.Max.z);
basePos.x += 10; basePos.z += 10;
Vector3f topPos = basePos + bounds.Height * Vector3f.AxisY;
if (SliceHeightGizmo == null)
{
SliceHeightGizmo = new SlicePlaneHeightSO()
{
LineAlwaysVisible = false
};
SliceHeightGizmo.Create(CC.ActiveScene.PivotSOMaterial, null);
SliceHeightGizmo.DisableShadows();
CC.ActiveScene.AddSceneObject(SliceHeightGizmo);
SliceHeightGizmo.Name = "Slice_Height";
SliceHeightGizmo.ConstraintFrameS = new Frame3f(basePos);
SliceHeightGizmo.SetLocalFrame(SliceHeightGizmo.ConstraintFrameS, CoordSpace.SceneCoords);
SliceHeightGizmo.MinPosS = basePos;
SliceHeightGizmo.MaxPosS = topPos;
SliceHeightGizmo.CenterPosS = bounds.Point(0, -1, 0);
SliceHeightGizmo.BoundsDim = (float)Math.Max(bounds.Width, bounds.Depth) + 10.0f;
SliceHeightGizmo.OnTransformModified += SliceHeightGizmo_OnTransformModified;
SliceHeightGizmo.InitializeLiveGizmo(CC.ActiveScene);
}
if (SceneUtil.IsVisible(SliceHeightGizmo) == false)
{
SceneUtil.SetVisible(SliceHeightGizmo, true);
}
SliceHeightGizmo.ConstraintFrameS = new Frame3f(basePos);
ignore_xform_event = true;
SliceHeightGizmo.SetLocalFrame(SliceHeightGizmo.ConstraintFrameS, CoordSpace.SceneCoords);
ignore_xform_event = false;
SliceHeightGizmo.MinPosS = basePos;
SliceHeightGizmo.MaxPosS = topPos;
SliceHeightGizmo.CenterPosS = bounds.Point(0, -1, 0);
SliceHeightGizmo.BoundsDim = (float)Math.Max(bounds.Width, bounds.Depth) + 10.0f;
set_slice_height_from_layer();
slice_gizmo_valid = true;
}
public void ComputeOnBackgroundThread()
{
Deviation = null;
DebugUtil.Log(SO.GetToolpathStats());
ToolpathSet paths = SO.GetToolpaths();
PlanarSliceStack slices = SO.GetSlices();
var settings = SO.GetSettings();
// AAHHH
double bed_width = settings.Machine.BedSizeXMM;
double bed_height = settings.Machine.BedSizeYMM;
Vector3d origin = new Vector3d(-bed_width / 2, -bed_height / 2, 0);
if (settings is gs.info.MakerbotSettings)
{
origin = Vector3d.Zero;
}
List <DeviationPt> points = new List <DeviationPt>();
SpinLock pointsLock = new SpinLock();
Action <DeviationPt> appendPointF = (pt) => {
bool entered = false;
pointsLock.Enter(ref entered);
points.Add(pt);
pointsLock.Exit();
};
double tolerance = settings.Machine.NozzleDiamMM * 0.5 + DeviationToleranceMM;
gParallel.ForEach(Interval1i.Range(slices.Count), (slicei) => {
PlanarSlice slice = slices[slicei];
//Interval1d zrange = (slicei < slices.Count - 1) ?
// new Interval1d(slice.Z, slices[slicei + 1].Z - 0.5*settings.LayerHeightMM) :
// new Interval1d(slice.Z, slice.Z + 0.5*settings.LayerHeightMM);
double dz = 0.5 * settings.LayerHeightMM;
Interval1d zrange = new Interval1d(slice.Z - dz, slice.Z + dz);
double cellSize = 2.0f;
ToolpathsLayerGrid grid = new ToolpathsLayerGrid();
grid.Build(paths, zrange, cellSize);
foreach (GeneralPolygon2d poly in slice.Solids)
{
measure_poly(poly.Outer, slice.Z, grid, tolerance, appendPointF);
foreach (var hole in poly.Holes)
{
measure_poly(poly.Outer, slice.Z, grid, tolerance, appendPointF);
}
}
});
int N = points.Count;
for (int k = 0; k < N; ++k)
{
DeviationPt pt = points[k];
Vector3d v = origin + pt.pos;
v = MeshTransforms.ConvertZUpToYUp(v);
pt.pos = MeshTransforms.FlipLeftRightCoordSystems(v);
points[k] = pt;
}
Deviation = new DeviationData();
Deviation.DeviationPoints = points;
OnGeometryUpdateRequired?.Invoke(this);
}
