480 lines
16 KiB
C#
480 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
|
|
using MatterHackers.VectorMath;
|
|
|
|
namespace MatterHackers.MatterControl
|
|
{
|
|
public static class CuraEngineMappings
|
|
{
|
|
public static bool MapContains(string defaultKey)
|
|
{
|
|
foreach (MapItem mapItem in curaToDefaultMapping)
|
|
{
|
|
if (mapItem.DefaultKey == defaultKey)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static MapItem[] curaToDefaultMapping =
|
|
{
|
|
new ScaledSingleNumber("layerThickness", "layer_height", 1000),
|
|
new AsPercentOfReferenceOrDirect("initialLayerThickness", "first_layer_height", "layer_height", 1000),
|
|
new ScaledSingleNumber("filamentDiameter", "filament_diameter", 1000),
|
|
new ScaledSingleNumber("extrusionWidth", "nozzle_diameter", 1000),
|
|
|
|
new MapItem("printSpeed", "perimeter_speed"),
|
|
new MapItem("infillSpeed", "infill_speed"),
|
|
new MapItem("moveSpeed", "travel_speed"),
|
|
new AsPercentOfReferenceOrDirect("initialLayerSpeed", "first_layer_speed", "infill_speed"),
|
|
|
|
new NotPassedItem("", "temperature"),
|
|
new NotPassedItem("", "bed_temperature"),
|
|
new NotPassedItem("", "bed_shape"),
|
|
|
|
new MapItem("insetCount", "perimeters"),
|
|
|
|
new MapItem("skirtLineCount", "skirts"),
|
|
new SkirtLengthMaping("skirtMinLength", "min_skirt_length"),
|
|
new ScaledSingleNumber("skirtDistance", "skirt_distance", 1000),
|
|
|
|
new MapItem("fanSpeedMin", "max_fan_speed"),
|
|
new MapItem("fanSpeedMax", "min_fan_speed"),
|
|
|
|
new MapItem("downSkinCount", "bottom_solid_layers"),
|
|
new MapItem("upSkinCount", "top_solid_layers"),
|
|
|
|
new FanTranslator("fanFullOnLayerNr", "disable_fan_first_layers"),
|
|
new MapItem("coolHeadLift", "cool_extruder_lift"),
|
|
|
|
new ScaledSingleNumber("retractionAmount", "retract_length", 1000),
|
|
new MapItem("retractionSpeed", "retract_speed"),
|
|
new ScaledSingleNumber("retractionMinimalDistance", "retract_before_travel", 1000),
|
|
|
|
new MapItem("spiralizeMode", "spiral_vase"),
|
|
|
|
new NotPassedItem("", "bed_size"),
|
|
|
|
new PrintCenterX("posx", "print_center"),
|
|
new PrintCenterY("posy", "print_center"),
|
|
|
|
new NotPassedItem("", "build_height"),
|
|
|
|
// needs testing, not working
|
|
new ScaledSingleNumber("supportLineDistance", "support_material_spacing", 1000),
|
|
new SupportMatterial("supportAngle", "support_material"),
|
|
new NotPassedItem("", "support_material_threshold"),
|
|
new MapItem("supportEverywhere", "support_material_create_internal_support"),
|
|
new ScaledSingleNumber("supportXYDistance", "support_material_xy_distance", 1000),
|
|
new ScaledSingleNumber("supportZDistance", "support_material_z_distance", 1000),
|
|
|
|
new MapItem("minimalLayerTime", "slowdown_below_layer_time"),
|
|
|
|
new InfillTranslator("sparseInfillLineDistance", "fill_density"),
|
|
|
|
new MapStartGCode("startCode", "start_gcode"),
|
|
new MapEndGCode("endCode", "end_gcode"),
|
|
|
|
#if false
|
|
SETTING(filamentFlow);
|
|
SETTING(infillOverlap);
|
|
|
|
SETTING(initialSpeedupLayers);
|
|
|
|
SETTING(supportExtruder);
|
|
|
|
SETTING(retractionAmountExtruderSwitch);
|
|
SETTING(minimalExtrusionBeforeRetraction);
|
|
SETTING(enableCombing);
|
|
SETTING(multiVolumeOverlap);
|
|
SETTING(objectSink);
|
|
|
|
SETTING(raftMargin);
|
|
SETTING(raftLineSpacing);
|
|
SETTING(raftBaseThickness);
|
|
SETTING(raftBaseLinewidth);
|
|
SETTING(raftInterfaceThickness);
|
|
SETTING(raftInterfaceLinewidth);
|
|
|
|
SETTING(minimalFeedrate);
|
|
|
|
fanFullOnLayerNr = 2;
|
|
|
|
SETTING(fixHorrible);
|
|
SETTING(gcodeFlavor);
|
|
|
|
/*
|
|
objectPosition.X = 102500;
|
|
objectPosition.Y = 102500;
|
|
enableOozeShield = 0;
|
|
*/
|
|
#endif
|
|
};
|
|
|
|
public static string GetCuraCommandLineSettings()
|
|
{
|
|
StringBuilder settings = new StringBuilder();
|
|
for (int i = 0; i < curaToDefaultMapping.Length; i++)
|
|
{
|
|
string curaValue = curaToDefaultMapping[i].CuraValue;
|
|
if(curaValue != null && curaValue != "")
|
|
{
|
|
settings.Append(string.Format("-s {0}=\"{1}\" ", curaToDefaultMapping[i].CuraKey, curaValue));
|
|
}
|
|
}
|
|
|
|
return settings.ToString();
|
|
}
|
|
}
|
|
|
|
public class MapItem
|
|
{
|
|
string curaKey;
|
|
string defaultKey;
|
|
|
|
internal MapItem(string curaKey, string defaultKey)
|
|
{
|
|
this.curaKey = curaKey;
|
|
this.defaultKey = defaultKey;
|
|
}
|
|
|
|
public string CuraKey { get { return curaKey; } }
|
|
public string DefaultKey { get { return defaultKey; } }
|
|
|
|
public string SlicerValue { get { return ActiveSliceSettings.Instance.GetActiveValue(defaultKey); } }
|
|
|
|
public virtual string CuraValue { get { return SlicerValue; } }
|
|
}
|
|
|
|
public class NotPassedItem : MapItem
|
|
{
|
|
public override string CuraValue
|
|
{
|
|
get
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public NotPassedItem(string cura, string slicer)
|
|
: base(cura, slicer)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class FanTranslator : MapItem
|
|
{
|
|
public override string CuraValue
|
|
{
|
|
get
|
|
{
|
|
int numLayersFanIsDisabledOn = int.Parse(base.CuraValue);
|
|
int layerToEnableFanOn = numLayersFanIsDisabledOn+1;
|
|
return layerToEnableFanOn.ToString();
|
|
}
|
|
}
|
|
|
|
public FanTranslator(string cura, string slicer)
|
|
: base(cura, slicer)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class SupportMatterial : MapItem
|
|
{
|
|
public override string CuraValue
|
|
{
|
|
get
|
|
{
|
|
string supportMaterial = ActiveSliceSettings.Instance.GetActiveValue("support_material");
|
|
if (supportMaterial == "0")
|
|
{
|
|
return "-1";
|
|
}
|
|
|
|
return (90 - double.Parse(ActiveSliceSettings.Instance.GetActiveValue("support_material_threshold"))).ToString();
|
|
}
|
|
}
|
|
|
|
public SupportMatterial(string cura, string slicer)
|
|
: base(cura, slicer)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class InfillTranslator : MapItem
|
|
{
|
|
public override string CuraValue
|
|
{
|
|
get
|
|
{
|
|
double infillRatio0To1 = Double.Parse(base.CuraValue);
|
|
// 400 = solid (extruder width)
|
|
double nozzle_diameter = double.Parse(ActiveSliceSettings.Instance.GetActiveValue("nozzle_diameter"));
|
|
double linespacing = 1000;
|
|
if (infillRatio0To1 > .01)
|
|
{
|
|
linespacing = nozzle_diameter / infillRatio0To1;
|
|
}
|
|
|
|
return ((int)(linespacing * 1000)).ToString();
|
|
}
|
|
}
|
|
|
|
public InfillTranslator(string cura, string slicer)
|
|
: base(cura, slicer)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class PrintCenterX : MapItem
|
|
{
|
|
public override string CuraValue
|
|
{
|
|
get
|
|
{
|
|
Vector2 PrinteCenter = ActiveSliceSettings.Instance.PrintCenter;
|
|
return (PrinteCenter.x * 1000).ToString();
|
|
}
|
|
}
|
|
|
|
public PrintCenterX(string cura, string slicer)
|
|
: base(cura, slicer)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class PrintCenterY : MapItem
|
|
{
|
|
public override string CuraValue
|
|
{
|
|
get
|
|
{
|
|
Vector2 PrinteCenter = ActiveSliceSettings.Instance.PrintCenter;
|
|
return (PrinteCenter.y * 1000).ToString();
|
|
}
|
|
}
|
|
|
|
public PrintCenterY(string cura, string slicer)
|
|
: base(cura, slicer)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class ConvertCRs : MapItem
|
|
{
|
|
public override string CuraValue
|
|
{
|
|
get
|
|
{
|
|
string actualCRs = base.CuraValue.Replace("\\n", "\n");
|
|
return actualCRs;
|
|
}
|
|
}
|
|
|
|
public ConvertCRs(string cura, string slicer)
|
|
: base(cura, slicer)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class InjectGCodeCommands : ConvertCRs
|
|
{
|
|
public InjectGCodeCommands(string cura, string slicer)
|
|
: base(cura, slicer)
|
|
{
|
|
}
|
|
|
|
protected void AddDefaultIfNotPresent(List<string> linesAdded, string commandToAdd, string[] linesToCheckIfAlreadyPresent, string comment)
|
|
{
|
|
string command = commandToAdd.Split(' ')[0].Trim();
|
|
bool foundCommand = false;
|
|
foreach (string line in linesToCheckIfAlreadyPresent)
|
|
{
|
|
if (line.StartsWith(command))
|
|
{
|
|
foundCommand = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!foundCommand)
|
|
{
|
|
linesAdded.Add(string.Format("{0} ; {1}", commandToAdd, comment));
|
|
}
|
|
}
|
|
}
|
|
|
|
public class MapStartGCode : InjectGCodeCommands
|
|
{
|
|
public override string CuraValue
|
|
{
|
|
get
|
|
{
|
|
StringBuilder curaStartGCode = new StringBuilder();
|
|
foreach (string line in PreStartGCode())
|
|
{
|
|
curaStartGCode.Append(line + "\n");
|
|
}
|
|
|
|
curaStartGCode.Append(base.CuraValue);
|
|
|
|
bool first = true;
|
|
foreach (string line in PostStartGCode())
|
|
{
|
|
if (!first)
|
|
{
|
|
curaStartGCode.Append("\n");
|
|
}
|
|
curaStartGCode.Append(line);
|
|
first = false;
|
|
}
|
|
|
|
return curaStartGCode.ToString();
|
|
}
|
|
}
|
|
|
|
public MapStartGCode(string cura, string slicer)
|
|
: base(cura, slicer)
|
|
{
|
|
}
|
|
|
|
public List<string> PreStartGCode()
|
|
{
|
|
string startGCode = ActiveSliceSettings.Instance.GetActiveValue("start_gcode");
|
|
string[] preStartGCodeLines = startGCode.Split(new string[] {"\\n"}, StringSplitOptions.RemoveEmptyEntries);
|
|
|
|
List<string> preStartGCode = new List<string>();
|
|
preStartGCode.Add("; automatic settings before start_gcode");
|
|
AddDefaultIfNotPresent(preStartGCode, "G21", preStartGCodeLines, "set units to millimeters");
|
|
AddDefaultIfNotPresent(preStartGCode, "M107", preStartGCodeLines, "fan off");
|
|
double bed_temperature = double.Parse(ActiveSliceSettings.Instance.GetActiveValue("bed_temperature"));
|
|
if (bed_temperature > 0)
|
|
{
|
|
string setBedTempString = string.Format("M190 S{0}", bed_temperature);
|
|
AddDefaultIfNotPresent(preStartGCode, setBedTempString, preStartGCodeLines, "wait for bed temperature to be reached");
|
|
}
|
|
string setTempString = string.Format("M104 S{0}", ActiveSliceSettings.Instance.GetActiveValue("temperature"));
|
|
AddDefaultIfNotPresent(preStartGCode, setTempString, preStartGCodeLines, "set temperature");
|
|
preStartGCode.Add("; settings from start_gcode");
|
|
|
|
return preStartGCode;
|
|
}
|
|
|
|
public List<string> PostStartGCode()
|
|
{
|
|
string startGCode = ActiveSliceSettings.Instance.GetActiveValue("start_gcode");
|
|
string[] postStartGCodeLines = startGCode.Split(new string[] { "\\n" }, StringSplitOptions.RemoveEmptyEntries);
|
|
|
|
List<string> postStartGCode = new List<string>();
|
|
postStartGCode.Add("; automatic settings after start_gcode");
|
|
string setTempString = string.Format("M109 S{0}", ActiveSliceSettings.Instance.GetActiveValue("temperature"));
|
|
AddDefaultIfNotPresent(postStartGCode, setTempString, postStartGCodeLines, "wait for temperature");
|
|
AddDefaultIfNotPresent(postStartGCode, "G90", postStartGCodeLines, "use absolute coordinates");
|
|
postStartGCode.Add(string.Format("{0} ; {1}", "G92 E0", "reset the expected extruder position"));
|
|
AddDefaultIfNotPresent(postStartGCode, "M82", postStartGCodeLines, "use absolute distance for extrusion");
|
|
|
|
return postStartGCode;
|
|
}
|
|
}
|
|
|
|
public class MapEndGCode : InjectGCodeCommands
|
|
{
|
|
public override string CuraValue
|
|
{
|
|
get
|
|
{
|
|
StringBuilder curaEndGCode = new StringBuilder();
|
|
|
|
curaEndGCode.Append(base.CuraValue);
|
|
|
|
curaEndGCode.Append("\n; filament used = filament_used_replace_mm (filament_used_replace_cm3)");
|
|
|
|
return curaEndGCode.ToString();
|
|
}
|
|
}
|
|
|
|
public MapEndGCode(string cura, string slicer)
|
|
: base(cura, slicer)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class SkirtLengthMaping : MapItem
|
|
{
|
|
public SkirtLengthMaping(string curaKey, string defaultKey)
|
|
: base(curaKey, defaultKey)
|
|
{
|
|
}
|
|
|
|
public override string CuraValue
|
|
{
|
|
get
|
|
{
|
|
double lengthToExtrudeMm = double.Parse(base.CuraValue);
|
|
// we need to convert mm of filament to mm of extrusion path
|
|
double amountOfFilamentCubicMms = ActiveSliceSettings.Instance.FillamentDiameter * MathHelper.Tau * lengthToExtrudeMm;
|
|
double extrusionSquareSize = ActiveSliceSettings.Instance.FirstLayerHeight * ActiveSliceSettings.Instance.NozzleDiameter;
|
|
double lineLength = amountOfFilamentCubicMms / extrusionSquareSize;
|
|
|
|
return (lineLength * 1000).ToString();
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ScaledSingleNumber : MapItem
|
|
{
|
|
internal double scale;
|
|
public override string CuraValue
|
|
{
|
|
get
|
|
{
|
|
if (scale != 1)
|
|
{
|
|
return (double.Parse(base.CuraValue) * scale).ToString();
|
|
}
|
|
return base.CuraValue;
|
|
}
|
|
}
|
|
|
|
internal ScaledSingleNumber(string cura, string slicer, double scale = 1)
|
|
: base(cura, slicer)
|
|
{
|
|
this.scale = scale;
|
|
}
|
|
}
|
|
|
|
public class AsPercentOfReferenceOrDirect : ScaledSingleNumber
|
|
{
|
|
internal string slicerReference;
|
|
public override string CuraValue
|
|
{
|
|
get
|
|
{
|
|
if (SlicerValue.Contains("%"))
|
|
{
|
|
string withoutPercent = SlicerValue.Replace("%", "");
|
|
double ratio = double.Parse(withoutPercent) / 100.0;
|
|
string slicerReferenceString = ActiveSliceSettings.Instance.GetActiveValue(slicerReference);
|
|
double valueToModify = double.Parse(slicerReferenceString);
|
|
double finalValue = valueToModify * ratio * scale;
|
|
return finalValue.ToString();
|
|
}
|
|
|
|
return base.CuraValue;
|
|
}
|
|
}
|
|
|
|
internal AsPercentOfReferenceOrDirect(string cura, string slicer, string slicerReference, double scale = 1)
|
|
: base(cura, slicer, scale)
|
|
{
|
|
this.slicerReference = slicerReference;
|
|
}
|
|
}
|
|
}
|