public void CalculateInfillData(ConfigSettings config,
int extruderIndex,
int layerIndex,
LayerIsland part,
Polygons bottomFillLines,
Polygons sparseFillPolygons = null,
Polygons solidFillPolygons = null,
Polygons firstTopFillPolygons = null,
Polygons topFillPolygons = null,
Polygons bridgePolygons = null,
Polygons bridgeAreas = null)
{
double alternatingInfillAngle = config.InfillStartingAngle;
if ((layerIndex % 2) == 0)
{
alternatingInfillAngle += 90;
}
// generate infill for the bottom layer including bridging
foreach (Polygons bottomFillIsland in part.BottomPaths.ProcessIntoSeparateIslands())
{
if (layerIndex > 0)
{
if (this.Support != null)
{
double infillAngle = config.SupportInterfaceLayers > 0 ? config.InfillStartingAngle : config.InfillStartingAngle + 90;
Infill.GenerateLinePaths(bottomFillIsland, bottomFillLines, config.ExtrusionWidth_um, config.InfillExtendIntoPerimeter_um, infillAngle);
}
else
{
SliceLayer previousLayer = this.Extruders[extruderIndex].Layers[layerIndex - 1];
if (bridgePolygons != null &&
previousLayer.BridgeAngle(bottomFillIsland, config.GetNumberOfPerimeters() * config.ExtrusionWidth_um, out double bridgeAngle, bridgeAreas))
{
// TODO: Make this code handle very complex pathing between different sizes or layouts of support under the island to fill.
Infill.GenerateLinePaths(bottomFillIsland, bridgePolygons, config.ExtrusionWidth_um, config.InfillExtendIntoPerimeter_um, bridgeAngle);
}
else // we still need to extrude at bridging speed
{
Infill.GenerateLinePaths(bottomFillIsland, bottomFillLines, config.ExtrusionWidth_um, config.InfillExtendIntoPerimeter_um, alternatingInfillAngle, 0, config.BridgeSpeed);
}
}
}
public void CreateRequiredInsets(ConfigSettings config, int outputLayerIndex, int extruderIndex)
{
if (extruderIndex < this.Extruders.Count)
{
var startIndex = Math.Max(0, outputLayerIndex - config.NumberOfBottomLayers - 1);
// figure out how many layers we need to calculate
var endIndex = outputLayerIndex + config.NumberOfTopLayers + 1;
var threadExtra = 10;
endIndex = (endIndex / threadExtra) * threadExtra + threadExtra;
// now bias more in to help multi threading
// and clamp to the number there are to make sure we can do it
endIndex = Math.Min(endIndex, this.Extruders[extruderIndex].Layers.Count);
// free up the insets from the previous layer
if (startIndex > config.NumberOfBottomLayers + 1)
{
SliceLayer previousLayer = this.Extruders[extruderIndex].Layers[startIndex - 2];
previousLayer.FreeIslandMemory();
}
using (new QuickTimer2("GenerateInsets"))
{
for (int layerIndex = startIndex; layerIndex < endIndex; layerIndex++)
{
SliceLayer layer = this.Extruders[extruderIndex].Layers[layerIndex];
if (layer.Islands.Count > 0 &&
!layer.CreatedInsets)
{
layer.CreatedInsets = true;
int insetCount = config.GetNumberOfPerimeters();
if (config.ContinuousSpiralOuterPerimeter && (int)layerIndex < config.NumberOfBottomLayers && layerIndex % 2 == 1)
{
// Add extra insets every 2 layers when spiralizing, this makes bottoms of cups watertight.
insetCount += 1;
}
if (layerIndex == 0)
{
layer.GenerateInsets(config, config.FirstLayerExtrusionWidth_um, config.FirstLayerExtrusionWidth_um, insetCount);
}
else
{
layer.GenerateInsets(config, config.ExtrusionWidth_um, config.OutsideExtrusionWidth_um, insetCount);
}
}
}
}
using (new QuickTimer2("GenerateTopAndBottoms"))
{
// Only generate bottom and top layers and infill for the first X layers when spiralize is chosen.
if (!config.ContinuousSpiralOuterPerimeter || (int)outputLayerIndex < config.NumberOfBottomLayers)
{
if (outputLayerIndex == 0)
{
this.Extruders[extruderIndex].GenerateTopAndBottoms(config, outputLayerIndex, config.FirstLayerExtrusionWidth_um, config.FirstLayerExtrusionWidth_um, config.NumberOfBottomLayers, config.NumberOfTopLayers, config.InfillExtendIntoPerimeter_um);
}
else
{
this.Extruders[extruderIndex].GenerateTopAndBottoms(config, outputLayerIndex, config.ExtrusionWidth_um, config.OutsideExtrusionWidth_um, config.NumberOfBottomLayers, config.NumberOfTopLayers, config.InfillExtendIntoPerimeter_um);
}
}
}
}
}
