Пример #1
0
        private void ProcessSliceData(LayerDataStorage slicingData)
        {
            if (config.ContinuousSpiralOuterPerimeter)
            {
                config.NumberOfTopLayers = 0;
                config.InfillPercent = 0;
            }

            MultiExtruders.ProcessBooleans(slicingData.Extruders, config.BooleanOpperations);

            MultiExtruders.RemoveExtruderIntersections(slicingData.Extruders);
            MultiExtruders.OverlapMultipleExtrudersSlightly(slicingData.Extruders, config.MultiExtruderOverlapPercent);
            #if False
            LayerPart.dumpLayerparts(slicingData, "output.html");
            #endif

            if (config.GenerateSupport && !config.ContinuousSpiralOuterPerimeter)
            {
                LogOutput.Log("Generating support map...\n");
                slicingData.support = new NewSupport(config, slicingData.Extruders, 1);
            }

            slicingData.CreateIslandData();

            int totalLayers = slicingData.Extruders[0].Layers.Count;
            if (config.outputOnlyFirstLayer)
            {
                totalLayers = 1;
            }
            #if DEBUG
            for (int extruderIndex = 1; extruderIndex < slicingData.Extruders.Count; extruderIndex++)
            {
                if (totalLayers != slicingData.Extruders[extruderIndex].Layers.Count)
                {
                    throw new Exception("All the extruders must have the same number of layers (they just can have empty layers).");
                }
            }
            #endif

            for (int layerIndex = 0; layerIndex < totalLayers; layerIndex++)
            {
                for (int extruderIndex = 0; extruderIndex < slicingData.Extruders.Count; extruderIndex++)
                {
                    if (MatterSlice.Canceled)
                    {
                        return;
                    }
                    int insetCount = config.NumberOfPerimeters;
                    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;
                    }

                    SliceLayer layer = slicingData.Extruders[extruderIndex].Layers[layerIndex];

                    if (layerIndex == 0)
                    {
                        layer.GenerateInsets(config.FirstLayerExtrusionWidth_um, config.FirstLayerExtrusionWidth_um, insetCount);
                    }
                    else
                    {
                        layer.GenerateInsets(config.ExtrusionWidth_um, config.OutsideExtrusionWidth_um, insetCount);
                    }
                }
                LogOutput.Log("Creating Insets {0}/{1}\n".FormatWith(layerIndex + 1, totalLayers));
            }

            slicingData.CreateWipeShield(totalLayers, config);

            LogOutput.Log("Generated inset in {0:0.0}s\n".FormatWith(timeKeeper.Elapsed.TotalSeconds));
            timeKeeper.Restart();

            for (int layerIndex = 0; layerIndex < totalLayers; layerIndex++)
            {
                if (MatterSlice.Canceled)
                {
                    return;
                }

                //Only generate bottom and top layers and infill for the first X layers when spiralize is chosen.
                if (!config.ContinuousSpiralOuterPerimeter || (int)(layerIndex) < config.NumberOfBottomLayers)
                {
                    for (int extruderIndex = 0; extruderIndex < slicingData.Extruders.Count; extruderIndex++)
                    {
                        if (layerIndex == 0)
                        {
                            slicingData.Extruders[extruderIndex].GenerateTopAndBottoms(layerIndex, config.FirstLayerExtrusionWidth_um, config.FirstLayerExtrusionWidth_um, config.NumberOfBottomLayers, config.NumberOfTopLayers);
                        }
                        else
                        {
                            slicingData.Extruders[extruderIndex].GenerateTopAndBottoms(layerIndex, config.ExtrusionWidth_um, config.OutsideExtrusionWidth_um, config.NumberOfBottomLayers, config.NumberOfTopLayers);
                        }
                    }
                }
                LogOutput.Log("Creating Top & Bottom Layers {0}/{1}\n".FormatWith(layerIndex + 1, totalLayers));
            }
            LogOutput.Log("Generated top bottom layers in {0:0.0}s\n".FormatWith(timeKeeper.Elapsed.TotalSeconds));
            timeKeeper.Restart();

            slicingData.CreateWipeTower(totalLayers, config);

            if (config.EnableRaft)
            {
                slicingData.GenerateRaftOutlines(config.RaftExtraDistanceAroundPart_um, config);

                slicingData.GenerateSkirt(
                    config.SkirtDistance_um + config.RaftBaseLineSpacing_um,
                    config.RaftBaseLineSpacing_um,
                    config.NumberOfSkirtLoops,
                    config.NumberOfBrimLoops,
                    config.SkirtMinLength_um,
                    config.RaftBaseThickness_um, config);
            }
            else
            {
                slicingData.GenerateSkirt(
                    config.SkirtDistance_um,
                    config.FirstLayerExtrusionWidth_um,
                    config.NumberOfSkirtLoops,
                    config.NumberOfBrimLoops,
                    config.SkirtMinLength_um,
                    config.FirstLayerThickness_um, config);
            }
        }