Exemplo n.º 1
0
        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();
        }
Exemplo n.º 2
0
        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;
                }
            }
        }
Exemplo n.º 3
0
        private void Settings_OnNewSettings(PrintSettings settings)
        {
            generateSupport.isOn = CC.Settings.GenerateSupport;
            UnityUIUtil.SetBackgroundColor(generateSupport, CotangentUI.NormalSettingColor);

            overhangAngle.text = CC.Settings.OverhangAngleDeg.ToString();
            UnityUIUtil.SetBackgroundColor(overhangAngle, CotangentUI.NormalSettingColor);

            supportMinZTips.isOn = CC.Settings.SupportMinZTips;
            UnityUIUtil.SetBackgroundColor(supportMinZTips, CotangentUI.NormalSettingColor);

            supportSpacing.text = CC.Settings.SupportStepX.ToString();
            UnityUIUtil.SetBackgroundColor(supportSpacing, CotangentUI.NormalSettingColor);

            supportShell.isOn = CC.Settings.EnableSupportShell;
            UnityUIUtil.SetBackgroundColor(supportShell, CotangentUI.NormalSettingColor);

            supportReleaseOpt.isOn = CC.Settings.EnableSupportReleaseOpt;
            UnityUIUtil.SetBackgroundColor(supportReleaseOpt, CotangentUI.NormalSettingColor);

            supportGap.text = CC.Settings.SupportSolidSpace.ToString();
            UnityUIUtil.SetBackgroundColor(supportGap, CotangentUI.NormalSettingColor);

            update_visibility();
        }
Exemplo n.º 4
0
        private void Settings_OnNewSettings(PrintSettings settings)
        {
            enableBridging.isOn = CC.Settings.EnableBridging;
            UnityUIUtil.SetBackgroundColor(enableBridging, CotangentUI.NormalSettingColor);

            maxDistance.text = CC.Settings.MaxBridgeDistanceMM.ToString();
            UnityUIUtil.SetBackgroundColor(maxDistance, CotangentUI.NormalSettingColor);

            update_visibility();
        }
Exemplo n.º 5
0
        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();
        }
Exemplo n.º 6
0
        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)
            {
            }
        }
Exemplo n.º 7
0
        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);
        }
Exemplo n.º 8
0
        public static void Initialize(FContext context)
        {
            ActiveContext = context;
            ActiveContext.Scene.SelectionChangedEvent += Scene_SelectionChangedEvent;
            ActiveContext.Scene.ChangedEvent          += Scene_ChangedEvent;

            PrinterDB = new SettingsDatabase();
            Settings  = new PrintSettings();

            PrinterDB.OnPrinterSelectionModified += PrinterDB_OnPrinterSelectionModified;
            PrinterDB.OnPresetSelectionModified  += PrinterDB_OnPresetSelectionModified;

            PrinterDB.Initialize();
            Settings.UpdateFromSettings(PrinterDB.ActivePreset.Settings);
            update_printer_bed();


            ObjSettings = new ObjectSettings();
            CCActions.UpdateObjectSettings();

            Objects = new PrintScene();

            Toolpather = new ToolpathGenerator();
            Toolpather.ToolpathsProgressEvent += (status) => {
                ToolpathProgressEvent?.Invoke(status);
            };

            Slicer = new GeometrySlicer();
            Slicer.SlicingProgressEvent += (status) => {
                SlicingProgressEvent?.Invoke(status);
            };
            Slicer.SlicingInvalidatedEvent += () => { InvalidateToolPaths(); };

            MeshAnalysis  = new MeshAnalysisManager();
            GCodeAnalysis = new GCodeAnalysisManager();
            GCodeAnalysis.EnableUpdates = false;

            FileMonitor = new ExternalFileMonitor();
        }
Exemplo n.º 9
0
        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);
        }
Exemplo n.º 10
0
            public void Compute(PrintSettings settings)
            {
                RequestCancel = false;

                printer =
                    new SingleMaterialFFFPrintGenerator(Meshes, SliceSet, PrintSettings);

                if (PrintSettings.EnableSupportReleaseOpt)
                {
                    printer.LayerPostProcessor = new SupportConnectionPostProcessor()
                    {
                        ZOffsetMM = PrintSettings.SupportReleaseGap
                    };
                }

                // if we aren't interpreting GCode, we want generator to return its path set
                printer.AccumulatePathSet = (InterpretGCodePaths == false);

                // set clip region
                Box2d clip_box = new Box2d(Vector2d.Zero,
                                           new Vector2d(settings.BedSizeXMM / 2, settings.BedSizeYMM / 2));

                printer.PathClipRegions = new List <GeneralPolygon2d>()
                {
                    new GeneralPolygon2d(new Polygon2d(clip_box.ComputeVertices()))
                };

                printer.ErrorF = (msg, trace) =>
                {
                    if (RequestCancel == false)
                    {
                        DebugUtil.Log(2, "Slicer Error! msg: {0} stack {1}", msg, trace);
                    }
                };

                DebugUtil.Log(2, "Generating gcode...");

                try
                {
                    if (printer.Generate() == false)
                    {
                        throw new Exception("generate failed");                           // this will be caught below
                    }
                    gcode = printer.Result;

                    //DebugUtil.Log(2, "Interpreting gcode...");

                    if (InterpretGCodePaths)
                    {
                        GCodeToToolpaths    converter   = new GCodeToToolpaths();
                        MakerbotInterpreter interpreter = new MakerbotInterpreter();
                        interpreter.AddListener(converter);
                        InterpretArgs interpArgs = new InterpretArgs();
                        interpreter.Interpret(gcode, interpArgs);
                        paths = converter.PathSet;
                    }
                    else
                    {
                        paths = printer.AccumulatedPaths;
                    }

                    //DebugUtil.Log(2, "Detecting layers...");
                    layerInfo = new LayersDetector(paths);

                    Success = true;
                }
                catch (Exception e)
                {
                    DebugUtil.Log("ToolpathGenerator.Compute: exception: " + e.Message);
                    Success = false;
                }

                Finished = true;
            }
Exemplo n.º 11
0
 private void Settings_OnSettingModified(PrintSettings settings)
 {
     //if ( saveButton != null )
     //    saveButton.enabled = true;
 }
Exemplo n.º 12
0
            public void Compute(PrintSettings printSettings)
            {
                int N = meshCopies.Count();

                slicer = new MeshPlanarSlicerPro()
                {
                    LayerHeightMM = printSettings.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 = printSettings.NozzleDiameterMM * 1.5,
                    SetMinZValue           = 0,
                    SliceFactoryF          = PlanarSlicePro.FactoryF
                };

                if (printSettings.OpenMode == PrintSettings.OpenMeshMode.Clipped)
                {
                    slicer.DefaultOpenPathMode = PrintMeshOptions.OpenPathsModes.Clipped;
                }
                else if (printSettings.OpenMode == PrintSettings.OpenMeshMode.Embedded)
                {
                    slicer.DefaultOpenPathMode = PrintMeshOptions.OpenPathsModes.Embedded;
                }
                else if (printSettings.OpenMode == PrintSettings.OpenMeshMode.Ignored)
                {
                    slicer.DefaultOpenPathMode = PrintMeshOptions.OpenPathsModes.Ignored;
                }

                if (printSettings.StartLayers > 0)
                {
                    int    start_layers       = printSettings.StartLayers;
                    double std_layer_height   = printSettings.LayerHeightMM;
                    double start_layer_height = printSettings.StartLayerHeightMM;
                    slicer.LayerHeightF = (layer_i) =>
                    {
                        return((layer_i < start_layers) ? start_layer_height : std_layer_height);
                    };
                }

                try
                {
                    MeshAssembly = new PrintMeshAssembly();

                    for (int k = 0; k < N; ++k)
                    {
                        DMesh3 mesh = meshCopies[k];
                        //Frame3f mapF = meshToScene[k];
                        PrintMeshSettings settings = new PrintMeshSettings();

                        var options = new PrintMeshOptions
                        {
                            IsSupport    = (settings.ObjectType == PrintMeshSettings.ObjectTypes.Support),
                            IsCavity     = (settings.ObjectType == PrintMeshSettings.ObjectTypes.Cavity),
                            IsCropRegion = (settings.ObjectType == PrintMeshSettings.ObjectTypes.CropRegion),
                            IsOpen       = settings.OuterShellOnly,
                            OpenPathMode = PrintMeshSettings.Convert(settings.OpenMeshMode),
                            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);

                        var decomposer = new MeshAssembly(mesh)
                        {
                            HasNoVoids = settings.NoVoids
                        };
                        decomposer.Decompose();

                        MeshAssembly.AddMeshes(decomposer.ClosedSolids, options);

                        PrintMeshOptions openOptions = options.Clone();
                        MeshAssembly.AddMeshes(decomposer.OpenMeshes, openOptions);
                    }

                    if (slicer.Add(MeshAssembly) == false)
                    {
                        throw new Exception("error adding PrintMeshAssembly to Slicer!!");
                    }

                    // set clip box
                    Box2d clip_box = new Box2d(
                        Vector2d.Zero,
                        new Vector2d(printSettings.BedSizeXMM / 2, printSettings.BedSizeYMM / 2));

                    slicer.ValidRegions = new List <GeneralPolygon2d>()
                    {
                        new GeneralPolygon2d(new Polygon2d(clip_box.ComputeVertices()))
                    };

                    SliceStack = slicer.Compute();

                    Success = true;
                }
                catch (Exception e)
                {
                    //DebugUtil.Log("GeometrySlicer.Compute: exception: " + e.Message);
                    System.Diagnostics.Debugger.Break();
                    Success = false;
                }

                Finished = true;
            }