计算直方图的最小值和最大值

Question

I have an image that is grayscale (has a single band) with values ranging from -182 to 94. However, for the most part, the histogram of the image occupies just a narrow range as shown in the diagram below. I have the values of the pixels in an array. I want to find the start and end of the histogram (in this case around 22 to 70). Is there any built in function that I can use to do that? I am using C#, Emgu CV and GDAL

Answer 1

If I understand correctly, you can pixels as an sbyte array, in which case this works for me:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleMinMax
{
    class Program
    {
        static void Main(string[] args)
        {
            sbyte[] array1 = { 1, -1, -2, 0, 99, -111 };

            MinMax(array1);

            void MinMax(sbyte[] array)
            {
                // Report minimum and maximum values.
                Console.WriteLine("max = {0}; min = {1}", array.Max(), array.Min());
            }
        }
    }
}

Answer 2

Assuming your histogram values are in an int[] called hist , you can use some LINQ extension methods to find the largest contiguous group of values, and find their start and end positions in the array. This is overkill if your histogram simply has all zeros with one non-zero area, and does not handle multiple non-zero areas very well - it just picks the longest horizontal span.

var histPos = hist
                .Select((hval, pos) => new { hval, pos })
                .GroupByWhile((prev,cur) => prev.hval != 0 && cur.hval != 0)
                .MaxBy(zvg => zvg.Count())
                .Select(zvg => zvg.pos);
var start = histPos.Min();
var end = histPos.Max();

The extension methods I used are GroupByWhile which groups sequential objects as long as a boolean lambda returns true, and MaxBy which returns the object that has the largest return value from a lambda.

public static class IEnumerableExt {
    // TKey combineFn((TKey Key, T Value) PrevKeyItem, T curItem):
    // PrevKeyItem.Key = Previous Key
    // PrevKeyItem.Value = Previous Item
    // curItem = Current Item
    // returns new Key
    public static IEnumerable<(TKey Key, T Value)> ScanPair<T, TKey>(this IEnumerable<T> src, TKey seedKey, Func<(TKey Key, T Value), T, TKey> combineFn) {
        using (var srce = src.GetEnumerator()) {
            if (srce.MoveNext()) {
                var prevkv = (seedKey, srce.Current);

                while (srce.MoveNext()) {
                    yield return prevkv;
                    prevkv = (combineFn(prevkv, srce.Current), srce.Current);
                }
                yield return prevkv;
            }
        }
    }

        // bool testFn(T prevItem, T curItem)
    // returns groups by sequential matching bool
    public static IEnumerable<IGrouping<int, T>> GroupByWhile<T>(this IEnumerable<T> src, Func<T, T, bool> testFn) =>
        src.ScanPair(1, (kvp, cur) => testFn(kvp.Value, cur) ? kvp.Key : kvp.Key + 1)
           .GroupBy(kvp => kvp.Key, kvp => kvp.Value);

    public static T MaxBy<T, TKey>(this IEnumerable<T> src, Func<T, TKey> keySelector, Comparer<TKey> keyComparer) => src.Aggregate((a, b) => keyComparer.Compare(keySelector(a), keySelector(b)) > 0 ? a : b);
    public static T MaxBy<T, TKey>(this IEnumerable<T> src, Func<T, TKey> keySelector) => src.Aggregate((a, b) => Comparer<TKey>.Default.Compare(keySelector(a), keySelector(b)) > 0 ? a : b);    
}