public void ParserGCode_G1_Correct_G01_G41_X10_X20_Test()
{
ParserGCode p = new ParserGCode();
List <GCodeLine> result = p.Parse("G01 G41 X10 " + Environment.NewLine + "X20");
List <GCodeLine> rightresult = new List <GCodeLine>();
GCodeLine gCodeLineResult1 = new GCodeLine(1);
gCodeLineResult1.Command.Add("G1");
gCodeLineResult1.Command.Add("G41");
gCodeLineResult1.XPos = 10;
GCodeLine gCodeLineResult2 = new GCodeLine(2);
gCodeLineResult2.Command.Add("G1");
gCodeLineResult2.XPos = 20;
rightresult.Add(gCodeLineResult1);
rightresult.Add(gCodeLineResult2);
rightresult.Add(new GCodeLine(3));
string resulttext = ListToString(result);
string rightresulttext = ListToString(rightresult);
Assert.AreEqual(resulttext, rightresulttext);
}
public void AddLine()
{
MockGCodeAccumulator mockGCA = new MockGCodeAccumulator();
GCodeBuilder gcb = new GCodeBuilder(mockGCA);
GCodeLine l = new GCodeLine(100, LineType.Comment);
l.Comment = "testComment";
gcb.AddLine(l);
Assert.IsTrue(mockGCA.Lines.Count == 1);
Assert.AreEqual("testComment", mockGCA.Lines[0].Comment);
Assert.AreEqual(LineType.Comment, mockGCA.Lines[0].Type);
Assert.AreEqual(0, mockGCA.Lines[0].LineNumber);
GCodeLine l2 = new GCodeLine(100, LineType.GCode);
l2.Comment = "testComment2";
l2.Code = 10;
GCodeParam p = GCodeParam.Double(2.5, "X");
l2.Parameters = new GCodeParam[1] {
p
};
gcb.AddLine(l2);
Assert.IsTrue(mockGCA.Lines.Count == 2);
Assert.AreEqual("testComment2", mockGCA.Lines[1].Comment);
Assert.AreEqual(10, mockGCA.Lines[1].Code);
Assert.AreEqual(LineType.GCode, mockGCA.Lines[1].Type);
Assert.AreEqual(1, mockGCA.Lines[1].LineNumber);
Assert.AreEqual(p, mockGCA.Lines[1].Parameters[0]);
}
protected virtual Vector3d ExtractPosition(GCodeLine line, Vector3d previousPosition)
{
double x = previousPosition.x;
double y = previousPosition.y;
double z = previousPosition.z;
if (line.Parameters != null)
{
foreach (var param in line?.Parameters)
{
switch (param.Identifier)
{
case "X":
x = param.DoubleValue;
break;
case "Y":
y = param.DoubleValue;
break;
case "Z":
z = param.DoubleValue;
break;
}
}
}
return(new Vector3d(x, y, z));
}
public GCodeFile ArcsToLines(double length)
{
var newFile = new List <GCodeCommand>();
foreach (var cmd in Commands)
{
if (cmd is GCodeArc)
{
foreach (var segment in ((GCodeArc)cmd).Split(length).Cast <GCodeArc>())
{
var ilne = new GCodeLine()
{
Start = segment.Start,
End = segment.End,
Feed = segment.Feed,
Rapid = false
};
newFile.Add(ilne);
}
}
else
{
newFile.Add(cmd);
}
}
return(new GCodeFile(newFile));
}
private static void insertArcMove(ItemPath item, int pos, Point oldPoint, Point endPoint, Point center, bool isCW, double depth)
{
GCodeMotion motion;
ArcProperties arcMove;
Point p1 = Round(oldPoint);
Point p2 = Round(endPoint);
double x = 0, y = 0;
arcMove = gcodeMath.getArcMoveProperties(p1, p2, center, isCW);
double stepwidth = (double)Properties.Settings.Default.importGCSegment;
int insertCounter = 1;
if (stepwidth > arcMove.radius / 2)
{
stepwidth = arcMove.radius / 5;
}
double step = Math.Asin(stepwidth / arcMove.radius); // in RAD
// double step = Math.Asin((double)Properties.Settings.Default.importGCSegment / arcMove.radius); // in RAD
if (step > Math.Abs(arcMove.angleDiff))
{
step = Math.Abs(arcMove.angleDiff / 2);
}
if (arcMove.angleDiff > 0) //(da > 0) // if delta >0 go counter clock wise
{
for (double angle = (arcMove.angleStart + step); angle < (arcMove.angleStart + arcMove.angleDiff); angle += step)
{
x = arcMove.center.X + arcMove.radius * Math.Cos(angle);
y = arcMove.center.Y + arcMove.radius * Math.Sin(angle);
motion = new GCodeLine(new Point(x, y), depth);
item.Dimension.setDimensionXY(x, y);
item.path.Insert(pos + insertCounter, motion);
insertCounter++;
item.PathLength += PointDistance(oldPoint, endPoint); // distance from last to current point
oldPoint = endPoint;
}
}
else // else go clock wise
{
for (double angle = (arcMove.angleStart - step); angle > (arcMove.angleStart + arcMove.angleDiff); angle -= step)
{
x = arcMove.center.X + arcMove.radius * Math.Cos(angle);
y = arcMove.center.Y + arcMove.radius * Math.Sin(angle);
motion = new GCodeLine(new Point(x, y), depth);
item.Dimension.setDimensionXY(x, y);
item.path.Insert(pos + insertCounter, motion);
insertCounter++;
item.PathLength += PointDistance(oldPoint, endPoint); // distance from last to current point
oldPoint = endPoint;
}
}
motion = new GCodeLine(new Point(endPoint.X, endPoint.Y), depth);
item.Dimension.setDimensionXY(endPoint.X, endPoint.Y);
item.path.Insert(pos + insertCounter, motion);
item.PathLength += PointDistance(oldPoint, endPoint); // distance from last to current point
oldPoint = endPoint;
}
private PrintVertex UpdatePrintVertex(GCodeLine line, PrintVertex previousVertex)
{
return(new PrintVertex(
ExtractPosition(line, previousVertex.Position),
ExtractFeedRate(line, previousVertex.FeedRate),
ExtractDimensions(line, previousVertex.Dimensions),
ExtractExtrusion(line, previousVertex.Extrusion.x)));
}
/// <summary>
/// Parse GCodeline property. Get values of G-Code commands
/// </summary>
public void ParseGCode()
{
var arr = GCodeLine.ToUpper().Split(' ');
try
{
for (int i = 0; i < arr.Length; i++)
{
//logger.Info("GCodeTool1" + arr[i].ToString());
if (arr[i].Contains("X"))
{
X = arr[i].Remove(0, 1);
}
else if (arr[i].Contains("Y"))
{
Y = arr[i].Remove(0, 1);
}
else if (arr[i].Contains("I"))
{
I = arr[i].Remove(0, 1);
}
else if (arr[i].Contains("J"))
{
J = arr[i].Remove(0, 1);
}
else if (arr[i].Contains("F"))
{
F = arr[i].Remove(0, 1);
}
else if (arr[i].Contains("S"))
{
S = arr[i].Remove(0, 1);
}
else if (arr[i].Contains("G"))
{
G = arr[i].Remove(0, 1);
ProcessGCode(G);
}
else if (arr[i].Contains("M"))
{
M = arr[i].Remove(0, 1);
ProcessMCode(M);
}
else
{
arr[i] = string.Empty;
}
}
}
catch (Exception ex)
{
logger.Error("Method ParseGCode raised: {0}", ex.ToString());
}
}
public void NotNewLayer_NoComment()
{
var line = new GCodeLine(0, LineType.GCode);
line.Code = 1;
line.Parameters = new GCodeParam[] { GCodeParam.Double(200, "X") };
var isNewLine = LineIsNewLayerComment(line, out int index, out double height);
Assert.IsFalse(isNewLine);
}
private bool LineIsNewFeatureType(GCodeLine line, FillTypeFlags fillType, out FillTypeFlags newFillType)
{
newFillType = fillType;
if (GCodeLineUtil.ExtractFillType(line, ref newFillType))
{
if (newFillType != fillType)
{
return(true);
}
}
return(false);
}
public virtual void ObserveGcodeLine(GCodeLine line)
{
if (line.Type != LineType.GCode)
{
return;
}
double x = VertexPrevious.Position.x;
double y = VertexPrevious.Position.y;
GCodeUtil.TryFindParamNum(line.Parameters, "X", ref x);
GCodeUtil.TryFindParamNum(line.Parameters, "Y", ref y);
VertexCurrent.Position = new Vector3d(x, y, 0);
double f = GCodeUtil.UnspecifiedValue;
if (GCodeUtil.TryFindParamNum(line.Parameters, "F", ref f))
{
VertexCurrent.FeedRate = f;
}
double extrusionAmount = GCodeUtil.UnspecifiedValue;
bool featureActive = GCodeUtil.TryFindParamNum(line.Parameters, "E", ref extrusionAmount) &&
extrusionAmount > VertexPrevious.Extrusion.x &&
currentFeatureInfo != null;
foreach (var s in endFeatureComments)
{
if (!string.IsNullOrWhiteSpace(line.Comment) && line.Comment.ToLower().Contains(s))
{
featureActive = false;
}
}
if (featureActive)
{
Vector2d average = new Segment2d(VertexCurrent.Position.xy, VertexPrevious.Position.xy).Center;
double distance = VertexCurrent.Position.Distance(VertexPrevious.Position);
double extrusion = extrusionAmount - VertexPrevious.Extrusion.x;
currentFeatureInfo.Extrusion += extrusion;
currentFeatureInfo.Distance += distance;
currentFeatureInfo.BoundingBox.Contain(VertexPrevious.Position.xy);
currentFeatureInfo.BoundingBox.Contain(VertexCurrent.Position.xy);
currentFeatureInfo.UnweightedCenterOfMass += average * extrusion;
currentFeatureInfo.Duration += distance / VertexCurrent.FeedRate;
VertexCurrent.Extrusion = new Vector3d(extrusionAmount, 0, 0);
}
VertexPrevious = new PrintVertex(VertexCurrent);
}
public void NewLayerUnknown()
{
var line = new GCodeLine(0, LineType.UnknownString);
line.OriginalString = "; layer 99, Z = 33.33";
var isNewLine = LineIsNewLayerComment(line, out int index, out double height);
Assert.IsTrue(isNewLine);
Assert.AreEqual(99, index);
Assert.AreEqual(33.33, height);
}
public void NewLayerCommentAlternate()
{
var line = new GCodeLine(0, LineType.Comment);
line.Comment = "layer 99: 33.33mm";
var isNewLine = LineIsNewLayerComment(line, out int index, out double height);
Assert.IsTrue(isNewLine);
Assert.AreEqual(99, index);
Assert.AreEqual(33.33, height);
}
public ItemPath(Point tmp)
{
isReversed = false;
distance = 0;
pathLength = 0;
path = new List <GCodeMotion>();
dimension = new Dimensions();
GCodeMotion motion = new GCodeLine(tmp);
dimension.setDimensionXY(tmp.X, tmp.Y);
path.Add(motion);
start = end = tmp;
}
private void CodeAddPoint(int idx, System.Windows.Point p)
{
var code = Code.Codes[idx] as GCodeLine;
var line = new GCodeLine(x: p.X, y: p.Y, speed: code.f, mode: code.SpeedMode);
Code.Codes.Insert(idx, line);
NotifyPropertyChanged("CodeCount");
UpdateObjSize();
NotifyPropertyChanged("CodePosition");
NotifyPropertyChanged("CurrentCodeString");
renderList();
PositionChanged?.Invoke(CodePosition);
}
public void Add(Point tmp, double z, double ang)
{
GCodeMotion motion = new GCodeLine(tmp, z, ang);
dimension.setDimensionXY(tmp.X, tmp.Y);
path.Add(motion);
pathLength += PointDistance(end, tmp); // distance from last to current point
end = tmp;
if (start == end)
{
isClosed = true;
}
}
public static bool ExtractFillType(GCodeLine line, ref string featureType)
{
if (line.Comment != null)
{
int indexOfFillType = line.Comment.IndexOf("feature");
if (indexOfFillType >= 0)
{
featureType = line.Comment.Substring(indexOfFillType + 8).Trim();
return(true);
}
}
return(false);
}
protected virtual double ExtractFeedRate(GCodeLine line, double previousFeedrate)
{
if (line.Parameters != null)
{
foreach (var param in line?.Parameters)
{
if (param.Identifier == "F")
{
return(param.DoubleValue);
}
}
}
return(previousFeedrate);
}
protected virtual double ExtractExtrusion(GCodeLine line, double previousExtrusion)
{
if (line.Parameters != null)
{
foreach (var param in line?.Parameters)
{
if (param.Identifier == "E")
{
return(param.DoubleValue);
}
}
}
return(previousExtrusion);
}
protected void SetExtrusionCoordinateMode(GCodeLine line)
{
if (line.Type == LineType.MCode)
{
if (line.Code == 82)
{
extruderRelativeCoordinates = false;
}
else if (line.Code == 83)
{
extruderRelativeCoordinates = true;
}
}
}
public static bool ExtractFillType(GCodeLine line, ref FillTypeFlags fillType)
{
if (line.comment != null)
{
int indexOfFillType = line.comment.IndexOf("feature");
if (indexOfFillType >= 0)
{
var featureName = line.comment.Substring(indexOfFillType + 8).Trim();
fillType = FeatureTypeLabelerFFF.Value.FillTypeFlagFromFeatureLabel(featureName);
return(true);
}
}
return(false);
}
/// <summary>
/// Parse GCodeline property. Get values of G-Code commands
/// </summary>
public void ParseGCode()
{
var arr = GCodeLine.ToUpper(CultureInfo.CurrentCulture).Split(' ');
for (int i = 0; i < arr.Length; i++)
{
//logger.Info("GCodeTool1" + arr[i].ToString());
if (arr[i].Contains("X"))
{
X = arr[i].Remove(0, 1);
}
else if (arr[i].Contains("Y"))
{
Y = arr[i].Remove(0, 1);
}
else if (arr[i].Contains("I"))
{
I = arr[i].Remove(0, 1);
}
else if (arr[i].Contains("J"))
{
J = arr[i].Remove(0, 1);
}
else if (arr[i].Contains("F"))
{
F = arr[i].Remove(0, 1);
}
else if (arr[i].Contains("S"))
{
S = arr[i].Remove(0, 1);
}
else if (arr[i].Contains("G"))
{
G = arr[i].Remove(0, 1);
ProcessGCode(G);
}
else if (arr[i].Contains("M"))
{
M = arr[i].Remove(0, 1);
ProcessMCode(M);
}
else
{
arr[i] = string.Empty;
}
}
}
public override void ProcessGCodeLine(GCodeLine line)
{
if (LineIsEmpty(line))
{
return;
}
SetExtrusionCoordinateMode(line);
currentVertex = UpdatePrintVertex(line, previousVertex);
if (LineIsNewLayerComment(line, out int index, out double height))
{
toolpath = FinishToolpath();
EmitNewLayer(currentLayerIndex++, height);
}
if (LineIsTravel(line))
{
CloseToolpathAndAddTravel(previousVertex, currentVertex);
}
if (LineIsNewFillTypeComment(line, out var newFillType))
{
toolpath = FinishToolpath();
toolpath.Type = ToolpathTypes.Deposition;
toolpath.FillType = newFillType;
}
if (line.Comment?.Contains("Plane Change") ?? false)
{
toolpath.Type = ToolpathTypes.PlaneChange;
}
if (line.Type == LineType.GCode)
{
if (VertexHasNegativeOrZeroExtrusion(previousVertex, currentVertex))
{
CloseToolpathAndAddTravel(previousVertex, currentVertex);
}
else if (toolpath != null)
{
AppendVertexToCurrentToolpath(currentVertex);
}
}
previousVertex = currentVertex;
}
public void ObserveGcodeLine(GCodeLine line)
{
if (line.type != GCodeLine.LType.GCode)
{
return;
}
double x = VertexPrevious.Position.x;
double y = VertexPrevious.Position.y;
bool found_x = GCodeUtil.TryFindParamNum(line.parameters, "X", ref x);
bool found_y = GCodeUtil.TryFindParamNum(line.parameters, "Y", ref y);
if (!found_x || !found_y)
{
return;
}
VertexCurrent.Position = new Vector3d(x, y, 0);
double f = GCodeUtil.UnspecifiedValue;
if (GCodeUtil.TryFindParamNum(line.parameters, "F", ref f))
{
VertexCurrent.FeedRate = f;
}
double extrusionAmount = GCodeUtil.UnspecifiedValue;
if (GCodeUtil.TryFindParamNum(line.parameters, "E", ref extrusionAmount) &&
extrusionAmount >= VertexPrevious.Extrusion.x && currentFeatureInfo != null)
{
Vector2d average = new Segment2d(VertexCurrent.Position.xy, VertexPrevious.Position.xy).Center;
double distance = VertexCurrent.Position.Distance(VertexPrevious.Position);
double extrusion = extrusionAmount - VertexPrevious.Extrusion.x;
currentFeatureInfo.Extrusion += extrusion;
currentFeatureInfo.Distance += distance;
currentFeatureInfo.BoundingBox.Contain(VertexCurrent.Position.xy);
currentFeatureInfo.UnweightedCenterOfMass += average * extrusion;
currentFeatureInfo.Duration += distance / VertexCurrent.FeedRate;
VertexCurrent.Extrusion = new Vector3d(extrusionAmount, 0, 0);
}
VertexPrevious = new PrintVertex(VertexCurrent);
}
public void ParserGCode_G1_Correct_G01_X10_Y10_Test()
{
ParserGCode p = new ParserGCode();
List <GCodeLine> result = p.Parse("G01 X10 Y10");
List <GCodeLine> rightresult = new List <GCodeLine>();
GCodeLine gCodeLineResult1 = new GCodeLine(1, "G1", 10, 10);
rightresult.Add(gCodeLineResult1);
rightresult.Add(new GCodeLine(2));
string resulttext = ListToString(result);
string rightresulttext = ListToString(rightresult);
Assert.AreEqual(resulttext, rightresulttext);
}
public virtual GCodeLine Clone()
{
GCodeLine clone = new GCodeLine(this.lineNumber, this.type);
clone.orig_string = this.orig_string;
clone.N = this.N;
clone.code = this.code;
if (this.parameters != null)
{
clone.parameters = new GCodeParam[this.parameters.Length];
for (int i = 0; i < this.parameters.Length; ++i)
{
clone.parameters[i] = this.parameters[i];
}
}
clone.comment = this.comment;
return(clone);
}
protected bool LineIsNewFillTypeComment(GCodeLine line, out IFillType fillType)
{
if (line.Comment != null)
{
var match = fillTypeLabelPattern.Match(line.Comment);
if (match.Success)
{
if (!FillTypes.TryGetValue(match.Groups[1].Captures[0].Value, out fillType))
{
fillType = new DefaultFillType();
}
return(true);
}
}
fillType = null;
return(false);
}
public virtual GCodeLine Clone()
{
GCodeLine clone = new GCodeLine(LineNumber, Type);
clone.OriginalString = OriginalString;
clone.N = N;
clone.Code = Code;
if (Parameters != null)
{
clone.Parameters = new GCodeParam[Parameters.Length];
for (int i = 0; i < Parameters.Length; ++i)
{
clone.Parameters[i] = Parameters[i];
}
}
clone.Comment = Comment;
return(clone);
}
public void ParserGCode_G1_Correct_G1_X10_Test()
{
ParserGCode p = new ParserGCode();
List <GCodeLine> result = p.Parse("G1 X10");
List <GCodeLine> rightresult = new List <GCodeLine>();
GCodeLine gCodeLineResult1 = new GCodeLine(1);
gCodeLineResult1.Command.Add("G1");
gCodeLineResult1.XPos = 10;
rightresult.Add(gCodeLineResult1);
rightresult.Add(new GCodeLine(2));
string resulttext = ListToString(result);
string rightresulttext = ListToString(rightresult);
Assert.AreEqual(resulttext, rightresulttext);
}
private GCodeMotion ParseLine(List <Word> Words, double MotionMode, Vector3 EndPos)
{
if (Words.Count > 0)
{
var bldr = new StringBuilder();
foreach (var word in Words)
{
bldr.Append(word.FullWord + "; ");
}
throw new Exception("Motion Command must be last in line Unparsed words in block => " + bldr.ToString());
}
var motion = new GCodeLine();
motion.Start = State.Position;
motion.End = EndPos;
motion.Rapid = MotionMode == 0;
return(motion);
}
public void ParserGCode_G1_Correct_G01_SEG10_52_ANG45_Test()
{
ParserGCode p = new ParserGCode();
List <GCodeLine> result = p.Parse("G01 SEG10.52 ANG45");
List <GCodeLine> rightresult = new List <GCodeLine>();
GCodeLine gCodeLineResult1 = new GCodeLine(1);
gCodeLineResult1.Command.Add("G1");
gCodeLineResult1.SEG = 10.52;
gCodeLineResult1.ANG = 45;
rightresult.Add(gCodeLineResult1);
rightresult.Add(new GCodeLine(2));
string resulttext = ListToString(result);
string rightresulttext = ListToString(rightresult);
Assert.AreEqual(resulttext, rightresulttext);
}
