C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/Mathematics/EdgeDetector.cs

//-----------------------------------------------------------------------------
// EdgeDetector.cs
// (A. Schiffler, 2009)
//-----------------------------------------------------------------------------

namespace NewGamePhysics.Mathematics
{
    using System;

    public enum EdgeDetectionType
    {
        Rising,

        Falling,

        Both,
    }

    public class EdgeDetector
    {
        private EdgeDetectionType detectionType;

        private double threshold;

        private EdgeDetector()
        {
        }

        public EdgeDetector(EdgeDetectionType detectionType, double threshold)
        {
            this.detectionType = detectionType;
            this.threshold = threshold;
        }

        public double[] Calculate(double[] samples)
        {
            int nMax = samples.Length;
            double[] result = new double[nMax];

            // Make absolute and determine maximum
            double maximum = Math.Abs(samples[0]);
            for (int i = 0; i < nMax; i++)
            {
                double value = Math.Abs(samples[i]);
                result[i] = value;
                if (value > maximum)
                {
                    maximum = value;
                }
            }

            // Binarize
            double margin = maximum * this.threshold;
            for (int i = 0; i < nMax; i++)
            {
                result[i] = (result[i] > margin) ? 1.0 : 0.0;
            }

            // Edge detect
            double lastValue = 0.0;
            for (int i = 0; i < nMax; i++)
            {
                bool risingEdge = ((lastValue == 0.0) && (result[i] == 1.0));
                bool fallingEdge = ((lastValue == 1.0) && (result[i] == 0.0));
                lastValue = result[i];
                switch (this.detectionType)
                {
                    case EdgeDetectionType.Falling:
                        result[i] = (fallingEdge) ? 1.0 : 0.0;
                        break;
                    case EdgeDetectionType.Rising:
                        result[i] = (risingEdge) ? 1.0 : 0.0;
                        break;
                    case EdgeDetectionType.Both:
                        result[i] = (risingEdge || fallingEdge) ? 1.0 : 0.0;
                        break;
                }
            }

            return result;
        }
    }
}

---