Программирование и комп-ры

Программа распознавания символов

Белорусский Государственный Университет Информатики и Радиоэлектроники.



                             Контрольная работа
                                по дисциплине
                                   «МАГИ»

                     «Программа распознавания символов»



                                          Выполнил студент группы 500501
                                          Балахонов Е.В.

                                  Задание.


      Требуется  написать  программу,  способную   распознавать   графически
представленные символы в виде растрового  изображения  и  преобразовывать  в
обычный текст.
      - платформа: Win32,
      - формат графического изображения: Windows Bitmap (BMP), 8 бит,
      - шрифт для распознавания: Arial, 16



                          Выбор средств разработки.


      В качестве среды разработки будет использоваться Borland  C++  Builder
5.


                           Распознавание символов.



Этап 1. Выделение контура объекта, определение его границ.


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

Общее описание алгоритма.



     Отслеживающие  алгоритмы  основаны  на   том,   что   на   изображении
отыскивается объект (первая встретившаяся точка объекта)  и  контур  объекта
отслеживается и векторизуется. Достоинством данных  алгоритмов  является  их
простота, к недостаткам  можно  отнести  их  последовательную  реализацию  и
некоторую сложность при  поиске  и  обработке  внутренних  контуров.  Пример
отслеживающего алгоритма - "алгоритма жука" - приведен  на  рис.  5.12.  Жук
начинает движение с белой области по направлению к  черной,  Как  только  он
попадает на черный элемент, он поворачивает налево и переходит к  следующему
элементу. Если этот элемент белый, то жук поворачивается  направо,  иначе  -
налево. Процедура повторяется до тех пор, пока жук не  вернется  в  исходную
точку. Координаты точек перехода с черного на белое и с белого на  черное  и
описывают границу объекта.

     На рис. 1 показана схема работы такого алгоритма.
[pic]
            Рис. 1. Схема работы отслеживающего алгоритма «жука».



Этап 2. Построение на основе контура объекта скелетной линии.


      При нахождении новой точки контура,  рассчитывается  расстояние  между
предыдущей найденной точкой и новой. Если оно  превышает  некоторую  границу
(по умолчанию в 5 единиц),  она запоминается. К концу  построения  скелетной
линии программа имеет массив  координат  вершин  ломаной,  которая  является
скелетной линией объекта.


Этап 3. Сравнение полученной скелетной линии с списком шаблонов.


      После построения скелетной линии производится сравнение ее с списком
шаблонов известных символов. При нахождении совпадения, программа
записывает в строку найденный символ.



                          Исходный текст программы.


//--------------------------------------------------------------------------
-

#include 
#pragma hdrstop

#include 
#include 

#include "ChildFormUnit.h"
#include "MainFormUnit.h"
#include "AverageFilterDialogFormUnit.h"
#include "OSRFormUnit.h"

//--------------------------------------------------------------------------
-
#pragma package(smart_init)
#pragma resource "*.dfm"
TChildForm *ChildForm;
TTemplates Templates;
//--------------------------------------------------------------------------
-
__fastcall TChildForm::TChildForm(TComponent* Owner)
        : TForm(Owner)
{
}
//--------------------------------------------------------------------------
-
bool __fastcall TChildForm::LoadImage(AnsiString FileName)
{
 try
 {
  Image1->Picture->LoadFromFile(FileName);
 }
 catch (EInvalidGraphic& Exception)
 {
  AnsiString Error = "Ошибка загрузки файла изображения! Ошибка системы: ";
  Error += Exception.Message;
  MessageBox(this->Handle, Error.c_str(), "Ошибка", MB_OK | MB_ICONERROR);
  return false;
 }

 if (Image1->Picture->Bitmap->PixelFormat != pf8bit)
 {
  MessageBox(Handle,"Такой формат файла пока не подерживается...",
                    "Слабоват я пока...",MB_OK | MB_ICONSTOP |
MB_APPLMODAL);
  return false;
 }

 return true;
}
//--------------------------------------------------------------------------
-
void __fastcall TChildForm::FormClose(TObject *Sender,
      TCloseAction &Action)
{
 MainForm->DeleteActiveChildForm();
}
//--------------------------------------------------------------------------
-
void __fastcall TChildForm::AverageFilter()
{
 AverageFilterDialogForm = new TAverageFilterDialogForm(this);
 if (AverageFilterDialogForm->ShowModal() == mrCancel)
 {
  delete AverageFilterDialogForm;
  return;
 }

 int Value = atoi(AverageFilterDialogForm->Edit1->Text.c_str());

 delete AverageFilterDialogForm;

 Byte* PrevisionLine = NULL;
 Byte* CurrentLine = NULL;
 Byte* NextLine = NULL;
 int I = 0, J = 0;
 int Summ = 0;

 for (I = 0; I <= Image1->Picture->Bitmap->Height - 1; I++)
 {
  CurrentLine = (Byte*)Image1->Picture->Bitmap->ScanLine[I];
  for (J = 0; J <= Image1->Picture->Bitmap->Width - 1; J++)
  {
   Summ = 0;

   if (I > 0)
   {
    PrevisionLine = (Byte*)Image1->Picture->Bitmap->ScanLine[I - 1];
    if (J > 0)
    {
     Summ += PrevisionLine[J - 1];
    }

    Summ = Summ + PrevisionLine[J];

    if (J + 1 < Image1->Picture->Bitmap->Width)
    {
     Summ += PrevisionLine[J + 1];
    }
   }

   if (J > 0)
   {
    Summ += CurrentLine[J - 1];
   }

   Summ += CurrentLine[J];

   if (J + 1 < Image1->Picture->Bitmap->Width)
   {
    Summ += CurrentLine[J + 1];
   }

   if (I + 1 < Image1->Picture->Bitmap->Height)
   {
    NextLine = (Byte*)Image1->Picture->Bitmap->ScanLine[I + 1];
    if (J > 0)
    {
     Summ += NextLine[J - 1];
    }

    Summ += NextLine[J];

    if (J + 1 < Image1->Picture->Bitmap->Width)
    {
     Summ += NextLine[J + 1];
    }
   }

   if ((int)(Summ / 9) <= Value)
    CurrentLine[J] = (Byte) Summ / 9;
  }
 }
 Image1->Visible = false;
 Image1->Visible = true;
}
//--------------------------------------------------------------------------
-
// Расстояние между двумя точками
int Distance(TVertex& V1, TVertex& V2)
{
 int a = abs(V1.Y - V2.Y);
 int b = abs(V1.X - V2.X);
 return sqrt(a*a + b*b);
}

//--------------------------------------------------------------------------
-
void __fastcall TChildForm::OSR()
{
 // Пороговое расстояние для простроения упрощенной фигуры
 const int Treshold = 5;

 // Сюда сохраняется результат распознования
 AnsiString Result;

 // Отладочная форма с изображением для работы
 OSRForm = new TOSRForm(this);

 // Направления движения жука
 typedef enum {North, East, South, West} TDirectional;
 TDirectional Direct;

 // Координаты первой встречи с текущим объектом
 int X,Y;

 // Временно их используем для задания нового размера рабочего изображения
 X = OSRForm->Width - OSRForm->Image1->Width;
 Y = OSRForm->Height - OSRForm->Image1->Height;
 OSRForm->Image1->Picture->Bitmap->Assign(Image1->Picture->Bitmap);
 OSRForm->Width = OSRForm->Image1->Width + X;
 OSRForm->Height = OSRForm->Image1->Height + Y;
 OSRForm->Image1->Canvas->Rectangle(0, 0, OSRForm->Image1->Width - 1,
                                    OSRForm->Image1->Height - 1);

 Graphics::TBitmap* FromImage = Image1->Picture->Bitmap;
 Graphics::TBitmap* ToImage = OSRForm->Image1->Picture->Bitmap;

 // Текущие координаты маркера
 int cX,cY;

 // Максимальные координаты, которые занимает фигура
 int MaxX = 0;
 int MaxY = FromImage->Height;

 // От этой координаты начинается новое сканирование по Y
 int BeginY = 0;

 // Обрабатываемые линии
 Byte *Line, *ToLine;

 char Symb = 'А';

 // Текущий байт
 Byte B = 0;

 bool SkipMode = false;
 while (true)
 {
  // Список координат текущего объекта
  TShapeVector ShapeVector;
  // Временная структура координат точки
  TVertex Vertex;

  // Поиск любого объекта
  // Идем до тех пор, пока не встретим черную область
  for (X = MaxX; X < FromImage->Width; X++)
  {
   for (Y = BeginY; Y < MaxY; Y++)
   {
    Line = (Byte*)FromImage->ScanLine[Y];
    if (Line[X] < 255)
     goto FindedLabel;
   }

   if ((X + 1 == FromImage->Width) && (Y == FromImage->Height))
   {
    X++;
    goto FindedLabel;
   }

   // Если прошли до самого правого края, расширяем границы поиска до низа
   if (X + 1 == FromImage->Width)
   {
    X = 0;

    MaxX = 0;
    BeginY = MaxY;
    MaxY = FromImage->Height;
   }

  }
FindedLabel:

  // Если не нашли ни одного черного пиксела, то выходим из процедуры
  if ((X == FromImage->Width) && (Y == FromImage->Height))
   break;

  // Сначала задача найти максимальные границы обнаруженной фигуры,
  // чтобы потом от нее начинать строить скелет
  // Также ищем самую верхнюю точку фигуры, для начала построения
  int MinX = Image1->Picture->Width;  // Самая левая координата

  MaxX = 0;
  MaxY = 0;

  // Самая верхняя точка
  TVertex TopPoint;
  TopPoint.Y = Image1->Picture->Height;

  // Поворачиваем налево (новое направление - север)
  cX = X;
  cY = Y - 1;

  Direct = North;
  Line = (Byte*)FromImage->ScanLine[cY];

  // Пока не придем в исходную точку, выделяем контур объекта
  while ((cX != X) || (cY != Y))
  {
   // В зависимости от текущего направления движения жука
   switch (Direct)
   {
     // Север
    case North:
    {
     B = Line[cX];
     // Если элемент "черный", поворачиваем снова "налево"
     if (B < 255)
     {
      Direct = West;
      cX--;
      // Может это самая левая координата?
      if (MinX > cX)
       MinX = cX;
     }
     // Иначе поворачиваем "направо"
     else
     {
      Direct = East;
      cX++;
      if (MaxX < cX)
       MaxX = cX;

     }
    }
    break;

    // Восток
    case East:
    {
     B = Line[cX];
     // Если элемент "черный", поворачиваем снова "налево"
     if (B < 255)
     {
      Direct = North;
      cY--;
      Line = (Byte*)FromImage->ScanLine[cY];
      // Может это самая верхняя точка?
      if (TopPoint.Y > cY)
      {
       TopPoint.Y = cY;
       TopPoint.X = cX;
      }
     }
     // Иначе поворачиваем "направо"
     else
     {

      Direct = South;
      cY++;
      Line = (Byte*)FromImage->ScanLine[cY];
      if (MaxY < cY)
       MaxY = cY;
     }
    }
    break;

    // Юг
    case South:
    {
     B = Line[cX];
     // Если элемент "черный", поворачиваем снова "налево"
     if (B < 255)
     {
      Direct = East;
      cX++;
      if (MaxX < cX)
       MaxX = cX;
     }
     // Иначе поворачиваем "направо"
     else
     {
      Direct = West;
      cX--;
      // Может это самая левая координата?
      if (MinX > cX)
       MinX = cX;
     }
    }
    break;

    // Запад
    case West:
    {
     B = Line[cX];
     // Если элемент "черный", поворачиваем снова "налево"
     if (B < 255)
     {
      Direct = South;
      cY++;
      Line = (Byte*)FromImage->ScanLine[cY];
      if (MaxY < cY)
       MaxY = cY;
     }
     // Иначе поворачиваем "направо"
     else
     {
      Direct = North;
      cY--;
      Line = (Byte*)FromImage->ScanLine[cY];
      // Может это самая верхняя точка?
      if (TopPoint.Y > cY)
      {
       TopPoint.Y = cY;
       TopPoint.X = cX;
      }
     }
    }
   }
  }

  TopPoint.X++;

  if ((!TopPoint.X) && (!TopPoint.Y))
  {
   TopPoint.X = X;
   TopPoint.Y = Y;
  }
  else
  {
   X = TopPoint.X;
   Y = TopPoint.Y;
  }

  // Постройка скелета
  ToLine = (Byte*)ToImage->ScanLine[Y];
  ToLine[X] = 0;

  // Поворачиваем налево (новое направление - юг)
  cX = X;
  cY = Y;

  Vertex.X = X;
  Vertex.Y = Y;
  ShapeVector.push_back(Vertex);

  Direct = East;
  Line = (Byte*)FromImage->ScanLine[cY];

  // Пока не придем в исходную точку, выделяем контур объекта
  do
  {
   // В зависимости от текущего направления движения жука
   switch (Direct)

   {
     // Север
    case North:
    {
     B = Line[cX];
     // Если элемент "черный", поворачиваем снова "налево"
     if (B < 255)
     {
      ToLine = (Byte*)ToImage->ScanLine[cY];
      ToLine[cX] = 0;

      Vertex.X = cX;
      Vertex.Y = cY;
      if (Distance(Vertex, ShapeVector[ShapeVector.size() - 1]) >=
Treshold)
       ShapeVector.push_back(Vertex);

      Direct = West;
      cX--;
     }
     // Иначе поворачиваем "направо"
     else
     {
      Direct = East;
      cX++;
     }
    }
    break;

    // Восток
    case East:
    {
     B = Line[cX];
     // Если элемент "черный", поворачиваем снова "налево"
     if (B < 255)
     {
      ToLine = (Byte*)ToImage->ScanLine[cY];
      ToLine[cX] = 0;

      Vertex.X = cX;
      Vertex.Y = cY;
      if (Distance(Vertex, ShapeVector[ShapeVector.size() - 1]) >=
Treshold)
       ShapeVector.push_back(Vertex);

      Direct = North;
      cY--;
      Line = (Byte*)FromImage->ScanLine[cY];
     }
     // Иначе поворачиваем "направо"
     else
     {
      Direct = South;
      cY++;
      Line = (Byte*)FromImage->ScanLine[cY];
     }
    }
    break;

    // Юг
    case South:
    {
     B = Line[cX];
     // Если элемент "черный", поворачиваем снова "налево"
     if (B < 255)
     {
      ToLine = (Byte*)ToImage->ScanLine[cY];
      ToLine[cX] = 0;

      Vertex.X = cX;
      Vertex.Y = cY;
      if (Distance(Vertex, ShapeVector[ShapeVector.size() - 1]) >=
Treshold)
       ShapeVector.push_back(Vertex);

      Direct = East;
      cX++;
     }
     // Иначе поворачиваем "направо"
     else
     {
      Direct = West;
      cX--;
     }
    }
    break;

    // Запад
    case West:
    {
     B = Line[cX];
     // Если элемент "черный", поворачиваем снова "налево"
     if (B < 255)
     {
      ToLine = (Byte*)ToImage->ScanLine[cY];
      ToLine[cX] = 0;

      Vertex.X = cX;
      Vertex.Y = cY;
      if (Distance(Vertex, ShapeVector[ShapeVector.size() - 1]) >=
Treshold)

       ShapeVector.push_back(Vertex);

      Direct = South;
      cY++;
      Line = (Byte*)FromImage->ScanLine[cY];
     }
     // Иначе поворачиваем "направо"
     else
     {
      Direct = North;
      cY--;
      Line = (Byte*)FromImage->ScanLine[cY];
     }
    }
   }
  } while ((cX != X) || (cY != Y));

  Vertex.X = X;
  Vertex.Y = Y;
  ShapeVector.push_back(Vertex);

  ToImage->Canvas->Pen->Color = clRed;
  ToImage->Canvas->MoveTo(ShapeVector[0].X, ShapeVector[0].Y);
  for (UINT i = 1; i < ShapeVector.size(); i++)
  {
   ToImage->Canvas->LineTo(ShapeVector[i].X, ShapeVector[i].Y);
  }

  for (UINT i = 0; i < ShapeVector.size(); i++)
  {
   ShapeVector[i].X -= MinX;
   ShapeVector[i].Y -= Y;
  }

/*

  if (Symb == 'Й')
  {
   Symb++;
  }

  if (Symb == 'а')
  {
   // Symb = 'A';
   break;
  }

  if ((Symb != 'Ы') && (!SkipMode))
  {
   AnsiString FileName = ExtractFilePath(Application->ExeName) + "TPL\\";
   FileName += Symb;

   ofstream OutFile(FileName.c_str());
   for (UINT i = 0; i < ShapeVector.size(); i++)
   {
    OutFile << IntToStr(ShapeVector[i].X).c_str() << endl;
    OutFile << IntToStr(ShapeVector[i].Y).c_str() << endl;
   }
   OutFile.close();

   Symb++;
  }
  else
  {
   if (SkipMode)
   {
    SkipMode = false;
    Symb++;
   }
   else if (Symb == 'Ы')
    SkipMode = true;
  }
*/

  TTemplate* Template = FindTemplate(ShapeVector);
  if (Template)
   Result += Template->Symb;
 }

 //OSRForm->Show();
 delete OSRForm;

 Memo1->Text = Result;
}
//--------------------------------------------------------------------------
-
TTemplate* FindTemplate(TShapeVector Vec)
{
 TTemplate Template;
 Template.Vec = Vec;
 for (UINT i = 0; i < Templates.size(); i++)
 {
  if (Templates[i] == Template)
   return &Templates[i];
 }

 return NULL;
}
//--------------------------------------------------------------------------
-


                             Снапшоты программы.


                                Начало работы

[pic]



                         Произведено распознавание.

[pic]


смотреть на рефераты похожие на "Программа распознавания символов"