public void CorrectIslandCount2() { void Test(bool mergeOverlaps, bool expandWalls) { string engineStlFile = TestUtilities.GetStlPath("all_layers"); string engineGCodeFile = TestUtilities.GetTempGCodePath($"all_layers - merge overlap {mergeOverlaps} - expand walls {expandWalls}.gcode"); var config = new ConfigSettings(); config.FirstLayerThickness = .2; config.LayerThickness = .2; config.NumberOfSkirtLoops = 0; config.InfillPercent = 0; config.NumberOfTopLayers = 0; config.NumberOfBottomLayers = 0; config.NumberOfPerimeters = 1; config.MergeOverlappingLines = mergeOverlaps; config.ExpandThinWalls = expandWalls; config.FillThinGaps = false; config.AvoidCrossingPerimeters = false; var processor = new FffProcessor(config); processor.SetTargetFile(engineGCodeFile); processor.LoadStlFile(engineStlFile); // slice and save it processor.DoProcessing(); processor.Dispose(); var loadedGCode = TestUtilities.LoadGCodeFile(engineGCodeFile); var layers = TestUtilities.LayerCount(loadedGCode); Assert.AreEqual(45, layers); var expectedIslands = new int[] { 7, 7, 7, 5, 5, // 0 - 4 5, 5, 5, 5, 5, // 5 - 9 5, 5, 5, 5, 5, // 10 - 14 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, }; var layerPolygons = TestUtilities.GetAllLayersExtrusionPolygons(loadedGCode); Assert.AreEqual(45, layerPolygons.Where(i => i.Count > 2).Count()); for (int i = 1; i < layers; i++) { Assert.AreEqual(expectedIslands[i], layerPolygons[i].Where(p => p.Count > 2).Count()); } } Test(false, false); Test(false, true); Test(true, false); Test(true, true); }
public void AllPerimetersGoInPolgonDirection() { string thinWallsSTL = TestUtilities.GetStlPath("ThinWallsRect"); string thinWallsGCode = TestUtilities.GetTempGCodePath("ThinWallsRect.gcode"); { // load a model that is correctly manifold var config = new ConfigSettings(); config.ExpandThinWalls = true; config.MergeOverlappingLines = false; var processor = new FffProcessor(config); processor.SetTargetFile(thinWallsGCode); processor.LoadStlFile(thinWallsSTL); // slice and save it processor.DoProcessing(); processor.Finalize(); string[] loadedGCode = TestUtilities.LoadGCodeFile(thinWallsGCode); int layerCount = TestUtilities.LayerCount(loadedGCode); var layerPolygons = loadedGCode.GetAllExtrusionPolygons(); for (int i = 2; i < layerCount - 2; i++) { Assert.LessOrEqual(layerPolygons[i].Count, 4, "We should not have add more than the 4 sides"); foreach (var polygon in layerPolygons[i]) { Assert.AreEqual(1, polygon.GetWindingDirection()); } } } }
internal static void CheckPolysAreSimilar(string aGCodeFile, string bGCodeFile) { var aLoadedGcode = TestUtilities.LoadGCodeFile(aGCodeFile); var bLoadedGCode = TestUtilities.LoadGCodeFile(bGCodeFile); var aLayerCount = TestUtilities.LayerCount(aLoadedGcode); Assert.AreEqual(aLayerCount, TestUtilities.LayerCount(bLoadedGCode)); for (int layerIndex = 0; layerIndex < aLayerCount; layerIndex++) { var aLayerGCode = TestUtilities.GetLayer(aLoadedGcode, layerIndex); var bLayerGCode = TestUtilities.GetLayer(bLoadedGCode, layerIndex); var aPolys = TestUtilities.GetExtrusionPolygonsForLayer(aLayerGCode, false); var bPolys = TestUtilities.GetExtrusionPolygonsForLayer(bLayerGCode, false); // Assert.AreEqual(aPolys.Count, bPolys.Count); if (aPolys.Count > 0) { var aPoly = aPolys[0]; var bPoly = bPolys[0]; for (int aPointIndex = 0; aPointIndex < aPoly.Count; aPointIndex++) { var found = false; for (int bPointIndex = 0; bPointIndex < bPoly.Count; bPointIndex++) { if ((aPoly[aPointIndex] - bPoly[bPointIndex]).Length() < 10) { found = true; break; } } Assert.IsTrue(found); } } } }
public void NoLayerChangeRetractions() { string infillSTL = TestUtilities.GetStlPath("no_layer_change_retractions"); string infillGCode = TestUtilities.GetTempGCodePath("no_layer_change_retractions.gcode"); { // load a model that is correctly manifold var config = new ConfigSettings(); string settingsPath = TestContext.CurrentContext.ResolveProjectPath(4, "Tests", "TestData", "no_retractions_config.ini"); config.ReadSettings(settingsPath); var processor = new FffProcessor(config); processor.SetTargetFile(infillGCode); processor.LoadStlFile(infillSTL); // slice and save it processor.DoProcessing(); processor.Finalize(); string[] gcodeContents = TestUtilities.LoadGCodeFile(infillGCode); int numLayers = TestUtilities.LayerCount(gcodeContents); for (int i = 1; i < numLayers - 2; i++) { string[] layer = TestUtilities.GetGCodeForLayer(gcodeContents, i); int totalRetractions = TestUtilities.CountRetractions(layer); Assert.IsTrue(totalRetractions == 0); } } }
public void AlwaysRetractOnIslandChange() { string meshWithIslands = TestUtilities.GetStlPath("comb"); string gCodeWithIslands = TestUtilities.GetTempGCodePath("comb-box"); { // load a model that has 3 islands var config = new ConfigSettings(); // make sure no retractions are going to occur that are island crossing config.MinimumTravelToCauseRetraction = 2000; var processor = new FffProcessor(config); processor.SetTargetFile(gCodeWithIslands); processor.LoadStlFile(meshWithIslands); // slice and save it processor.DoProcessing(); processor.Finalize(); string[] gcodeContents = TestUtilities.LoadGCodeFile(gCodeWithIslands); int numLayers = TestUtilities.LayerCount(gcodeContents); for (int i = 1; i < numLayers - 1; i++) { string[] layer = TestUtilities.GetGCodeForLayer(gcodeContents, i); int totalRetractions = TestUtilities.CountRetractions(layer); Assert.IsTrue(totalRetractions == 4); } } }
public void SingleLayerCreated() { string point3mmStlFile = TestUtilities.GetStlPath("Point3mm"); string point3mmGCodeFile = TestUtilities.GetTempGCodePath("Point3mm.gcode"); var config = new ConfigSettings(); config.FirstLayerThickness = .25; config.LayerThickness = .25; config.NumberOfSkirtLoops = 0; var processor = new FffProcessor(config); processor.SetTargetFile(point3mmGCodeFile); processor.LoadStlFile(point3mmStlFile); // slice and save it processor.DoProcessing(); processor.Dispose(); var loadedGCode = TestUtilities.LoadGCodeFile(point3mmGCodeFile); var layers = TestUtilities.LayerCount(loadedGCode); Assert.AreEqual(1, layers); var totalExtrusions = TestUtilities.GetExtrusionPolygonsForLayer(loadedGCode); #if __ANDROID__ Assert.IsTrue(totalExtrusions.Count > 0); Assert.IsTrue(totalExtrusions[0].PolygonLength() > 100); #else Assert.Greater(totalExtrusions.Count, 0); Assert.Greater(totalExtrusions[0].PolygonLength(), 100); #endif }
public void CorrectNumberOfLayersForLayerHeights() { // test .1 layer height Assert.AreEqual(100, TestUtilities.LayerCount(TestUtilities.LoadGCodeFile(CreateGCodeForLayerHeights(.1, .1)))); Assert.AreEqual(99, TestUtilities.LayerCount(TestUtilities.LoadGCodeFile(CreateGCodeForLayerHeights(.2, .1)))); Assert.AreEqual(50, TestUtilities.LayerCount(TestUtilities.LoadGCodeFile(CreateGCodeForLayerHeights(.2, .2)))); Assert.AreEqual(51, TestUtilities.LayerCount(TestUtilities.LoadGCodeFile(CreateGCodeForLayerHeights(.05, .2)))); }
public static List <IEnumerable <MovementInfo> > GetAllLayersMovements(this string[] loadedGCode) { var layerCount = TestUtilities.LayerCount(loadedGCode); var layerMovements = new List <IEnumerable <MovementInfo> >(layerCount); for (int i = 0; i < layerCount; i++) { layerMovements.Add(TestUtilities.GetLayerMovements(loadedGCode.GetLayer(i))); } return(layerMovements); }
public static List <string[]> GetAllLayers(this string[] loadedGCode) { var layerCount = TestUtilities.LayerCount(loadedGCode); var gcodeLayers = new List <string[]>(layerCount); for (int i = 0; i < layerCount; i++) { gcodeLayers.Add(loadedGCode.GetLayer(i)); } return(gcodeLayers); }
/// <summary> /// Get the extrusion polygons for every layer /// </summary> /// <param name="loadedGCode">The source gcode separated by line</param> /// <returns>A list of all the polygons by layer</returns> public static List <Polygons> GetAllExtrusionPolygons(this string[] loadedGCode) { var layerCount = TestUtilities.LayerCount(loadedGCode); var layerPolygons = new List <Polygons>(layerCount); for (int i = 0; i < layerCount; i++) { layerPolygons.Add(TestUtilities.GetExtrusionPolygonsForLayer(loadedGCode.GetGCodeForLayer(i))); } return(layerPolygons); }
private static void CheckLayersIncrement(string stlFile, string gcodeFile) { string risingLayersStlFile = TestUtilities.GetStlPath(stlFile); string risingLayersGCodeFileName = TestUtilities.GetTempGCodePath(gcodeFile); var config = new ConfigSettings(); config.FirstLayerThickness = .2; config.LayerThickness = .2; var processor = new FffProcessor(config); processor.SetTargetFile(risingLayersGCodeFileName); processor.LoadStlFile(risingLayersStlFile); // slice and save it processor.DoProcessing(); processor.Dispose(); string[] risingLayersGCodeContent = TestUtilities.LoadGCodeFile(risingLayersGCodeFileName); // test .1 layer height int layerCount = TestUtilities.LayerCount(risingLayersGCodeContent); Assert.IsTrue(layerCount == 50); var startingPosition = default(MovementInfo); for (int layerIndex = 0; layerIndex < layerCount; layerIndex++) { string[] layerInfo = TestUtilities.GetLayer(risingLayersGCodeContent, layerIndex); int movementIndex = 0; // check that all layers move up foreach (MovementInfo movement in TestUtilities.GetLayerMovements(layerInfo, startingPosition)) { if (movement.line.Contains("X") || movement.line.Contains("Y") || movement.line.Contains("Z")) { if (layerIndex > 0) { Assert.AreEqual(movement.position.z, .2 + layerIndex * .2, .001); Assert.IsTrue(movement.position.z >= startingPosition.position.z); } } // always go up startingPosition.position = new Vector3(0, 0, Math.Max(startingPosition.position.z, movement.position.z)); movementIndex++; } } }
/// <summary> /// Get the extrusion polygons for every layer /// </summary> /// <param name="loadedGCode">The source gcode separated by line</param> /// <returns>A list of all the polygons by layer</returns> public static List <Polygons> GetAllLayersExtrusionPolygons(this string[] loadedGCode) { var layerCount = TestUtilities.LayerCount(loadedGCode); var layerPolygons = new List <Polygons>(layerCount); var movementInfo = default(MovementInfo); for (int i = 0; i < layerCount; i++) { layerPolygons.Add(TestUtilities.GetExtrusionPolygonsForLayer(loadedGCode.GetLayer(i), ref movementInfo, false)); } return(layerPolygons); }
/// <summary> /// Get the travel polygons for every layer /// </summary> /// <param name="loadedGCode">The source gcode separated by line</param> /// <returns>A list of all the polygons by layer</returns> public static List <Polygons> GetAllTravelPolygons(this string[] loadedGCode) { var layerCount = TestUtilities.LayerCount(loadedGCode); var layerPolygons = new List <Polygons>(layerCount); var lastMovement = default(MovementInfo); for (int i = 0; i < layerCount; i++) { layerPolygons.Add(TestUtilities.GetTravelPolygonsForLayer(loadedGCode.GetLayer(i), ref lastMovement)); } return(layerPolygons); }
public void DualMaterialNoRetraction(int material) { GCodeExport.CheckForZeroPositions = false; string shortCubeName = "CubePoint2High"; string shortCube = TestUtilities.GetStlPath(shortCubeName); string outputGCodeFileName = TestUtilities.GetTempGCodePath($"CubeNoRetractions{material}"); var config = new ConfigSettings(); config.ExtruderCount = 2; config.FirstLayerThickness = .2; config.LayerThickness = .2; var processor = new FffProcessor(config); processor.SetTargetFile(outputGCodeFileName); for (int i = 0; i < material; i++) { string skipExtruder = TestUtilities.GetStlPath("TooSmallToPrint"); processor.LoadStlFile(skipExtruder); } processor.LoadStlFile(shortCube); // slice and save it processor.DoProcessing(); processor.Dispose(); string[] gCodeContent = TestUtilities.LoadGCodeFile(outputGCodeFileName); // test layer count int layerCount = TestUtilities.LayerCount(gCodeContent); Assert.AreEqual(1, layerCount); int retractions = TestUtilities.CountRetractions(gCodeContent); Assert.AreEqual(1, retractions, $"Material {material} should have no retractions"); }
public void SupportConnectedOptimaly() { string thinWallsSTL = TestUtilities.GetStlPath("two disks"); string thinWallsGCode = TestUtilities.GetTempGCodePath("two disks.gcode"); { // load a model that is correctly manifold var config = new ConfigSettings(); config.GenerateSupport = true; var processor = new FffProcessor(config); processor.SetTargetFile(thinWallsGCode); processor.LoadStlFile(thinWallsSTL); // slice and save it processor.DoProcessing(); processor.Finalize(); string[] loadedGCode = TestUtilities.LoadGCodeFile(thinWallsGCode); int layerCount = TestUtilities.LayerCount(loadedGCode); for (int i = 0; i < layerCount; i++) { var movements = loadedGCode.GetGCodeForLayer(i).Movements().ToList(); int longMoveCount = 0; for (var j = 1; j < movements.Count - 2; j++) { var start = movements[j - 1]; var end = movements[j]; if (end.extrusion - start.extrusion == 0 && (end.position - start.position).Length > 5) { longMoveCount++; } } Assert.LessOrEqual(longMoveCount, 6); } } }
public void CorrectIslandCount() { string engineStlFile = TestUtilities.GetStlPath("Engine-Benchmark"); string engineGCodeFile = TestUtilities.GetTempGCodePath("Engine-Benchmark.gcode"); var config = new ConfigSettings(); config.FirstLayerThickness = .2; config.LayerThickness = .2; config.NumberOfSkirtLoops = 0; config.InfillPercent = 0; config.NumberOfTopLayers = 0; config.NumberOfBottomLayers = 0; config.NumberOfPerimeters = 1; config.MergeOverlappingLines = false; var processor = new FffProcessor(config); processor.SetTargetFile(engineGCodeFile); processor.LoadStlFile(engineStlFile); // slice and save it processor.DoProcessing(); processor.Dispose(); var loadedGCode = TestUtilities.LoadGCodeFile(engineGCodeFile); var layers = TestUtilities.LayerCount(loadedGCode); Assert.AreEqual(195, layers); var layerPolygons = TestUtilities.GetAllLayersExtrusionPolygons(loadedGCode); Assert.AreEqual(17, layerPolygons[32].Count); for (int i = 33; i < 44; i++) { Assert.AreEqual(13, layerPolygons[i].Where(p => p.Count > 2).Count()); } }
public void AllMovesRequiringRetractionDoRetraction(string baseFileName, string settingsIniFile = "") { string stlToLoad = TestUtilities.GetStlPath(baseFileName + ".stl"); // check that default is support printed with extruder 0 string gcodeToCreate = TestUtilities.GetTempGCodePath(baseFileName + "_retract_.gcode"); var config = new ConfigSettings(); if (settingsIniFile == "") { config.MinimumTravelToCauseRetraction = 2; config.MinimumExtrusionBeforeRetraction = 0; config.MergeOverlappingLines = false; config.FirstLayerExtrusionWidth = .5; } else { config.ReadSettings(settingsIniFile); } // this is what we detect config.RetractionZHop = 5; var processor = new FffProcessor(config); processor.SetTargetFile(gcodeToCreate); processor.LoadStlFile(stlToLoad); // slice and save it processor.DoProcessing(); processor.Dispose(); string[] gcodeContents = TestUtilities.LoadGCodeFile(gcodeToCreate); int layerCount = TestUtilities.LayerCount(gcodeContents); bool firstPosition = true; var lastMovement = default(MovementInfo); var lastExtrusion = default(MovementInfo); bool lastMoveIsExtrusion = true; for (int layerIndex = 0; layerIndex < layerCount; layerIndex++) { string[] layerGCode = TestUtilities.GetLayer(gcodeContents, layerIndex); int movementIndex = 0; foreach (MovementInfo movement in TestUtilities.GetLayerMovements(layerGCode, lastMovement)) { if (!firstPosition) { bool isTravel = lastMovement.extrusion == movement.extrusion; if (isTravel) { Vector3 lastPosition = lastMovement.position; lastPosition.z = 0; Vector3 currenPosition = movement.position; currenPosition.z = 0; double xyLength = (lastPosition - currenPosition).Length; if (xyLength > config.MinimumTravelToCauseRetraction && lastMoveIsExtrusion) { Assert.GreaterOrEqual(movement.position.z, lastExtrusion.position.z); } lastMoveIsExtrusion = false; } else { lastMoveIsExtrusion = true; lastExtrusion = movement; } lastMoveIsExtrusion = !isTravel; } lastMovement = movement; firstPosition = false; movementIndex++; } } // make sure we don't switch extruders Assert.IsFalse(TestUtilities.UsesExtruder(gcodeContents, 1)); Assert.IsFalse(TestUtilities.UsesExtruder(gcodeContents, 2)); }
public void DoHas2WallRingsAllTheWayUp(string fileName, int expectedLayerCount, bool checkRadius = false) { string stlFile = TestUtilities.GetStlPath(fileName); string gCodeFile = TestUtilities.GetTempGCodePath(fileName + ".gcode"); var config = new ConfigSettings(); config.InfillPercent = 0; config.NumberOfPerimeters = 1; config.FirstLayerExtrusionWidth = .2; config.LayerThickness = .2; config.NumberOfBottomLayers = 0; config.NumberOfTopLayers = 0; var processor = new FffProcessor(config); processor.SetTargetFile(gCodeFile); processor.LoadStlFile(stlFile); // slice and save it processor.DoProcessing(); processor.Dispose(); string[] gcodeLines = TestUtilities.LoadGCodeFile(gCodeFile); int layerCount = TestUtilities.LayerCount(gcodeLines); Assert.IsTrue(layerCount == expectedLayerCount); var movement = default(MovementInfo); for (int i = 0; i < layerCount - 10; i++) { string[] layerInfo = TestUtilities.GetLayer(gcodeLines, i); if (i > 0) { Polygons layerPolygons = TestUtilities.GetExtrusionPolygonsForLayer(layerInfo, ref movement); Assert.IsTrue(layerPolygons.Count == 2); if (checkRadius) { Assert.IsTrue(layerPolygons[0].Count > 10); Assert.IsTrue(layerPolygons[1].Count > 10); if (false) { foreach (var polygon in layerPolygons) { double radiusForPolygon = polygon[0].LengthMm(); foreach (var point in polygon) { Assert.AreEqual(radiusForPolygon, point.LengthMm(), 15); } } } } } else { TestUtilities.GetExtrusionPolygonsForLayer(layerInfo, ref movement); } } }
public void ExpandThinWallsFindsWalls() { string thinWallsSTL = TestUtilities.GetStlPath("ThinWalls"); // without expand thin walls { string thinWallsGCode = TestUtilities.GetTempGCodePath("ThinWalls1.gcode"); var config = new ConfigSettings { FirstLayerThickness = .2, LayerThickness = .2, NumberOfSkirtLoops = 0, InfillPercent = 0, NumberOfTopLayers = 0, NumberOfBottomLayers = 0, NumberOfPerimeters = 1, ExpandThinWalls = false, MergeOverlappingLines = false }; var processor = new FffProcessor(config); processor.SetTargetFile(thinWallsGCode); processor.LoadStlFile(thinWallsSTL); // slice and save it processor.DoProcessing(); processor.Finalize(); string[] loadedGCode = TestUtilities.LoadGCodeFile(thinWallsGCode); int layerCount = TestUtilities.LayerCount(loadedGCode); Assert.AreEqual(50, layerCount); var layerPolygons = loadedGCode.GetAllExtrusionPolygons(); Assert.AreEqual(6, layerPolygons[10].Where(i => i.Count > 2).Count()); } // with expand thin walls { string thinWallsGCode = TestUtilities.GetTempGCodePath("ThinWalls2.gcode"); var config = new ConfigSettings(); config.FirstLayerThickness = .2; config.LayerThickness = .2; config.NumberOfSkirtLoops = 0; config.InfillPercent = 0; config.NumberOfTopLayers = 0; config.NumberOfBottomLayers = 0; config.NumberOfPerimeters = 1; config.ExpandThinWalls = true; config.MergeOverlappingLines = false; var processor = new FffProcessor(config); processor.SetTargetFile(thinWallsGCode); processor.LoadStlFile(thinWallsSTL); // slice and save it processor.DoProcessing(); processor.Finalize(); string[] loadedGCode = TestUtilities.LoadGCodeFile(thinWallsGCode); int layerCount = TestUtilities.LayerCount(loadedGCode); Assert.AreEqual(50, layerCount); var layerPolygons = loadedGCode.GetAllExtrusionPolygons(); Assert.AreEqual(10, layerPolygons[10].Count); } // with expand thin walls and with merge overlapping lines { string thinWallsGCode = TestUtilities.GetTempGCodePath("ThinWalls3.gcode"); var config = new ConfigSettings(); config.FirstLayerThickness = .2; config.LayerThickness = .2; config.NumberOfSkirtLoops = 0; config.InfillPercent = 0; config.NumberOfTopLayers = 0; config.NumberOfBottomLayers = 0; config.NumberOfPerimeters = 1; config.ExpandThinWalls = true; config.MergeOverlappingLines = true; var processor = new FffProcessor(config); processor.SetTargetFile(thinWallsGCode); processor.LoadStlFile(thinWallsSTL); // slice and save it processor.DoProcessing(); processor.Finalize(); string[] loadedGCode = TestUtilities.LoadGCodeFile(thinWallsGCode); int layerCount = TestUtilities.LayerCount(loadedGCode); Assert.AreEqual(50, layerCount); var layerPolygons = loadedGCode.GetAllExtrusionPolygons(); Assert.AreEqual(10, layerPolygons[10].Count); } }
public void DualMaterialPrintMovesCorrectly(bool createWipeTower) { string leftPart = "Box Left"; string rightPart = "Box Right"; string leftStlFile = TestUtilities.GetStlPath(leftPart); string rightStlFile = TestUtilities.GetStlPath(rightPart); string outputGCodeFileName = TestUtilities.GetTempGCodePath("DualPartMoves"); var config = new ConfigSettings(); config.ExtruderCount = 2; config.FirstLayerThickness = .2; config.LayerThickness = .2; config.NumberOfBottomLayers = 0; if (createWipeTower) { config.WipeTowerSize = 10; } else { config.WipeTowerSize = 0; } var processor = new FffProcessor(config); processor.SetTargetFile(outputGCodeFileName); processor.LoadStlFile(leftStlFile); processor.LoadStlFile(rightStlFile); // slice and save it processor.DoProcessing(); processor.Dispose(); string[] gCodeContent = TestUtilities.LoadGCodeFile(outputGCodeFileName); // test .1 layer height int layerCount = TestUtilities.LayerCount(gCodeContent); Assert.IsTrue(layerCount == 50); bool hadMoveLessThan85 = false; var lastMovement = default(MovementInfo); for (int i = 0; i < layerCount - 3; i++) { string[] layerInfo = TestUtilities.GetLayer(gCodeContent, i); // check that all layers move up continuously foreach (MovementInfo movement in TestUtilities.GetLayerMovements(layerInfo, lastMovement, onlyG1s: true)) { if (i > 2) { if (createWipeTower) { Assert.IsTrue(movement.position.x > 75 && movement.position.y > 10, "Moves don't go to 0"); if (movement.position.x < 85) { hadMoveLessThan85 = true; } } else { Assert.IsTrue(movement.position.x > 85 && movement.position.y > 10, "Moves don't go to 0"); } } lastMovement = movement; } } if (createWipeTower) { Assert.IsTrue(hadMoveLessThan85, "found a wipe tower"); } }
private static void CheckSpiralCone(string stlFile, string gcodeFile, bool enableThinWalls = false) { string cylinderStlFile = TestUtilities.GetStlPath(stlFile); string cylinderGCodeFileName = TestUtilities.GetTempGCodePath(gcodeFile); var config = new ConfigSettings { FirstLayerThickness = .2, LayerThickness = .2, NumberOfBottomLayers = 0, ContinuousSpiralOuterPerimeter = true }; if (enableThinWalls) { config.ExpandThinWalls = true; config.FillThinGaps = true; } var processor = new FffProcessor(config); processor.SetTargetFile(cylinderGCodeFileName); processor.LoadStlFile(cylinderStlFile); // slice and save it processor.DoProcessing(); processor.Dispose(); string[] cylinderGCodeContent = TestUtilities.LoadGCodeFile(cylinderGCodeFileName); // test .1 layer height int layerCount = TestUtilities.LayerCount(cylinderGCodeContent); Assert.AreEqual(50, layerCount, "SpiralCone should have 50 layers"); for (int i = 2; i < layerCount - 3; i++) { string[] layerInfo = TestUtilities.GetLayer(cylinderGCodeContent, i); // check that all layers move up continuously var lastMovement = default(MovementInfo); foreach (MovementInfo movement in TestUtilities.GetLayerMovements(layerInfo)) { #if __ANDROID__ Assert.IsTrue(movement.position.z > lastMovement.position.z); #else Assert.Greater(movement.position.z, lastMovement.position.z, "Z position should increment per layer"); #endif lastMovement = movement; } double radiusForLayer = 5.0 + (20.0 - 5.0) / layerCount * i; bool first = true; lastMovement = default(MovementInfo); // check that all moves are on the outside of the cylinder (not crossing to a new point) foreach (MovementInfo movement in TestUtilities.GetLayerMovements(layerInfo)) { if (!first) { Assert.IsTrue((movement.position - lastMovement.position).Length < 2); var xyOnly = new Vector3(movement.position.x, movement.position.y, 0); Assert.AreEqual(radiusForLayer, xyOnly.Length, .3); } lastMovement = movement; first = false; } } }
private static void CheckSpiralCylinder(string stlFile, string gcodeFile, int expectedLayers, bool enableThinWalls = false) { string cylinderStlFile = TestUtilities.GetStlPath(stlFile); string cylinderGCodeFileName = TestUtilities.GetTempGCodePath(gcodeFile); var config = new ConfigSettings(); config.FirstLayerThickness = .2; config.LayerThickness = .2; if (enableThinWalls) { config.ExpandThinWalls = true; config.FillThinGaps = true; } config.NumberOfBottomLayers = 0; config.ContinuousSpiralOuterPerimeter = true; var processor = new FffProcessor(config); processor.SetTargetFile(cylinderGCodeFileName); processor.LoadStlFile(cylinderStlFile); // slice and save it processor.DoProcessing(); processor.Dispose(); string[] cylinderGCodeContent = TestUtilities.LoadGCodeFile(cylinderGCodeFileName); // test .1 layer height int layerCount = TestUtilities.LayerCount(cylinderGCodeContent); Assert.IsTrue(layerCount == expectedLayers); for (int i = 2; i < layerCount - 3; i++) { string[] layerInfo = TestUtilities.GetLayer(cylinderGCodeContent, i); // check that all layers move up continuously var lastMovement = default(MovementInfo); foreach (MovementInfo movement in TestUtilities.GetLayerMovements(layerInfo)) { Assert.IsTrue(movement.position.z > lastMovement.position.z); lastMovement = movement; } bool first = true; lastMovement = default(MovementInfo); // check that all moves are on the outside of the cylinder (not crossing to a new point) foreach (MovementInfo movement in TestUtilities.GetLayerMovements(layerInfo)) { if (!first) { Assert.IsTrue((movement.position - lastMovement.position).Length < 2); var xyOnly = new Vector3(movement.position.x, movement.position.y, 0); Assert.AreEqual(9.8, xyOnly.Length, .3); } lastMovement = movement; first = false; } } }