Алгоритм распознавания подписи

[Николая Ленин]

Очень нужна помощь с задачей. Нужно составить алгоритм распознавания подписи. Задача должна выглядеть так: по мере рисования подписи, программа определяет направление движения мыши, «округляя» его до одного из четырёх основных направлений: left, right, up, down. Повторение одного и того же направления игнорируется (то есть «LLLLL» считается одной «L») — это нивелирует разницу в масштабах жестов.
В результате, подпись можно представить в виде сравнительно короткой последовательности а-ля ULDRUDRULDR, где каждый символ занимает всего два бита.
Распознавание направления делается так: когда мышь сместилась на N пикселей от начальной точки, сравниваем Δx c Δy, и их знаки; если полученное направление отличается от предыдущего — добавляем его в цепочку распознанных.

[Guy]

Вперёд дерзай Ты такой ответ хотел услышать ?

[Николая Ленин]

Ответ, в котором мне бы пояснили, как это сделать, был бы куда уместнее

[Abstraction]

Вы говорите, что нужно составить алгоритм и приводите пример уже составленного алгоритма. Вопрос "а что делать-то?" вполне естественен в таких обстоятельствах.

[Николая Ленин]

Нужна помощь в его реализации

[raxp]

...начните с GetCursorPos()/

[ImmortalAlexSan]

Можно сделать класс "Линия". Где укажите длину линии - допутимая погрешность для определения напрявления. Линия может состоять всего из двух пикселов - это минимальная погрешность. Направление линии - сравнение начальной и конечной координаты линии. Может представлять из себя обычную структуру с вриантами выбора.
Вот небольшой пример. Что смог написать, пока свободное время было.

public class MyLine
    {
        private enum Direction
        {
            Left, Up, Right, Down
        }

        private Point _startPoint;
        private Point _endPoint;
        private int _tolerance;
        private double _length;
        private Direction _direction;

        public int Tolerance { get { return this._tolerance; } }
        public double Length { get { return this._length; } }
        //public Direction Direction { get { return this._direction; } private set { value = this._direction; } }

        public MyLine(int tolerance)
        {
            this._tolerance = tolerance;
        }

        public void SetStartPoint(Point point)
        {
            this._startPoint = point;
        }

        public void SetEndPoint(Point point)
        {
            this._endPoint = point;
        }

        public void DeterminateDirection()
        {

        }

        public bool LimitingLength()
        {
            double length = CalculateLength();

            if (length > this._tolerance)
            {
                this._length = this._tolerance;
                return true;
            }
            else
            {
                this._length = length;
                return false;
            }
        }

        private double CalculateLength()
        {
            int legLength_1 = Math.Abs(this._endPoint.X - this._startPoint.X);
            int legLength_2 = Math.Abs(this._endPoint.Y - this._startPoint.Y);
            double hypotenuseLength = Math.Sqrt((double)(legLength_1 * legLength_1 + legLength_2 * legLength_2));

            return hypotenuseLength;
        }
    }

Класс позволяет вычислять длину линии, сравнивая ее с допустимой длиной, заданной изначально. Делать это нужно для точности определения распознавания. Минус кода в том, что когда устанавливаешь погрешность больше 2-х пикселей, будут определяться только длинные линии. Нужно доработать это. Зная положение начальных точек и конечных, можно определить угол наклона. Это несложно. будет время допишу. И от туда уже определить направление. Вот применение класса.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WindowsFormsApplication4
{
    public partial class Form1 : Form
    {
        public List<MyLine> MyLines;
        public int i = 0;
        public Point LastPoint;

        public Form1()
        {
            this.MyLines = new List<MyLine>();
            InitializeComponent();
        }

        private void Form1_MouseDown(object sender, MouseEventArgs e)
        {
            MyLine myLine = new MyLine(100);
            myLine.SetStartPoint(new Point(e.X, e.Y));

            this.MyLines.Add(myLine);
        }

        private void Form1_MouseMove(object sender, MouseEventArgs e)
        {
            if (e.Button == System.Windows.Forms.MouseButtons.Left)
            {
                this.Text = e.X.ToString() + " x " + e.Y.ToString();
                Graphics g = this.CreateGraphics();
                g.DrawLine(new Pen(new System.Drawing.Drawing2D.LinearGradientBrush(new Point(1, 0), new Point(0, 1), Color.Black, Color.Red)), new Point(e.X, e.Y), this.LastPoint);

                this.MyLines[i].SetEndPoint(new Point(e.X, e.Y));

                if (this.MyLines[i].LimitingLength())
                {
                    MessageBox.Show("Line coordinates are saved! Line length = " + this.MyLines[i].Length.ToString() + "New line start generateing");

                    MyLine myLine = new MyLine(100);
                    myLine.SetStartPoint(new Point(e.X, e.Y));

                    this.MyLines.Add(myLine);

                    i++;
                }

                this.LastPoint = new Point(e.X, e.Y);

                g.Dispose();
            }
        }
    }
}

Все вставите в проект с пустой формой. Дальше разберетесь однозначно. Но это касательно вашего алгоритма...
Писал на скорую руку, по этому на касяки-маляки внимания не обращайте!

[ImmortalAlexSan]

А что косается наклона. То будет примерно так:

if ((Math.Abs(x2) / Math.Abs(y2)) > 1)
{
    if (x2 > x1) -> Right;
    else -> Left;
}
else
{
    if (y2 > y1) -> Up;
    else -> Down;
}

[ImmortalAlexSan]

    public enum LineDirection
    {
        Left = 0,
        Up = 1,
        Right = 2,
        Down = 3
    }

    public class MyLine
    {
        private Point _startPoint;
        private Point _endPoint;
        private int _tolerance;
        private double _length;
        private LineDirection _direction;

        public Point StartPoint { get { return this._startPoint; } }
        public Point EndPoint { get { return this._endPoint; } }
        public int Tolerance { get { return this._tolerance; } }
        public double Length { get { return this._length; } }
        public LineDirection Direction { get { return this._direction; } }

        public MyLine(int tolerance)
        {
            this._tolerance = tolerance;
        }

        public void SetStartPoint(Point point)
        {
            this._startPoint = point;
        }

        public void SetEndPoint(Point point)
        {
            this._endPoint = point;
        }

        public void DeterminateDirection()
        {
            int aX = Math.Abs(this._endPoint.X - this._startPoint.X);
            int aY = Math.Abs(this._endPoint.Y - this._startPoint.Y);
            float rate = (float)aX / (float)aY;

            if (rate > 1)
            {
                if (this._endPoint.X > this._startPoint.X)
                    this._direction = LineDirection.Right;
                else
                    this._direction = LineDirection.Left;
            }
            else
            {
                if (this._endPoint.Y > this._startPoint.Y)
                    this._direction = LineDirection.Down;
                else
                    this._direction = LineDirection.Up;
            }
        }

        public bool CompareLength()
        {
            double length = CalculateLength();

            if (length > this._tolerance)
            {
                this._length = this._tolerance;
                return true;
            }
            else
            {
                this._length = length;
                return false;
            }
        }

        private double CalculateLength()
        {
            int legLength_1 = Math.Abs(this._endPoint.X - this._startPoint.X);
            int legLength_2 = Math.Abs(this._endPoint.Y - this._startPoint.Y);
            double hypotenuseLength = Math.Sqrt((double)(legLength_1 * legLength_1 + legLength_2 * legLength_2));

            return hypotenuseLength;
        }
    }

    public partial class Form1 : Form
    {
        public List<MyLine> MyLines;
        public int i = 0;
        public Point LastPoint;

        public Graphics Graphics = null;
        public SolidBrush FillingBrush = null;
        public Pen DrawingPen = null;

        public Form1()
        {
            this.DrawingPen = new Pen(new SolidBrush(Color.Black));
            this.FillingBrush = new SolidBrush(Color.Black);

            this.MyLines = new List<MyLine>();

            InitializeComponent();
        }

        private void Form1_MouseDown(object sender, MouseEventArgs e)
        {
            MyLine myLine = new MyLine(5);
            myLine.SetStartPoint(new Point(e.X, e.Y));

            this.Graphics.FillEllipse(this.FillingBrush, e.X - 2, e.Y - 2, 4, 4);

            this.MyLines.Add(myLine);
        }

        private void Form1_MouseMove(object sender, MouseEventArgs e)
        {
            if (e.Button == System.Windows.Forms.MouseButtons.Left)
            {
                
                this.Graphics.DrawLine(this.DrawingPen, new Point(e.X, e.Y), this.LastPoint);

                this.MyLines[i].SetEndPoint(new Point(e.X, e.Y));

                if (this.MyLines[i].CompareLength())
                {
                    this.Graphics.FillEllipse(this.FillingBrush, e.X - 2, e.Y - 2, 3, 3);
                    this.MyLines[i].DeterminateDirection();
                    this.Text = this.Text + this.MyLines[i].Direction.ToString();
                    MyLine myLine = new MyLine(5);
                    myLine.SetStartPoint(new Point(e.X, e.Y));

                    this.MyLines.Add(myLine);

                    i++;
                }

                this.LastPoint = new Point(e.X, e.Y);
            }
        }

        private void UpdateGraphicsContext(object sender, EventArgs e)
        {
            if (this.Graphics != null)
                this.Graphics.Dispose();

            this.Graphics = this.CreateGraphics();
            this.Graphics.SmoothingMode = SmoothingMode.HighQuality;
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            if (this.FillingBrush != null)
                this.FillingBrush.Dispose();

            if (this.DrawingPen != null)
                this.DrawingPen.Dispose();
        }
    }