Imaginsystems


Tecniche di Programmazione - Codici Sorgenti - News Informatiche
Archivio Posts
Anno 2014

Anno 2013

Anno 2012
Statistiche
  • Views Home Page: 53.087
  • Views Posts: 400.937
  • Views Gallerie: 0
  • n° Posts: 210
  • n° Commenti: 222

C# - Come interpretare la Scrittura a mano con C# (Codice)

C# - Come interpretare la Scrittura a mano con C# (Codice)


 

In questo articolo, cercherò di spiegare come riconoscere la scrittura a mano con C #.

Lo scopo di questo articolo è di dare spunto a come usare il C# per crearsi un rudimentali ma efficace OCR di riconoscimento scrittura.

Cerchiamo di capire il nostro algoritmo e di decidere che tipo di controlli useremo nel progetto.

Algoritmo :

l'utente disegna linee in direzioni diverse, mentre sta scrivendo. In primo luogo dobbiamo notare questa direzione e dare loro un valore.

 

Useremo un controllo PictureBox in modo l'utente può disegnare o scrivere il carattere su di esso.Inoltre useremo due caselle di testo, uno per mostrare le direzioni disegnata all'istante e uno per mostrare la lettera di riconoscimento.

Per quanto riguarda la tabella di direzione, ad esempio la lettera "I"  corrisponde al numero 2. Semplificando questo, l'utente dovrà tracciare una linea per la direzione sud. Possiamo archiviare la "firma direzione" salvando solo le direzioni, basta memorizzare le informazioni X e Y quando l'utente sposta il mouse sulla PictureBox tenendo premuto il tasto sinistro del mouse.

In questa fase dobbiamo controllare i cambiamenti di direzione in modo che possiamo costruire la "firma direzione". Diamo uno sguardo al codice seguente.

CODICE VISUAL STUDIO 2010 - C#

        private byte XDirection = 0;

        private byte YDirection = 0;

        private ArrayList X = new ArrayList();

        private ArrayList Y = new ArrayList();

        private StringBuilder OCR = new StringBuilder();

        private byte History = 10;

        private int Range = 5;

         //Windows Form Designer generated code

        private void pictureBox1_MouseMove(object sender, MouseEventArgs e)

        {

            bool XDirChanged = false;

            bool YDirChanged = false;

            if (e.Button == MouseButtons.Left)

            {

                Graphics g = pictureBox1.CreateGraphics();

                g.DrawEllipse(new Pen(Color.Brown), e.X, e.Y, 5, 5);

                X.Add(e.X);

                Y.Add(e.Y);

                if (X.Count > History)

                {

                    if (XDirection == 0)

                    {

                        if ((e.X - Convert.ToInt32(X[X.Count - History])) > Range)

                        {

                            XDirection = 3;

                            XDirChanged = true;

                        }

                        else if ((Convert.ToInt32(X[X.Count - History]) - e.X) > Range)

                        {

                            XDirection = 4;

                            XDirChanged = true;

                        }

                    }

                    else

                    {

                        if ((e.X - Convert.ToInt32(X[X.Count - History])) > Range && XDirection == 4)

                        {

                            XDirection = 3;

                            XDirChanged = true;

                        }

                        else if ((Convert.ToInt32(X[X.Count - History]) - e.X) > Range && XDirection == 3)

                        {

                            XDirection = 4;

                            XDirChanged = true;

                        }

                    }

                }

                if (Y.Count > History)

                {

                    if (YDirection == 0)

                    {

                        if ((e.Y - Convert.ToInt32(Y[Y.Count - History])) > Range)

                        {

                            YDirection = 2;

                            YDirChanged = true;

                        }

                        else if ((Convert.ToInt32(Y[Y.Count - History]) - e.Y) > Range)

                        {

                            YDirection = 1;

                            YDirChanged = true;

                        }

                    }

                    else

                    {

                        if ((e.Y - Convert.ToInt32(Y[Y.Count - History])) > Range && YDirection == 1)

                        {

                            YDirection = 2;

                            YDirChanged = true;

                        }

                        else if ((Convert.ToInt32(Y[Y.Count - History]) - e.Y) > Range && YDirection == 2)

                        {

                            YDirection = 1;

                            YDirChanged = true;

                        }

                    }

                }

                if (XDirChanged && XDirection != 0)

                {

                    OCR.Append(XDirection);

                }

                if (YDirChanged && YDirection != 0)

                {

                    OCR.Append(YDirection);

                }

                textBox1.Text = OCR.ToString();

            }

        }


 

Per fare il disegno

Useremo l'evento MouseMove della PictureBox per fare il disegno. Se il mouse si muove sulla PictureBox e viene premuto il pulsante sinistro del mouse disegniamo una forma, e si memorizza la posizione X e Y del mouse.

CODICE VISUAL STUDIO 2010 - C#

.... 

   if (e.Button==MouseButtons.Left)

{  

Graphics g=pictureBox1.CreateGraphics();

g.DrawEllipse(new Pen(Color.Brown), e.X ,e.Y,5,5);

...


Per scoprire i cambiamenti di direzione

Abbiamo coordinate X e Y in un ambiente 2D. Così i cambiamenti di direzione dovranno avvenire sia su coordinate X e Y. Useremo le variabili XDirection e YDirection per scoprire i cambiamenti di direzione. Se XDirection ha un valore di 3 direzione sarà Est, 4 sarà Ovest. Se YDirection ha un valore di 1, la direzione sarà a Nord, 2 sarà Sud. Se entrambe queste variabili ha un valore di 0, allora capiremo che l'utente non ha tratto niente.

Per scoprire i cambiamenti di direzione, è l'unico modo per abbinare i valori delle coordinate correnti con quelli precedenti. Così dobbiamo registrare la X, Y informazioni disegnati precedentemente. Per raggiungere questo useremo due variabili di tipo ArrayList denominate X e Y.

Poiché non vogliamo che il nostro codice sia quella sensibile per registrare i cambiamenti di direzione su una o due modifiche dei pixel, useremo due variabili chiamate History e Range. Come ricorderete tracciamo i cambiamenti di direzione, facendo corrispondere il precedente x, record y con quelli attuali, variabile History manterrà il valore che identifica il numero di record che torneremo indietro in ArrayList. Variabile di intervallo manterrà il valore della differenza massima ammissibile tra il x, y .

Diamo un'occhiata alla foto

 

Per mantenere la direzione cambia in memoria

Useremo una variabile tipizzata StringBuilder chiamata OCR per raggiungere questo obiettivo. Se la variabile XDirChanged ha un valore TRUE e XDirection variabile ha un valore diverso da 0 si aggiunge la direzione alla variabile OCR. 

CODICE VISUAL STUDIO 2010 - C#

...

if (XDirChanged && XDirection!=0)

OCR.Append(XDirection);

if (YDirChanged && YDirection!=0)

OCR.Append(YDirection);

...

Processo finale, interpretare i cambiamenti di direzione

Per iniziare a interpretare il cambiamento di direzione utente dovrà fare clic con il tasto destro del mouse.

Usando questo evento possiamo poi utilizzare il metodo AnaylseThis() per analizzare quello che ha scritto.

Prima di andare avanti prendete un pezzo di carta e disegnare la lettera A. Si noti la direzione si disegna. (Ricordate il grafico direzione)

Una lettera 
42323?

Impara a disegnare :

 

Andiamo a direzione 4 per X e 2 per Y come tracciamo la linea 1 
Andiamo a direzione 3 per X e 2 per Y come tracciamo la linea 2 
Andiamo a direzione 3 per X e 0 per Y come tracciamo la linea 3

Finalmente possiamo comprendere che il valore 42323 è la lettera A. La prima cosa che ti chiedo è che lo stile di scrittura può variare come faremo interpretare disegni diversi per A?

Date un'occhiata al seguente codice.

CODICE VISUAL STUDIO 2010 - C#

private void AnalyseThis()

     {

     Graphics Gc=pictureBox1.CreateGraphics();

     Gc.Clear(Color.White);

     //Yorumlama;

     string OCRText=OCR.ToString();

     switch(OCRText)

     {

     //A

     case "3123":

    textBox2.Text+="A";

    break;

     case "1323":

     goto case "3123";

     case "1332":

     goto case "3123";

     case "42233":

     goto case "3123";

     case "42323":

     goto case "3123";

     case "24323":

     goto case "3123";

     case "31323":

     goto case "42233";

     //B

     case "2324324":

    textBox2.Text+="B";

    break;

     case "231243124":

     goto case "2324324";

     case "232434":

     goto case "2324324";

     //C

     case "423":

    textBox2.Text+="C";

    break;

     case "243":

     goto case "423";

     //D

     case "2324":

    textBox2.Text+="D";

    break;

     case "2234":

     goto case "2324";

     //E

     case "2333":

    textBox2.Text+="E";

    break;

     //F

     case "233":

    textBox2.Text+="F";

    break;

     //G

     case "42313":

    textBox2.Text+="G";

    break;

     //H

     case "223":

    textBox2.Text+="H";

    break;

     case "232":

     goto case "223";

     //I

     case "2":

    textBox2.Text+="I";

    break;

     //J

     case "241":

    textBox2.Text+="J";

    break;

     //K

     case "2423":

    textBox2.Text+="K";

    break;

     case "2243":

     goto case "2423";

     //L

     case "23":

    textBox2.Text+="L";

    break;

     //M

     case "22312":

    textBox2.Text+="M";

    break;

     case "23212":

     goto case "22312";

     //N

     case "2232":

    textBox2.Text+="N";

    break;

     case "2322":

     goto case "2232";

     case "2321":

     goto case "2232";

     //O

     case "42314":

    textBox2.Text+="O";

    break;

     //P

     case "22343":

    textBox2.Text+="P";

    break;

     case "23243":

     goto case "22343";

     //R

     case "223432":

    textBox2.Text+="R";

    break;

     case "223423":

     goto case "223432";

     case "232432":

     goto case "223432";

     case "232423":

     goto case "223432";

     //S

     case "4234":

    textBox2.Text+="S";

      break;

     //T

     case "32":

    textBox2.Text+="T";

    break;

     //U

     case "231":

    textBox2.Text+="U";

    break;

     //V

     case "2313":

    textBox2.Text+="V";

    break;

     case "2331":

     goto case "2313";

     case "3213":

     goto case "2313";

     case "3231":

     goto case "2313";

     //Y

     case "2312":

    textBox2.Text+="Y";

    break;

     case "3212":

     goto case "2312";

     //Z

     case "3423":

    textBox2.Text+="Z";

    break;

     case "3243":

     goto case "3423";

    }

  OCR.Remove(0,OCR.Length);

  }

}

Come potete vedere siamo in grado di utilizzare diverse combinazioni di direzione per una lettera.

Con questo metodo possiamo interpretare diversi stili di scrittura.

Questo codice può interpretare erroneamente per alcune lettere simili come D, P. 

In questa fase è possibile scrivere alcuni componenti aggiuntivi per risolvere questo problema :)

Questo articolo è stato tradotto in italiano di seguito troverete l'articolo Originale e il nome della fonte :

(Titolo Originario) : How to Interpret Handwriting with C#  -  (Autore) : Levent Yildiz del 02 - Settembre - 2005

Potete scaricare il file d'esempio :

Password :  "ImaginSystem" 

Link File Download : Download SimpleOCR_C#

By ImaginSystems & Queen Gin   

Categoria: C#
mercoledì, 20 nov 2013 Ore. 11.00

Messaggi collegati


Ora e Data
Mappa
Blogs Amici
    Copyright © 2002-2007 - Blogs 2.0
    dotNetHell.it | Home Page Blogs
    ASP.NET 2.0 Windows 2003