What's a good way to select the steepest local maxima C#?

I'm trying to find the 4 steepest local maxima (corners of a piece) in a polar coordinate plot generated from a Jigsaw Piece, example plot:

My current implementation, which uses the same idea as this answer and works perfectly, but when combined with a "steepest peaks" function, does not work well, the issue most certainly lies in how a peak is measured for its "steepness".

Here is the "steepest peak" determining function, it returns a single number, smaller is better.

    public double GetMagnitude(List<Point> pointList, int centerIndex)
    {
        Point crrt = pointList[centerIndex];
        Point prev = pointList[centerIndex - 1];
        Point next = pointList[centerIndex + 1];

        Point rhs = new Point((next - crrt).x, (next - crrt).y);
        Point lhs = new Point((prev - crrt).x, (prev - crrt).y);

        // Calculate the gradient of the lhs against the rhs
        return Math.Abs((lhs.y - rhs.y) / (lhs.x - rhs.x));
    }

It's called like so (where averageRange is 20, and the number of sample points to take across the curve from the centerIndex)

    public double GetAverageMagnitude(List<Point> pointList, int centerIndex)
    {
        double mag = 0;
        int halfAverageRange = averageRange / 2;
        for (int j = -halfAverageRange; j < halfAverageRange; j++)
        {
            mag += GetMagnitude(pointList, centerIndex + j);
        }

        return mag / averageRange;
    }

The math at the end of the GetMagnitude() function could be entirely wrong, I have also tried:

• Cross product of lhs against rhs
• Separately calculating gradient of lhs and rhs and averaging them (absolute)
  No luck on any of those methods, the current one is the best so far, yet it's not good enough.

See example below for incorrect vs correct identification:

Note: Each consecutive points X value follows X=i, as in, X₀ = 0, X₁ = 1

How can I improve these results?

I don't know if it will be useful, but this is a pretty straight-forward algorithm I've just coded. It is not math-based, you will definitely find counter-examples that won't work I'm afraid.

private static void GetPeeks(List<int> points)
{
    var acc = ForwardIncrease(points);
    var dec = BackwardIncrease(points);

    var mul = new List<int>();

    for (int i = 0; i < acc.Count; i++)
    {
        mul.Add(acc[i] * dec[i]);
    }

    //in mul, greatest values are the peaks (minima and maxima)
}

private static List<int> ForwardIncrease(List<int> points)
{
    var result = new List<int>();
    var previous = points[0];
    var cumul = 0;

    foreach (var point in points)
    {
        var diff = point - previous;

        if (diff >= 0 && cumul >= 0)
        {
            cumul += diff;
        }
        else if (diff <= 0 && cumul <= 0)
        {
            cumul += diff;
        }
        else
        {
            cumul = diff;
        }

        result.Add(cumul);
        previous = point;
    }

    return result;
}

private static List<int> BackwardIncrease(List<int> points)
{
    var result = new List<int>();
    var previous = points[points.Count - 1];
    var cumul = 0;

    for (int i = points.Count - 1; i >= 0; i--)
    {
        var point = points[i];
        var diff = point - previous;

        if (diff >= 0 && cumul >= 0)
        {
            cumul += diff;
        }
        else if (diff <= 0 && cumul <= 0)
        {
            cumul += diff;
        }
        else
        {
            cumul = diff;
        }

        result.Insert(0, cumul);
        previous = point;
    }

    return result;
}

I managed to fix this relatively easy after lots of experimentation.

Firstly, I made sure to reduce any noise in the data where possible, giving cleaner looking curves without sacrificing (too much) the sharpness of the peaks of interest. In my case, I increased the blur on the original image that the polar plot was made from.

Secondly, I took @BenVoigt's advice and switched to using a second derivative equation for calculating the "sharpness" of points along the curve. This gave more accurate readings across all points on the graph.

Then, I switched from using a mean average to a median average, this left the steeper, more curved parts of the graph with a distinctly greater median making the selection process much more accurate.

To help with testing, I also decreased the scale of the Y axis to make it easier to see what was happening, example below: