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); } }