OpenNest/OpenNest.Core/Splitting/SpikeGrooveSplit.cs

using System.Collections.Generic;
using OpenNest.Geometry;
using OpenNest.Math;

namespace OpenNest;

/// <summary>
/// Generates interlocking spike/V-groove pairs along the split edge.
/// Spikes protrude from the positive side into the negative side.
/// V-grooves on the negative side receive the spikes for self-alignment during welding.
/// The weld gap (grooveDepth - spikeDepth) is the clearance at the tip when assembled.
/// </summary>
public class SpikeGrooveSplit : ISplitFeature
{
    public string Name => "Spike / V-Groove";

    public SplitFeatureResult GenerateFeatures(
        SplitLine line,
        double extentStart,
        double extentEnd,
        SplitParameters parameters
    )
    {
        var extent = extentEnd - extentStart;
        var pairCount = parameters.SpikePairCount;
        var spikeDepth = parameters.SpikeDepth;
        var grooveDepth = parameters.GrooveDepth;
        var angleRad = OpenNest.Math.Angle.ToRadians(parameters.SpikeAngle / 2);
        var spikeHalfWidth = spikeDepth * PortableMath.Tan(angleRad);
        var grooveHalfWidth = grooveDepth * PortableMath.Tan(angleRad);

        var isVertical = line.Axis == CutOffAxis.Vertical;
        var pos = line.Position;

        // Use custom positions if provided, otherwise place evenly with margin
        var pairPositions = new List<double>();
        if (line.FeaturePositions.Count > 0)
        {
            pairPositions.AddRange(line.FeaturePositions);
        }
        else if (pairCount == 1)
        {
            pairPositions.Add(extentStart + extent / 2);
        }
        else
        {
            var margin = extent * 0.15;
            var usable = extent - 2 * margin;
            for (var i = 0; i < pairCount; i++)
                pairPositions.Add(extentStart + margin + usable * i / (pairCount - 1));
        }

        var negEntities = BuildGrooveSide(
            pairPositions,
            grooveHalfWidth,
            grooveDepth,
            extentStart,
            extentEnd,
            pos,
            isVertical
        );
        var posEntities = BuildSpikeSide(
            pairPositions,
            spikeHalfWidth,
            spikeDepth,
            extentStart,
            extentEnd,
            pos,
            isVertical
        );

        return new SplitFeatureResult(negEntities, posEntities);
    }

    private static List<Entity> BuildGrooveSide(
        List<double> pairPositions,
        double halfWidth,
        double depth,
        double extentStart,
        double extentEnd,
        double pos,
        bool isVertical
    )
    {
        var entities = new List<Entity>();
        var cursor = extentStart;

        foreach (var center in pairPositions)
        {
            var grooveStart = center - halfWidth;
            var grooveEnd = center + halfWidth;

            if (grooveStart > cursor + OpenNest.Math.Tolerance.Epsilon)
                entities.Add(MakeLine(pos, cursor, pos, grooveStart, isVertical));

            entities.Add(MakeLine(pos, grooveStart, pos - depth, center, isVertical));
            entities.Add(MakeLine(pos - depth, center, pos, grooveEnd, isVertical));

            cursor = grooveEnd;
        }

        if (extentEnd > cursor + OpenNest.Math.Tolerance.Epsilon)
            entities.Add(MakeLine(pos, cursor, pos, extentEnd, isVertical));

        return entities;
    }

    private static List<Entity> BuildSpikeSide(
        List<double> pairPositions,
        double halfWidth,
        double depth,
        double extentStart,
        double extentEnd,
        double pos,
        bool isVertical
    )
    {
        var entities = new List<Entity>();
        var cursor = extentEnd;

        for (var i = pairPositions.Count - 1; i >= 0; i--)
        {
            var center = pairPositions[i];
            var spikeEnd = center + halfWidth;
            var spikeStart = center - halfWidth;

            if (cursor > spikeEnd + OpenNest.Math.Tolerance.Epsilon)
                entities.Add(MakeLine(pos, cursor, pos, spikeEnd, isVertical));

            entities.Add(MakeLine(pos, spikeEnd, pos - depth, center, isVertical));
            entities.Add(MakeLine(pos - depth, center, pos, spikeStart, isVertical));

            cursor = spikeStart;
        }

        if (cursor > extentStart + OpenNest.Math.Tolerance.Epsilon)
            entities.Add(MakeLine(pos, cursor, pos, extentStart, isVertical));

        return entities;
    }

    private static Line MakeLine(
        double splitAxis1,
        double along1,
        double splitAxis2,
        double along2,
        bool isVertical
    )
    {
        return isVertical
            ? new Line(new Vector(splitAxis1, along1), new Vector(splitAxis2, along2))
            : new Line(new Vector(along1, splitAxis1), new Vector(along2, splitAxis2));
    }
}