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;
}
}
}
static void generate_stacked_polygon(SingleMaterialFFFCompiler compiler,
SingleMaterialFFFSettings settings)
{
int NLayers = 10;
for (int layer_i = 0; layer_i < NLayers; ++layer_i)
{
// create data structures for organizing this layer
ToolpathSetBuilder layer_builder = new ToolpathSetBuilder();
SequentialScheduler2d scheduler = new SequentialScheduler2d(layer_builder, settings);
if (layer_i == 0)
{
scheduler.SpeedHint = SchedulerSpeedHint.Careful;
}
// initialize layer
layer_builder.Initialize(compiler.NozzlePosition);
// layer-up
layer_builder.AppendZChange(settings.LayerHeightMM, settings.ZTravelSpeed);
// schedule a circle
FillPolygon2d circle_poly = new FillPolygon2d(Polygon2d.MakeCircle(25.0f, 64));
circle_poly.TypeFlags = FillTypeFlags.OuterPerimeter;
scheduler.AppendPolygon2d(circle_poly);
// pass paths to compiler
compiler.AppendPaths(layer_builder.Paths, settings);
}
}
public SliceFeature(Mesh input)
{
MeshCheck meshCheck = new MeshCheck();
meshCheck.setMesh(input);
DMesh3 mesh = meshCheck.ToUnityWatertightMesh().ToDMesh3();
if (!mesh.IsClosed())
{
return;
}
// 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
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);
settings = new RepRapSettings(RepRap.Models.Unknown);
}
public static PrintTestRunner CreateTestRunner(string caseName, SingleMaterialFFFSettings settings)
{
var resultGenerator = CreateResultGenerator(settings);
var resultAnalyzer = new ResultAnalyzer <FeatureInfo>(new FeatureInfoFactoryFFF(), new ConsoleLogger());
return(new PrintTestRunner(caseName, resultGenerator, resultAnalyzer));
}
public SingleMaterialFFFSettings CloneCurrentSettings()
{
SingleMaterialFFFSettings clone = Active.CloneAs <SingleMaterialFFFSettings>();
WriteToSettings(clone);
return(clone);
}
private void Settings_OnSettingModified(PrintSettings settings)
{
SingleMaterialFFFSettings S = CC.PrinterDB.ActivePreset.Settings as SingleMaterialFFFSettings;
if (generateSupport.isOn != CC.Settings.GenerateSupport)
{
generateSupport.isOn = CC.Settings.GenerateSupport;
}
UnityUIUtil.SetBackgroundColor(generateSupport, settings.GenerateSupport_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(overhangAngle, settings.OverhangAngleDeg_Modified?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(supportMinZTips, settings.SupportMinZTips_Modified?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(supportSpacing, settings.SupportStepX_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(supportShell, settings.EnableSupportShell_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(supportReleaseOpt, settings.EnableSupportReleaseOpt_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(supportGap, settings.SupportSolidSpace_Modified?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
update_visibility();
}
private void Settings_OnSettingModified(PrintSettings settings)
{
SingleMaterialFFFSettings S = CC.PrinterDB.ActivePreset.Settings as SingleMaterialFFFSettings;
UnityUIUtil.SetBackgroundColor(nozzleWidth, settings.NozzleDiameterMM_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(filamentDiam, settings.FilamentDiameterMM_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(nozzleTemp, settings.ExtruderTempC_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(bedTemp, settings.BedTempC_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(printSpeed, settings.PrintSpeedMMS_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(travelSpeed, settings.TravelSpeedMMS_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(fanSpeed, settings.FanSpeedX_Modified?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(bedSizeX, settings.BedSizeXMM_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(bedSizeY, settings.BedSizeYMM_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(bedSizeZ, settings.BedSizeZMM_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
}
protected override void CopyFieldsTo(SingleMaterialFFFSettings to)
{
base.CopyFieldsTo(to);
if (to is PrintrbotSettings)
{
(to as PrintrbotSettings).EnableAutoBedLevel = this.EnableAutoBedLevel;
}
}
public void SetPaths(ToolpathSet paths, SingleMaterialFFFSettings knownSettings = null)
{
Paths = paths;
double layer_height = (knownSettings != null) ? knownSettings.LayerHeightMM : 0;
Layers = new LayersDetector(Paths, layer_height);
CurrentLayer = 0;
}
public BaseDepositionAssembler MakePrintrbotAssembler(
GCodeBuilder builder, SingleMaterialFFFSettings settings)
{
var asm = new RepRapAssembler(builder, settings);
asm.HeaderCustomizerF = HeaderCustomF;
return(asm);
}
public BaseDepositionAssembler MakePrusaAssembler(
GCodeBuilder builder, SingleMaterialFFFSettings settings)
{
var asm = new RepRapAssembler(builder, settings);
asm.HomeSequenceF = this.HomeSequence;
asm.HeaderCustomizerF = HeaderCustomF;
asm.TravelGCode = 1;
return(asm);
}
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);
}
private void Settings_OnSettingModified(PrintSettings settings)
{
SingleMaterialFFFSettings S = CC.PrinterDB.ActivePreset.Settings as SingleMaterialFFFSettings;
UnityUIUtil.SetBackgroundColor(enableBridging, settings.EnableBridging_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(maxDistance, settings.MaxBridgeDistanceMM_Modified?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
update_visibility();
}
public void UpdateFromSettings(PlanarAdditiveSettings settings)
{
if (settings == null)
{
return;
}
if (settings is SingleMaterialFFFSettings == false)
{
throw new Exception("PrintSettings.UpdateFromSettings: invalid settings type!");
}
SingleMaterialFFFSettings ss = settings as SingleMaterialFFFSettings;
Active = ss;
LayerHeightMM = ss.LayerHeightMM;
OuterShells = ss.Shells;
RoofLayers = ss.RoofLayers;
FloorLayers = ss.FloorLayers;
InfillStepX = ss.SparseLinearInfillStepX;
ClipSelfOverlaps = ss.ClipSelfOverlaps;
InteriorSolidRegionShells = ss.InteriorSolidRegionShells;
StartLayers = ss.StartLayers;
StartLayerHeightMM = ss.StartLayerHeightMM;
GenerateSupport = ss.GenerateSupport;
OverhangAngleDeg = ss.SupportOverhangAngleDeg;
SupportMinZTips = ss.SupportMinZTips;
EnableSupportShell = ss.EnableSupportShell;
EnableSupportReleaseOpt = ss.EnableSupportReleaseOpt;
SupportStepX = ss.SupportSpacingStepX;
SupportSolidSpace = ss.SupportSolidSpace;
EnableBridging = ss.EnableBridging;
MaxBridgeDistanceMM = ss.MaxBridgeWidthMM;
LayerRangeMin = ss.LayerRangeFilter.a + 1;
LayerRangeMax = ss.LayerRangeFilter.b + 1;
NozzleDiameterMM = ss.Machine.NozzleDiamMM;
FilamentDiameterMM = ss.Machine.FilamentDiamMM;
ExtruderTempC = ss.ExtruderTempC;
BedTempC = ss.HeatedBedTempC;
PrintSpeedMMS = (int)Math.Round(ss.RapidExtrudeSpeed / 60, 0);
TravelSpeedMMS = (int)Math.Round(ss.RapidTravelSpeed / 60, 0);
FanSpeedX = (int)Math.Round(ss.FanSpeedX * 100, 0);
BedSizeXMM = (int)ss.Machine.BedSizeXMM;
BedSizeYMM = (int)ss.Machine.BedSizeYMM;
BedSizeZMM = (int)ss.Machine.MaxHeightMM;
bValueModified = false;
OnNewSettings?.Invoke(this);
}
private void Settings_OnSettingModified(PrintSettings settings)
{
SingleMaterialFFFSettings S = CC.PrinterDB.ActivePreset.Settings as SingleMaterialFFFSettings;
UnityUIUtil.SetBackgroundColor(layerRangeMin, settings.LayerRangeMin_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(layerRangeMax, settings.LayerRangeMax_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(startLayers, settings.StartLayers_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(startLayerHeight, settings.StartLayerHeightMM_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
update_visibility();
}
public virtual ToolpathSO Create(ToolpathSet toolpaths, SingleMaterialFFFSettings settings, SOMaterial setMaterial)
{
AssignSOMaterial(setMaterial); // need to do this to setup BaseSO material stack
parentGO = GameObjectFactory.CreateParentGO(UniqueNames.GetNext("Toolpath"));
Toolpaths = toolpaths;
Settings = settings;
polylines_valid = false;
PolylinePool = new fGameObjectPool <fPolylineGameObject>(allocate_polyline_go);
PolylinePool.FreeF = (go) => {
//go.SetVertices(EmptyToolpathCurve, false, true);
};
return(this);
}
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();
}
static void generate_stacked_wavy_circle(SingleMaterialFFFCompiler compiler,
SingleMaterialFFFSettings settings)
{
double height = 20.0; // mm
int NLayers = (int)(height / settings.LayerHeightMM); // 20mm
int NSteps = 128;
double radius = 15.0;
double frequency = 6;
double scale = 5.0;
for (int layer_i = 0; layer_i < NLayers; ++layer_i)
{
// create data structures for organizing this layer
ToolpathSetBuilder layer_builder = new ToolpathSetBuilder();
SequentialScheduler2d scheduler = new SequentialScheduler2d(layer_builder, settings);
if (layer_i == 0)
{
scheduler.SpeedHint = SchedulerSpeedHint.Careful;
}
// initialize and layer-up
layer_builder.Initialize(compiler.NozzlePosition);
layer_builder.AppendZChange(settings.LayerHeightMM, settings.ZTravelSpeed);
// start with circle
FillPolygon2d circle_poly = new FillPolygon2d(Polygon2d.MakeCircle(radius, NSteps));
// apply a wave deformation to circle, with wave height increasing with Z
double layer_scale = MathUtil.Lerp(0, scale, (double)layer_i / (double)NLayers);
for (int i = 0; i < NSteps; ++i)
{
Vector2d v = circle_poly[i];
double angle = Math.Atan2(v.y, v.x);
double r = v.Length;
r += layer_scale * Math.Sin(frequency * angle);
circle_poly[i] = r * v.Normalized;
}
circle_poly.TypeFlags = FillTypeFlags.OuterPerimeter;
scheduler.AppendPolygon2d(circle_poly);
// pass paths to compiler
compiler.AppendPaths(layer_builder.Paths, settings);
}
}
public void WriteToSettings(SingleMaterialFFFSettings settings)
{
settings.LayerHeightMM = LayerHeightMM;
settings.Shells = OuterShells;
settings.RoofLayers = RoofLayers;
settings.FloorLayers = FloorLayers;
settings.SparseLinearInfillStepX = InfillStepX;
settings.ClipSelfOverlaps = ClipSelfOverlaps;
settings.InteriorSolidRegionShells = InteriorSolidRegionShells;
settings.StartLayers = StartLayers;
settings.StartLayerHeightMM = StartLayerHeightMM;
settings.GenerateSupport = GenerateSupport;
settings.SupportOverhangAngleDeg = OverhangAngleDeg;
settings.SupportMinZTips = SupportMinZTips;
settings.EnableSupportShell = EnableSupportShell;
settings.EnableSupportReleaseOpt = EnableSupportReleaseOpt;
settings.SupportSpacingStepX = SupportStepX;
settings.SupportSolidSpace = SupportSolidSpace;
settings.EnableBridging = EnableBridging;
settings.MaxBridgeWidthMM = MaxBridgeDistanceMM;
int use_min = Math.Max(0, LayerRangeMin - 1);
int use_max = (LayerRangeMax == 0) ? 999999999 : LayerRangeMax - 1;
if (use_max < use_min)
{
use_max = use_min;
}
settings.LayerRangeFilter = new g3.Interval1i(use_min, use_max);
settings.FanSpeedX = (double)FanSpeedX / 100.0;
settings.Machine.NozzleDiamMM = NozzleDiameterMM;
settings.Machine.FilamentDiamMM = FilamentDiameterMM;
settings.ExtruderTempC = ExtruderTempC;
settings.HeatedBedTempC = BedTempC;
settings.RapidExtrudeSpeed = PrintSpeedMMS * 60;
settings.RapidTravelSpeed = TravelSpeedMMS * 60;
settings.Machine.BedSizeXMM = BedSizeXMM;
settings.Machine.BedSizeYMM = BedSizeYMM;
settings.Machine.MaxHeightMM = BedSizeZMM;
}
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 CloneBareAsCurve()
{
// Arrange
var settings = new SingleMaterialFFFSettings();
var loop = FillFactory.CreateTriangleCCW();
loop.FillType = settings.FillTypeFactory.OuterPerimeter();
loop.PerimeterOrder = 100;
loop.IsHoleShell = true;
loop.FillThickness = 3;
// Act
var clone = loop.CloneBareAsCurve();
// Assert
Assert.AreEqual(100, clone.PerimeterOrder);
Assert.AreEqual(3, clone.FillThickness);
Assert.IsTrue(clone.IsHoleShell);
Assert.IsInstanceOfType(clone.FillType, typeof(OuterPerimeterFillType));
}
static void generate_square(SingleMaterialFFFCompiler compiler,
SingleMaterialFFFSettings settings)
{
ToolpathSetBuilder builder = new ToolpathSetBuilder();
builder.Initialize(compiler.NozzlePosition);
// layer-up
builder.AppendZChange(settings.LayerHeightMM, settings.ZTravelSpeed);
// draw rectangle
float left = 0, right = 50, bottom = -20, top = 20;
builder.AppendTravel(new Vector2d(left, bottom), settings.RapidTravelSpeed);
builder.AppendExtrude(new Vector2d(right, bottom), settings.CarefulExtrudeSpeed);
builder.AppendExtrude(new Vector2d(right, top), settings.CarefulExtrudeSpeed);
builder.AppendExtrude(new Vector2d(left, top), settings.CarefulExtrudeSpeed);
builder.AppendExtrude(new Vector2d(left, bottom), settings.CarefulExtrudeSpeed);
compiler.AppendPaths(builder.Paths, settings);
}
private void Settings_OnSettingModified(PrintSettings settings)
{
SingleMaterialFFFSettings S = CC.PrinterDB.ActivePreset.Settings as SingleMaterialFFFSettings;
UnityUIUtil.SetBackgroundColor(layerHeight, settings.LayerHeightMM_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(infill, settings.InfillStepX_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(shells, settings.OuterShells_Modified?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(roofLayers, settings.RoofLayers_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(floorLayers, settings.FloorLayers_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(interiorSolidRegionShells, settings.InteriorSolidRegionShells_Modified?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
UnityUIUtil.SetBackgroundColor(clipOverlaps, settings.ClipSelfOverlaps_Modified ?
CotangentUI.ModifiedSettingColor : CotangentUI.NormalSettingColor);
}
public static ResultGenerator <SingleMaterialFFFPrintGenerator, SingleMaterialFFFSettings> CreateResultGenerator(SingleMaterialFFFSettings settings)
{
var logger = new ConsoleLogger();
return(new ResultGenerator <SingleMaterialFFFPrintGenerator, SingleMaterialFFFSettings>(
new PrintGeneratorManager <SingleMaterialFFFPrintGenerator, SingleMaterialFFFSettings>(settings, "", "", logger), logger));
}
static void generate_vertical(SingleMaterialFFFCompiler compiler,
SingleMaterialFFFSettings settings)
{
ToolpathSetBuilder builder = new ToolpathSetBuilder();
builder.Initialize(compiler.NozzlePosition);
// layer-up
builder.AppendZChange(settings.LayerHeightMM, settings.ZTravelSpeed);
// draw circle
int N = 32;
Polygon2d circle = Polygon2d.MakeCircle(25.0f, N, -MathUtil.HalfPI);
builder.AppendTravel(circle[0], settings.RapidTravelSpeed);
for (int k = 1; k <= N; k++)
{
builder.AppendExtrude(circle[k % N], settings.CarefulExtrudeSpeed);
}
// layer-up
builder.AppendZChange(settings.LayerHeightMM, settings.ZTravelSpeed);
double height = 5.0f;
double z_layer = builder.Position.z;
double z_high = z_layer + height;
for (int k = 1; k <= N; k++)
{
Vector2d p2 = circle[k % N];
double z = (k % 2 == 1) ? z_high : z_layer;
Vector3d p3 = new Vector3d(p2.x, p2.y, z);
builder.AppendExtrude(p3, settings.CarefulExtrudeSpeed / 4);
// dwell at tops
if (z == z_high)
{
AssemblerCommandsToolpath dwell_path = new AssemblerCommandsToolpath()
{
AssemblerF = make_tip
};
builder.AppendPath(dwell_path);
}
}
// move up to z_high
builder.AppendZChange(height, settings.ZTravelSpeed);
// draw circle again
builder.AppendTravel(circle[0], settings.RapidTravelSpeed);
for (int k = 1; k <= N; k++)
{
builder.AppendExtrude(circle[k % N], settings.RapidExtrudeSpeed);
}
// draw teeth again
z_layer = builder.Position.z;
z_high = z_layer + height;
for (int k = 1; k <= N; k++)
{
Vector2d p2 = circle[k % N];
double z = (k % 2 == 1) ? z_high : z_layer;
Vector3d p3 = new Vector3d(p2.x, p2.y, z);
builder.AppendExtrude(p3, settings.CarefulExtrudeSpeed / 4);
// dwell at tops
if (z == z_high)
{
AssemblerCommandsToolpath dwell_path = new AssemblerCommandsToolpath()
{
AssemblerF = make_tip
};
builder.AppendPath(dwell_path);
}
}
// move up to z_high
builder.AppendZChange(height, settings.ZTravelSpeed);
// draw circle again
builder.AppendTravel(circle[0], settings.RapidTravelSpeed);
for (int k = 1; k <= N; k++)
{
builder.AppendExtrude(circle[k % N], settings.RapidExtrudeSpeed);
}
compiler.AppendPaths(builder.Paths, settings);
}
static void generate_vertical_wave(SingleMaterialFFFCompiler compiler,
SingleMaterialFFFSettings settings)
{
ToolpathSetBuilder builder = new ToolpathSetBuilder();
builder.Initialize(compiler.NozzlePosition);
// layer-up
builder.AppendZChange(settings.LayerHeightMM, settings.ZTravelSpeed);
int N = 24;
Polygon2d circle = Polygon2d.MakeCircle(15.0f, N, -MathUtil.HalfPI);
int REPEAT = 5;
for (int ri = 0; ri < REPEAT; ++ri)
{
builder.AppendTravel(circle[0], settings.RapidTravelSpeed);
for (int k = 1; k <= N; k++)
{
builder.AppendExtrude(circle[k % N], settings.CarefulExtrudeSpeed / 4);
}
builder.AppendZChange(settings.LayerHeightMM, settings.ZTravelSpeed);
builder.AppendTravel(circle[0], settings.RapidTravelSpeed);
for (int k = 1; k <= N; k++)
{
builder.AppendExtrude(circle[k % N], settings.CarefulExtrudeSpeed / 4);
}
builder.AppendZChange(settings.LayerHeightMM, settings.ZTravelSpeed);
if (ri == REPEAT - 1)
{
break;
}
// make on the move up we should also move 'back' a bit,
// to counteract forward pull force?
double height = 1.0f;
double h_fudge = 0.0f;
double z_stick = -0.05f;
double z_layer = builder.Position.z;
double top_z = z_layer + height + h_fudge;
for (int k = 0; k < N - 1; k++)
{
Vector2d pcur = circle[k % N], pnext = circle[(k + 1) % N];
Vector3d pUp = new Vector3d(pcur.x, pcur.y, top_z);
builder.AppendExtrude(pUp, settings.CarefulExtrudeSpeed / 8);
builder.AppendDwell(500, false);
Vector3d pDown = new Vector3d(pnext.x, pnext.y, z_layer + z_stick);
builder.AppendExtrude(pDown, settings.CarefulExtrudeSpeed / 8);
}
// move up to z_high
Vector3d vpos = new Vector3d(circle[0].x, circle[0].y, z_layer + height);
builder.AppendExtrude(vpos, settings.CarefulExtrudeSpeed / 8);
}
compiler.AppendPaths(builder.Paths, settings);
}
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 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 SLSCompiler(SingleMaterialFFFSettings settings)
{
Settings = settings;
}
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);
}
}
