/// <summary>
/// Calculate the extrusion and travel times
/// </summary>
public void Calculate()
{
// [TODO] could do this inline...
// filter paths
List <IToolpath> allPaths = new List <IToolpath>();
foreach (IToolpath ipath in Paths)
{
ToolpathUtil.ApplyToLeafPaths(ipath, (p) =>
{
if (p is LinearToolpath3 <PrintVertex> )
{
allPaths.Add(p);
}
});
}
int N = allPaths.Count;
TimeStatistics = new PrintTimeStatistics();
for (int pi = 0; pi < N; ++pi)
{
LinearToolpath3 <PrintVertex> path = allPaths[pi] as LinearToolpath3 <PrintVertex>;
if (path == null || (path.Type != ToolpathTypes.Deposition && path.Type != ToolpathTypes.Travel))
{
continue;
}
double path_time = 0;
Vector3d curPos = path[0].Position;
for (int i = 1; i < path.VertexCount; ++i)
{
bool last_vtx = (i == path.VertexCount - 1);
Vector3d newPos = path[i].Position;
double newRate = path[i].FeedRate;
double dist = (newPos - curPos).Length;
double rate_mm_per_s = newRate / 60; // feed rates are in mm/min
path_time += dist / rate_mm_per_s;
curPos = newPos;
}
if (path.Type == ToolpathTypes.Deposition)
{
TimeStatistics.ExtrudeTimeS += path_time;
}
else
{
TimeStatistics.TravelTimeS += path_time;
}
}
} // Calculate()
public static void SetConstantPerVertexData <T>(LinearToolpath3 <T> toolpath, TPVertexData data) where T : IToolpathVertex
{
int N = toolpath.VertexCount;
for (int i = 0; i < N; ++i)
{
T vtx = toolpath[i];
vtx.ExtendedData = data;
toolpath.UpdateVertex(i, vtx);
}
}
public static void AddPerVertexFlags <T>(LinearToolpath3 <T> toolpath, IList <TPVertexFlags> flags) where T : IToolpathVertex
{
int N = toolpath.VertexCount;
for (int i = 0; i < N; ++i)
{
T vtx = toolpath[i];
if (vtx.ExtendedData == null)
{
vtx.ExtendedData = new TPVertexData();
}
vtx.ExtendedData.Flags |= flags[i];
toolpath.UpdateVertex(i, vtx);
}
}
public void Calculate(Vector3d vStartPos, double fStartA, bool alreadyInRetract = false)
{
double curA = fStartA;
Vector3d curPos = vStartPos;
double curRate = 0;
bool inRetract = alreadyInRetract;
// filter paths
List <IToolpath> allPaths = new List <IToolpath>();
foreach (IToolpath p in Paths)
{
if (p is LinearToolpath3 <T> || p is ResetExtruderPathHack)
{
allPaths.Add(p);
}
}
int N = allPaths.Count;
LinearToolpath3 <T> prev_path = null;
for (int pi = 0; pi < N; ++pi)
{
if (allPaths[pi] is ResetExtruderPathHack)
{
curA = 0;
continue;
}
var path = allPaths[pi] as LinearToolpath3 <T>;
if (path == null)
{
throw new Exception("Invalid path type!");
}
if (!(path.Type == ToolpathTypes.Deposition || path.Type == ToolpathTypes.PlaneChange || path.Type == ToolpathTypes.Travel))
{
throw new Exception("Unknown path type!");
}
// if we are travelling between two extrusion paths, and neither is support,
// and the travel distance is very short,then we will skip the retract.
// [TODO] should only do this on interior travels. We should determine that upstream and set a flag on travel path.
bool skip_retract = false;
if (path.Type == ToolpathTypes.Travel && path.Length < MinRetractTravelLength)
{
bool prev_is_model_deposition =
(prev_path != null) && (prev_path.Type == ToolpathTypes.Deposition) && prev_path.FillType.IsPart();
var next_path = (pi < N - 1) ? (allPaths[pi + 1] as LinearToolpath3 <T>) : null;
bool next_is_model_deposition =
(next_path != null) && (next_path.Type == ToolpathTypes.Deposition) && next_path.FillType.IsPart();
skip_retract = prev_is_model_deposition && next_is_model_deposition;
}
if (EnableRetraction == false)
{
skip_retract = true;
}
// figure out volume scaling based on path type
double vol_scale = 1.0;
vol_scale = path.FillType.AdjustVolume(vol_scale);
for (int i = 0; i < path.VertexCount; ++i)
{
bool last_vtx = (i == path.VertexCount - 1);
Vector3d newPos = path[i].Position;
double newRate = path[i].FeedRate;
// default line thickness and height
double path_width = Settings.Machine.NozzleDiamMM;
double path_height = Settings.Part.LayerHeightMM;
// override with custom dimensions if provided
Vector2d vtx_dims = path[i].Dimensions;
if (vtx_dims.x > 0 && vtx_dims.x < 1000.0)
{
path_width = vtx_dims.x;
}
if (vtx_dims.y > 0 && vtx_dims.y < 1000.0)
{
path_height = vtx_dims.y;
}
if (path.Type != ToolpathTypes.Deposition)
{
// [RMS] if we switched to a travel move we retract, unless we don't
if (skip_retract == false)
{
if (!inRetract)
{
curA -= FixedRetractDistance;
inRetract = true;
}
}
curPos = newPos;
curRate = newRate;
}
else
{
// for i == 0 this dist is always 0 !!
double dist = (newPos - curPos).Length;
if (i == 0)
{
Util.gDevAssert(dist < 1e-12); // next path starts at end of previous!!
if (inRetract)
{
curA += FixedRetractDistance;
inRetract = false;
}
}
else
{
curPos = newPos;
curRate = newRate;
double segment_width = (path[i].Dimensions.x != GCodeUtil.UnspecifiedValue) ?
path[i].Dimensions.x : path_width;
double segment_height = (path[i].Dimensions.y != GCodeUtil.UnspecifiedValue) ?
path[i].Dimensions.y : path_height;
double feed = ExtrusionMath.PathLengthToFilamentLength(
segment_height, segment_width, Settings.Material.FilamentDiamMM,
dist, vol_scale);
// Change the extrusion amount if a modifier is present.
// TODO: This is a bit of a hack since the modifier acts on a Vector3d
// and we're ignoring data in the second & third positions.
var modifier = path[i]?.ExtendedData?.ExtrusionModifierF;
if (modifier != null)
{
feed = modifier(new Vector3d(feed, 0, 0))[0];
}
curA += feed;
}
}
T v = path[i];
v.Extrusion = GCodeUtil.Extrude(curA);
path.UpdateVertex(i, v);
}
prev_path = path;
}
NumPaths = N;
ExtrusionLength = curA;
} // Calculate()
public void Calculate(Vector3d vStartPos, double fStartA, bool alreadyInRetract = false)
{
double curA = fStartA;
Vector3d curPos = vStartPos;
double curRate = 0;
bool inRetract = alreadyInRetract;
// filter paths
List <IToolpath> allPaths = new List <IToolpath>();
foreach (IToolpath ipath in Paths)
{
ToolpathUtil.ApplyToLeafPaths(ipath, (p) => {
if (p is LinearToolpath3 <PrintVertex> || p is ResetExtruderPathHack)
{
allPaths.Add(p);
}
});
}
int N = allPaths.Count;
LinearToolpath3 <PrintVertex> prev_path = null;
for (int pi = 0; pi < N; ++pi)
{
if (allPaths[pi] is ResetExtruderPathHack)
{
curA = 0;
continue;
}
LinearToolpath3 <PrintVertex> path = allPaths[pi] as LinearToolpath3 <PrintVertex>;
if (path == null)
{
throw new Exception("Invalid path type!");
}
if (!(path.Type == ToolpathTypes.Deposition || path.Type == ToolpathTypes.PlaneChange || path.Type == ToolpathTypes.Travel))
{
throw new Exception("Unknown path type!");
}
// if we are travelling between two extrusion paths, and neither is support,
// and the travel distance is very short,then we will skip the retract.
// [TODO] should only do this on interior travels. We should determine that upstream and set a flag on travel path.
bool skip_retract = false;
if (path.Type == ToolpathTypes.Travel && path.Length < MinRetractTravelLength)
{
bool prev_is_model_deposition =
(prev_path != null) && (prev_path.Type == ToolpathTypes.Deposition) && ((prev_path.TypeModifiers & FillTypeFlags.SupportMaterial) == 0);
LinearToolpath3 <PrintVertex> next_path = (pi < N - 1) ? (allPaths[pi + 1] as LinearToolpath3 <PrintVertex>) : null;
bool next_is_model_deposition =
(next_path != null) && (next_path.Type == ToolpathTypes.Deposition) && ((next_path.TypeModifiers & FillTypeFlags.SupportMaterial) == 0);
skip_retract = prev_is_model_deposition && next_is_model_deposition;
}
if (EnableRetraction == false)
{
skip_retract = true;
}
// figure out volume scaling based on path type
double vol_scale = 1.0;
if ((path.TypeModifiers & FillTypeFlags.SupportMaterial) != 0)
{
vol_scale *= SupportExtrudeScale;
}
else if ((path.TypeModifiers & FillTypeFlags.BridgeSupport) != 0)
{
vol_scale *= Settings.BridgeVolumeScale;
}
for (int i = 0; i < path.VertexCount; ++i)
{
bool last_vtx = (i == path.VertexCount - 1);
Vector3d newPos = path[i].Position;
double newRate = path[i].FeedRate;
// default line thickness and height
double path_width = Settings.Machine.NozzleDiamMM;
double path_height = Settings.LayerHeightMM;
// override with custom dimensions if provided
Vector2d vtx_dims = path[i].Dimensions;
if (vtx_dims.x > 0 && vtx_dims.x < 1000.0)
{
path_width = vtx_dims.x;
}
if (vtx_dims.y > 0 && vtx_dims.y < 1000.0)
{
path_height = vtx_dims.y;
}
if (path.Type != ToolpathTypes.Deposition)
{
// [RMS] if we switched to a travel move we retract, unless we don't
if (skip_retract == false)
{
if (!inRetract)
{
curA -= FixedRetractDistance;
inRetract = true;
}
}
curPos = newPos;
curRate = newRate;
}
else
{
// for i == 0 this dist is always 0 !!
double dist = (newPos - curPos).Length;
if (i == 0)
{
Util.gDevAssert(dist == 0); // next path starts at end of previous!!
if (inRetract)
{
curA += FixedRetractDistance;
inRetract = false;
}
}
else
{
curPos = newPos;
curRate = newRate;
double feed = ExtrusionMath.PathLengthToFilamentLength(
path_height, path_width, Settings.Machine.FilamentDiamMM,
dist, vol_scale);
curA += feed;
}
}
PrintVertex v = path[i];
v.Extrusion = GCodeUtil.Extrude(curA);
path.UpdateVertex(i, v);
}
prev_path = path;
}
NumPaths = N;
ExtrusionLength = curA;
} // Calculate()
