} // Calculate()
/// <summary>
/// Scale the extrusion speeds by the given scale factor
/// </summary>
public void ScaleExtrudeTimes(double scaleFactor)
{
// filter paths
foreach (IToolpath ipath in Paths)
{
ToolpathUtil.ApplyToLeafPaths(ipath, (p) => {
if (p is LinearToolpath3 <PrintVertex> )
{
LinearToolpath3 <PrintVertex> path = p as LinearToolpath3 <PrintVertex>;
if (path != null && path.Type == ToolpathTypes.Deposition)
{
for (int i = 0; i < path.VertexCount; ++i)
{
PrintVertex v = path[i];
double rate = path[i].FeedRate;
double scaledRate = v.FeedRate * scaleFactor;
if (scaledRate < Settings.MinExtrudeSpeed)
{
scaledRate = Settings.MinExtrudeSpeed;
}
v.FeedRate = scaledRate;
path.UpdateVertex(i, v);
}
}
}
});
}
}
/// <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;
LayerTimeS = 0;
ExtrudeTimeS = 0;
TravelTimeS = 0;
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;
}
LayerTimeS += path_time;
if (path.Type == ToolpathTypes.Deposition)
{
ExtrudeTimeS += path_time;
}
else
{
TravelTimeS += path_time;
}
}
} // Calculate()
public List <double> GetZValues()
{
HashSet <double> Zs = new HashSet <double>();
ToolpathUtil.ApplyToLeafPaths(this, (ipath) => {
if (ipath is LinearToolpath3 <IToolpathVertex> )
{
foreach (var v in (ipath as LinearToolpath3 <IToolpathVertex>))
{
Zs.Add(v.Position.z);
}
}
});
return(new List <double>(Zs));
}
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()