Esempio n. 1
0
        private void SetInitalLayer()
        {
            activeLayerIndex = 0;
            if (loadedGCode.LineCount > 0)
            {
                int     firstExtrusionIndex = 0;
                Vector3 lastPosition        = loadedGCode.Instruction(0).Position;
                double  ePosition           = loadedGCode.Instruction(0).EPosition;
                // let's find the first layer that has extrusion if possible and go to that
                for (int i = 1; i < loadedGCode.LineCount; i++)
                {
                    PrinterMachineInstruction currentInstruction = loadedGCode.Instruction(i);
                    if (currentInstruction.EPosition > ePosition && lastPosition != currentInstruction.Position)
                    {
                        firstExtrusionIndex = i;
                        break;
                    }

                    lastPosition = currentInstruction.Position;
                }

                if (firstExtrusionIndex > 0)
                {
                    for (int layerIndex = 0; layerIndex < loadedGCode.NumChangesInZ; layerIndex++)
                    {
                        if (firstExtrusionIndex < loadedGCode.GetInstructionIndexAtLayer(layerIndex))
                        {
                            activeLayerIndex = Math.Max(0, layerIndex - 1);
                            break;
                        }
                    }
                }
            }
        }
Esempio n. 2
0
        public void CreateFeaturesForLayerIfRequired(int layerToCreate)
        {
            if (renderFeatures.Count == 0 ||
                renderFeatures[layerToCreate].Count > 0)
            {
                return;
            }

            List <RenderFeatureBase> renderFeaturesForLayer = renderFeatures[layerToCreate];

            int startRenderIndex = gCodeFileToDraw.GetFirstLayerInstruction(layerToCreate);
            int endRenderIndex   = gCodeFileToDraw.LineCount - 1;

            if (layerToCreate < gCodeFileToDraw.LayerCount - 1)
            {
                endRenderIndex = gCodeFileToDraw.GetFirstLayerInstruction(layerToCreate + 1);
            }

            for (int instructionIndex = startRenderIndex; instructionIndex < endRenderIndex; instructionIndex++)
            {
                PrinterMachineInstruction currentInstruction  = gCodeFileToDraw.Instruction(instructionIndex);
                PrinterMachineInstruction previousInstruction = currentInstruction;
                if (instructionIndex > 0)
                {
                    previousInstruction = gCodeFileToDraw.Instruction(instructionIndex - 1);
                }

                if (currentInstruction.Position == previousInstruction.Position)
                {
                    if (Math.Abs(currentInstruction.EPosition - previousInstruction.EPosition) > 0)
                    {
                        // this is a retraction
                        renderFeaturesForLayer.Add(new RenderFeatureRetract(currentInstruction.Position, currentInstruction.EPosition - previousInstruction.EPosition, currentInstruction.ExtruderIndex, currentInstruction.FeedRate));
                    }
                    if (currentInstruction.Line.StartsWith("G10"))
                    {
                        renderFeaturesForLayer.Add(new RenderFeatureRetract(currentInstruction.Position, -1, currentInstruction.ExtruderIndex, currentInstruction.FeedRate));
                    }
                    else if (currentInstruction.Line.StartsWith("G11"))
                    {
                        renderFeaturesForLayer.Add(new RenderFeatureRetract(currentInstruction.Position, 1, currentInstruction.ExtruderIndex, currentInstruction.FeedRate));
                    }
                }
                else
                {
                    if (gCodeFileToDraw.IsExtruding(instructionIndex))
                    {
                        double layerThickness = gCodeFileToDraw.GetLayerHeight(layerToCreate);

                        Color extrusionColor = ExtrusionColors.GetColorForSpeed((float)currentInstruction.FeedRate);
                        renderFeaturesForLayer.Add(new RenderFeatureExtrusion(previousInstruction.Position, currentInstruction.Position, currentInstruction.ExtruderIndex, currentInstruction.FeedRate, currentInstruction.EPosition - previousInstruction.EPosition, gCodeFileToDraw.GetFilamentDiameter(), layerThickness, extrusionColor));
                    }
                    else
                    {
                        renderFeaturesForLayer.Add(new RenderFeatureTravel(previousInstruction.Position, currentInstruction.Position, currentInstruction.ExtruderIndex, currentInstruction.FeedRate));
                    }
                }
            }
        }
		public void ApplyLeveling(GCodeFile unleveledGCode)
		{
			for (int i = 0; i < unleveledGCode.LineCount; i++)
			{
				PrinterMachineInstruction instruction = unleveledGCode.Instruction(i);
				Vector3 currentDestination = instruction.Position;
				instruction.Line = ApplyLeveling(currentDestination, instruction.movementType, instruction.Line);
			}
		}
		public ColorGradientWidget(GCodeFile gcodeFileTest)
			: base(FlowDirection.TopToBottom)
		{
			BackgroundColor = new RGBA_Bytes(0, 0, 0, 120);

			HashSet<float> speeds = new HashSet<float>();
			PrinterMachineInstruction previousInstruction = gcodeFileTest.Instruction(0);
			for (int i = 1; i < gcodeFileTest.LineCount; i++)
			{
				PrinterMachineInstruction instruction = gcodeFileTest.Instruction(i);
				if (instruction.EPosition > previousInstruction.EPosition && (instruction.Line.IndexOf('X') != -1 || instruction.Line.IndexOf('Y') != -1))
				{
					speeds.Add((float)instruction.FeedRate);
				}
				previousInstruction = instruction;
			}

			ExtrusionColors extrusionColors = new ExtrusionColors();

			speeds.Select(speed => extrusionColors.GetColorForSpeed(speed)).ToArray();

			if(speeds.Count <= 0)
			{
				// There are no paths so don't generate the rest of the widget.
				return;
			}

			float min = speeds.Min();
			float max = speeds.Max();
			int maxItems = Math.Min(7, speeds.Count());

			int count = maxItems - 1;
			float increment = (max - min) / count;
			int index = 0;

			int[] rangeValues;
			if (speeds.Count < 8)
			{
				rangeValues = speeds.Select(s => (int)s).OrderBy(i => i).ToArray();
			}
			else
			{
				rangeValues = Enumerable.Range(0, maxItems).Select(x => (int)(min + increment * index++)).ToArray();
			}

			RGBA_Bytes[] speedColors = rangeValues.OrderBy(s => s).Select(speed => extrusionColors.GetColorForSpeed(speed)).ToArray();

			for (int i = 0; i < speedColors.Length; i++)
			{
				RGBA_Bytes color = speedColors[i];
				int speed = rangeValues[i];

				GuiWidget colorWidget = new GuiWidget();
				colorWidget.Width = 20;
				colorWidget.Height = 20;
				colorWidget.BackgroundColor = color;
				colorWidget.Margin = new BorderDouble(2);
				double feedRateToMMPerSecond = speed / 60;

				ColorToSpeedWidget colorToSpeedWidget = new ColorToSpeedWidget(colorWidget, feedRateToMMPerSecond);
				this.AddChild(colorToSpeedWidget);
			}

			Margin = new BorderDouble(5, 5, 200, 50);
			HAnchor |= Agg.UI.HAnchor.ParentLeft;
			VAnchor = Agg.UI.VAnchor.ParentTop;
		}
Esempio n. 5
0
        public void CreateFeaturesForLayerIfRequired(int layerToCreate)
        {
            if (extrusionColors == null &&
                gCodeFileToDraw != null &&
                gCodeFileToDraw.LineCount > 0)
            {
                extrusionColors = new ExtrusionColors();
                HashSet <float>           speeds          = new HashSet <float>();
                PrinterMachineInstruction prevInstruction = gCodeFileToDraw.Instruction(0);
                for (int i = 1; i < gCodeFileToDraw.LineCount; i++)
                {
                    PrinterMachineInstruction instruction = gCodeFileToDraw.Instruction(i);
                    if (instruction.EPosition > prevInstruction.EPosition && (instruction.Line.IndexOf('X') != -1 || instruction.Line.IndexOf('Y') != -1))
                    {
                        speeds.Add((float)instruction.FeedRate);
                    }

                    prevInstruction = instruction;
                }

                foreach (float speed in speeds)
                {
                    extrusionColors.GetColorForSpeed(speed);
                }
            }

            if (renderFeatures.Count == 0 ||
                renderFeatures[layerToCreate].Count > 0)
            {
                return;
            }

            List <RenderFeatureBase> renderFeaturesForLayer = renderFeatures[layerToCreate];

            int startRenderIndex = gCodeFileToDraw.GetInstructionIndexAtLayer(layerToCreate);
            int endRenderIndex   = gCodeFileToDraw.LineCount - 1;

            if (layerToCreate < gCodeFileToDraw.NumChangesInZ - 1)
            {
                endRenderIndex = gCodeFileToDraw.GetInstructionIndexAtLayer(layerToCreate + 1);
            }

            for (int instructionIndex = startRenderIndex; instructionIndex < endRenderIndex; instructionIndex++)
            {
                PrinterMachineInstruction currentInstruction  = gCodeFileToDraw.Instruction(instructionIndex);
                PrinterMachineInstruction previousInstruction = currentInstruction;
                if (instructionIndex > 0)
                {
                    previousInstruction = gCodeFileToDraw.Instruction(instructionIndex - 1);
                }

                if (currentInstruction.Position == previousInstruction.Position)
                {
                    if (Math.Abs(currentInstruction.EPosition - previousInstruction.EPosition) > 0)
                    {
                        // this is a retraction
                        renderFeaturesForLayer.Add(new RenderFeatureRetract(currentInstruction.Position, currentInstruction.EPosition - previousInstruction.EPosition, currentInstruction.ExtruderIndex, currentInstruction.FeedRate));
                    }
                    if (currentInstruction.Line.StartsWith("G10"))
                    {
                        renderFeaturesForLayer.Add(new RenderFeatureRetract(currentInstruction.Position, -1, currentInstruction.ExtruderIndex, currentInstruction.FeedRate));
                    }
                    else if (currentInstruction.Line.StartsWith("G11"))
                    {
                        renderFeaturesForLayer.Add(new RenderFeatureRetract(currentInstruction.Position, 1, currentInstruction.ExtruderIndex, currentInstruction.FeedRate));
                    }
                }
                else
                {
                    if (gCodeFileToDraw.IsExtruding(instructionIndex))
                    {
                        double layerThickness = gCodeFileToDraw.GetLayerHeight();
                        if (layerToCreate == 0)
                        {
                            layerThickness = gCodeFileToDraw.GetFirstLayerHeight();
                        }

                        Color extrusionColor = extrusionColors.GetColorForSpeed((float)currentInstruction.FeedRate);
                        renderFeaturesForLayer.Add(new RenderFeatureExtrusion(previousInstruction.Position, currentInstruction.Position, currentInstruction.ExtruderIndex, currentInstruction.FeedRate, currentInstruction.EPosition - previousInstruction.EPosition, gCodeFileToDraw.GetFilamentDiameter(), layerThickness, extrusionColor));
                    }
                    else
                    {
                        renderFeaturesForLayer.Add(new RenderFeatureTravel(previousInstruction.Position, currentInstruction.Position, currentInstruction.ExtruderIndex, currentInstruction.FeedRate));
                    }
                }
            }
        }
        private void SaveGCodeToNewLocation(string source, string dest)
        {
            if (ActivePrinterProfile.Instance.DoPrintLeveling)
            {
                GCodeFile unleveledGCode = new GCodeFile(source);
                if (applyLeveling.Checked)
                {
                    PrintLevelingPlane.Instance.ApplyLeveling(unleveledGCode);

                    PrintLevelingData levelingData = PrintLevelingData.GetForPrinter(ActivePrinterProfile.Instance.ActivePrinter);
                    if (levelingData != null)
                    {
                        for (int i = 0; i < unleveledGCode.Count; i++)
                        {
                            PrinterMachineInstruction instruction = unleveledGCode.Instruction(i);

                            List<string> linesToWrite = null;
                            switch (levelingData.levelingSystem)
                            {
                                case PrintLevelingData.LevelingSystem.Probe2Points:
                                    linesToWrite = LevelWizard2Point.ProcessCommand(instruction.Line);
                                    break;

                                case PrintLevelingData.LevelingSystem.Probe3Points:
                                    linesToWrite = LevelWizard3Point.ProcessCommand(instruction.Line);
                                    break;
                            }

                            instruction.Line = linesToWrite[0];
                            linesToWrite.RemoveAt(0);

                            // now insert any new lines
                            foreach(string line in linesToWrite)
                            {
                                PrinterMachineInstruction newInstruction = new PrinterMachineInstruction(line);
                                unleveledGCode.Insert(++i, newInstruction); 
                            }
                        }
                    }
                }
                unleveledGCode.Save(dest);
            }
            else
            {
                File.Copy(source, dest, true);
            }
            ShowFileIfRequested(dest);
        }
Esempio n. 7
0
        public void CreateFeaturesForLayerIfRequired(int layerToCreate)
        {
            if (all.layers.Count == 0 ||
                all.layers[layerToCreate].features.Count > 0)
            {
                return;
            }

            List <RenderFeatureBase> renderFeaturesForLayer = all.layers[layerToCreate].features;

            int startRenderIndex = gCodeFileToDraw.GetFirstLayerInstruction(layerToCreate);
            int endRenderIndex   = gCodeFileToDraw.LineCount - 1;

            if (layerToCreate < gCodeFileToDraw.LayerCount - 1)
            {
                endRenderIndex = gCodeFileToDraw.GetFirstLayerInstruction(layerToCreate + 1);
            }

            for (int instructionIndex = startRenderIndex; instructionIndex < endRenderIndex; instructionIndex++)
            {
                PrinterMachineInstruction currentInstruction  = gCodeFileToDraw.Instruction(instructionIndex);
                PrinterMachineInstruction previousInstruction = currentInstruction;
                if (instructionIndex > 0)
                {
                    previousInstruction = gCodeFileToDraw.Instruction(instructionIndex - 1);
                }

                if (currentInstruction.Position == previousInstruction.Position)
                {
                    double eMovement = 0;
                    if (currentInstruction.PositionSet != PositionSet.E)
                    {
                        eMovement = currentInstruction.EPosition - previousInstruction.EPosition;
                    }

                    if (Math.Abs(eMovement) > 0)
                    {
                        // this is a retraction
                        renderFeaturesForLayer.Add(new RenderFeatureRetract(instructionIndex, currentInstruction.Position, eMovement, currentInstruction.ToolIndex, currentInstruction.FeedRate));
                    }

                    if (currentInstruction.Line.StartsWith("G10"))
                    {
                        renderFeaturesForLayer.Add(new RenderFeatureRetract(instructionIndex, currentInstruction.Position, -1, currentInstruction.ToolIndex, currentInstruction.FeedRate));
                    }
                    else if (currentInstruction.Line.StartsWith("G11"))
                    {
                        renderFeaturesForLayer.Add(new RenderFeatureRetract(instructionIndex, currentInstruction.Position, 1, currentInstruction.ToolIndex, currentInstruction.FeedRate));
                    }
                }
                else
                {
                    var extrusionAmount    = currentInstruction.EPosition - previousInstruction.EPosition;
                    var filamentDiameterMm = gCodeFileToDraw.GetFilamentDiameter();

                    if (gCodeFileToDraw.IsExtruding(instructionIndex))
                    {
                        double layerThickness = gCodeFileToDraw.GetLayerHeight(layerToCreate);

                        Color extrusionColor = ExtrusionColors.GetColorForSpeed((float)currentInstruction.FeedRate);
                        renderFeaturesForLayer.Add(
                            new RenderFeatureExtrusion(
                                instructionIndex,
                                previousInstruction.Position,
                                currentInstruction.Position,
                                currentInstruction.ToolIndex,
                                currentInstruction.FeedRate,
                                extrusionAmount,
                                filamentDiameterMm,
                                layerThickness,
                                extrusionColor,
                                this.Gray));
                    }
                    else
                    {
                        if (extrusionAmount < 0)
                        {
                            double moveLength     = (currentInstruction.Position - previousInstruction.Position).Length;
                            double filamentRadius = filamentDiameterMm / 2;
                            double areaSquareMm   = (filamentRadius * filamentRadius) * Math.PI;

                            var extrusionVolumeMm3 = (float)(areaSquareMm * extrusionAmount);
                            var area = extrusionVolumeMm3 / moveLength;
                        }

                        renderFeaturesForLayer.Add(
                            new RenderFeatureTravel(
                                instructionIndex,
                                previousInstruction.Position,
                                currentInstruction.Position,
                                currentInstruction.ToolIndex,
                                currentInstruction.FeedRate,
                                extrusionAmount < 0));
                    }
                }
            }
        }