Реализация метода главных компонент с помощью библиотеки OpenCV

13750
знаков
0
таблиц
0
изображений

Министерство образования и науки Российской Федерации

Южно-Уральский государственный университет

Кафедра Автоматика и Управление

Курсовая работа

на тему

Реализация метода главных компонент с помощью библиотеки OpenCV

Выполнил: Пушников А.А.

Группа: ПС-669

Проверил Разнополов К.О.

Дата «____» _____________2006 г.

Челябинск

2006 г
Оглавление

Метод главных компонент 2

Реализация метода главных компонент в OpenCV_ 3

Текст программы_ 4


Метод главных компонент

Метод главных компонент (Principal Component Analysis, PCA) применяется для сжатия информации без существенных потерь информативности. Он состоит в линейном ортогональном преобразовании входного вектора X размерности N в выходной вектор Y размерности M, N. При этом компоненты вектора Y являются некоррелированными и общая дисперсия после преобразования остаётся неизменной. Матрица X состоит из всех примеров изображений обучающего набора. Решив уравнение Gif 76x19, 964 байт, получаем матрицу собственных векторов Gif 17x15, 856 байт, где Gif 14x15, 850 байт– ковариационная матрица для X, а Gif 15x17, 856 байт– диагональная матрица собственных чисел. Выбрав из Gif 17x15, 856 байтподматрицу Gif 28x22, 896 байт, соответствующую M наибольшим собственным числам, получим, что преобразование Gif 62x24, 970 байт, где Gif 60x17, 922 байт– нормализованный вектор с нулевым математическим ожиданием, характеризует большую часть общей дисперсии и отражает наиболее существенные изменения X.

Выбор первых M главных компонент разбивает векторное пространство на главное (собственное) пространство Gif 69x26, 1001 байт, содержащее главные компоненты, и его ортогональное дополнение Gif 86x26, 1030 байт.

Применение для задачи распознавания изображений имеет следующий вид. Входные вектора представляют собой отцентрированные и приведённые к единому масштабу изображения. Собственные вектора, вычисленные для всего набора изображений, называются собственными объектами (eigenobject). С помощью вычисленных ранее матриц входное изображение разлагается на набор линейных коэффициентов, называемых главными компонентами. Сумма главных компонент, умноженных на соответствующие собственные вектора, является реконструкцией изображения.

Для каждого изображения лица вычисляются его главные компоненты. Обычно берётся от 5 до 200 главных компонент. Остальные компоненты кодируют мелкие различия между эталоном и шум. Процесс распознавания заключается в сравнении главных компонент неизвестного изображения с компонентами всех остальных изображений. Для этого обычно применяют какую-либо метрику (простейший случай – Евклидово расстояние). При этом предполагается, что изображения, соответствующие одному эталону, сгруппированы в кластеры в собственном пространстве. Из базы данных (или тренировочного набора) выбираются изображения-кандидаты, имеющие наименьшее расстояние от входного (неизвестного) изображения.

Дальнейшее совершенствование заключалось в использовании метрики Махаланобиса и Гауссовского распределения для оценки близости изображений. Для учёта различных ракурсов в этой же работе использовалось многомодальное распределение изображений в собственном пространстве.

Основное преимущество применения анализа главных компонент – это хранение и поиск изображений в больших базах данных, реконструкция изображений.

Основной недостаток – высокие требования к условиям съёмки изображений. Изображения должны быть получены в близких условиях освещённости, одинаковом ракурсе. Должна быть проведена качественная предварительная обработка, приводящая изображения к стандартным условиям (масштаб, поворот, центрирование, выравнивание яркости, отсечение фона).


Реализация метода главных компонент в OpenCV

Библиотека OpenCV реализует описанный выше алгоритм следующими функциями:

Функция, вычисляет собственные объекты эталонов:

void cvCalcEigenObjects( int nObjects, void* input, void* output, int ioFlags, int ioBufSize, void* userData, CvTermCriteria* calcLimit, IplImage* avg, float* eigVals ),

где

nObjects – число эталонов

input - указатель на массив изображений-эталонов (изображения глубиной 8 бит)

output – (выход функции) указатель на массив собственных объектов (изображения глубиной 32 бит)

ioFlags – флаги ввода/вывода. Для работы с памятью.

ioBufSize - размер буфера. Для работы с памятью.

userData – указатель на структуру для работы с памятью.

calcLimit – критерий прекращения вычислений. Два варианта: по количеству итераций и по ко точности (?)

avg – (выход функции) усредненное изображение эталонов

eigVals (выход функции) указатель на собственные числа (может быть NULL)

Функция, вычисляет коэффициенты разложения:

void cvEigenDecomposite( IplImage* obj, int eigenvec_count, void* eigInput, int ioFlags, void* userData, IplImage* avg, float* coeffs ),

где

obj – исследуемое изображение

eigenvec_count – число собственных объектов

eigInput - указатель на массив собственных объектов (изображения глубиной 32 бит)

ioFlags – флаги ввода/вывода. Для работы с памятью.

userData – указатель на структуру для работы с памятью.

avg - (выход функции) усредненное изображение эталонов

coeffs - (выход функции) коэффициенты разложения (?)

Функция, вычисляет проекцию исследуемого изображения на пространство собственных объектов:

void cvEigenProjection( void* input_vecs, int eigenvec_count, int io_flags, void* userdata, float* coeffs, IplImage* avg, IplImage* proj ),

где

input_vec - указатель на массив собственных объектов (изображения глубиной 32 бит)

eigenvec_count – число собственных объектов

io_flags – флаги ввода/вывода. Для работы с памятью.

userdata – указатель на структуру для работы с памятью.

coeffs - коэффициенты разложения (?)

avg - усредненное изображение эталонов

proj - проекция исследуемого изображения на пространство собственных объектов

В полученной проекции имеет смысл убрать излишние компоненты (например, с помощью функции cvThreshold – отсечение по порогу). Далее полученный результат можно сравнивать с эталонами, для принятия решения. Способов сравнения много, это может быть, например, минимальное расстояние (Евклидово) или корреляция с эталонами.


Текст программы

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

#include <vcl.h>

#pragma hdrstop

#include "Unit1.h"

#include "cxcore.h"

#include "cv.h"

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

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

IplImage **Objs, *Pro, *Object;

int obj_number=3;

 HINSTANCE highgui,cv,cvaux;

 IplImage* (__stdcall *cvLoadImage)( const char* filename, int iscolor);

 int (__stdcall *cvSaveImage)( const char* filename, const CvArr* image);

 int (__stdcall *cvNamedWindow)( const char* name, int flags );

 void (__stdcall *cvShowImage)( const char* name, const CvArr* image );

 IplImage* (__stdcall *cvCreateImage_)( CvSize size, int depth, int channels );

 double (__stdcall *cvDotProduct_)(const CvArr* src1, const CvArr* src2 );

 void (__stdcall *cvMul_)(const CvArr* src1, const CvArr* src2, CvArr* dst, double scale=1 );

 void (__stdcall *cvThreshold_)(const CvArr* src, CvArr* dst, double threshold,double max_value, int threshold_type);

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

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

 }

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

void show_im(TCanvas*c,IplImage *p)

{

 for(int i=0;i<p->width;i++)

for(int j=0;j<p->height;j++)

{

int a=p->imageDataOrigin[p->widthStep*j+i];

c->Pixels[i][j]=a&0x0000ff|(a<<8)&0x00ff00|(a<<16)&0xff0000;

}

}

void pca(int obj_number, IplImage **Objs,CvTermCriteria limit, IplImage *Object,IplImage *Pro)

{

 CvSize size;

 int m1=obj_number;

 IplImage **EigObjs, *Avg;

 float *coeffs;

 HINSTANCE hDLL = LoadLibrary("cvaux100.dll");

 if (!hDLL) return;

 void (__stdcall *cvCalcEigenObjects)( int nObjects, void* input, void* output, int ioFlags, int ioBufSize, void* userData, CvTermCriteria* calcLimit, IplImage* avg, float* eigVals );

 cvCalcEigenObjects = (void(__stdcall *)( int nObjects, void* input, void* output, int ioFlags, int ioBufSize, void* userData, CvTermCriteria* calcLimit, IplImage* avg, float* eigVals ))GetProcAddress(hDLL, "cvCalcEigenObjects");

 if (!cvCalcEigenObjects) return;

 void (__stdcall *cvEigenDecomposite)( IplImage* obj, int nEigObjs, void* eigInput, int ioFlags, void* userData, IplImage* avg, float* coeffs );

 cvEigenDecomposite = (void(__stdcall *)( IplImage* obj, int nEigObjs, void* eigInput, int ioFlags, void* userData, IplImage* avg, float* coeffs ))GetProcAddress(hDLL, "cvEigenDecomposite");

 if (!cvEigenDecomposite) return;

 void (__stdcall *cvEigenProjection)( void* eigInput, int nEigObjs, int ioFlags, void* userData, float* coeffs, IplImage* avg, IplImage* proj );

 cvEigenProjection = (void(__stdcall *)( void* eigInput, int nEigObjs, int ioFlags, void* userData, float* coeffs, IplImage* avg, IplImage* proj ))GetProcAddress(hDLL, "cvEigenProjection");

 if (!cvEigenProjection) return;

 EigObjs=new IplImage*[m1];

 coeffs=new float[m1];

 size.width = Object->width; size.height = Object->height;

 Avg = cvCreateImage_( size, IPL_DEPTH_32F, 1 );

 for(int i=0; i<m1; i++ )

{

EigObjs[i] = cvCreateImage_( size, IPL_DEPTH_32F, 1 );

}

 cvCalcEigenObjects( obj_number, (void*)Objs, (void*)EigObjs, 0, 0, NULL, &limit, Avg, NULL );

 cvEigenDecomposite( Object, m1, (void*)EigObjs, 0, NULL, Avg, coeffs );

 cvEigenProjection ( (void*)EigObjs, m1, 0, NULL, coeffs, Avg, Pro );

 FreeLibrary(hDLL);

// cvReleaseImage( &Avg );

// for(int i=0; i<m1; i++ )

// {

// cvReleaseImage( &EigObjs[i] );

// }

// cvFree( &coeffs);

}

void __fastcall TForm1::FormCreate(TObject *Sender)

{

 highgui = LoadLibrary("highgui100.dll");

 if (!highgui) return;

 cvLoadImage = (IplImage*(__stdcall *)( const char* filename, int iscolor))GetProcAddress(highgui, "cvLoadImage");

 if (!cvLoadImage) return;

 cvSaveImage = (int(__stdcall *)( const char* filename, const CvArr* image))GetProcAddress(highgui, "cvSaveImage");

 if (!cvSaveImage) return;

 cvNamedWindow = (int(__stdcall *)( const char* name, int flags ))GetProcAddress(highgui, "cvNamedWindow");

 if (!cvNamedWindow) return;

 cvShowImage = (void(__stdcall *)( const char* name, const CvArr* image ))GetProcAddress(highgui, "cvShowImage");

 if (!cvShowImage) return;

 cv = LoadLibrary("cxcore100.dll");

 if (!cv) return;

 cvCreateImage_ = (IplImage*(__stdcall *)( CvSize size, int depth, int channels ))GetProcAddress(cv, "cvCreateImage");

 if (!cvCreateImage_) return;

 cvDotProduct_ = (double(__stdcall *)( const CvArr* src1, const CvArr* src2))GetProcAddress(cv, "cvDotProduct");

 if (!cvDotProduct_) return;

 cvMul_ = (void(__stdcall *)( const CvArr* src1, const CvArr* src2, CvArr* dst, double scale=1))GetProcAddress(cv, "cvMul");

 if (!cvMul_) return;

 cvaux = LoadLibrary("cv100.dll");

 if (!cvaux) return;

 cvThreshold_ = (void(__stdcall *)(const CvArr* src, CvArr* dst, double threshold,double max_value, int threshold_type))GetProcAddress(cvaux, "cvThreshold");

 if (!cvThreshold_) return;

 Objs=new IplImage*[obj_number];

 Objs[0] = cvLoadImage( ".\\et\\1.bmp", 0);

 show_im(Image1->Canvas,Objs[0]);

 Objs[1] = cvLoadImage( ".\\et\\2.bmp", 0);

 show_im(Image2->Canvas,Objs[1]);

 Objs[2] = cvLoadImage( ".\\et\\3.bmp", 0);

 show_im(Image3->Canvas,Objs[2]);

 String fname="6.bmp";

 Object = cvLoadImage((".\\in\\"+fname).c_str(), 0);

 show_im(Image4->Canvas,Object);

}

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

void __fastcall TForm1::Button1Click(TObject *Sender)

{

 float e[3];

 CvTermCriteria limit;

 CvSize size;

 size.width = Object->width; size.height = Object->height;

 Pro = cvCreateImage_( size, IPL_DEPTH_8U, 1 );

 limit.type = CV_TERMCRIT_EPS;

 limit.max_iter = 1;

 limit.epsilon = 0.1;

 show_im(Image4->Canvas,Object);

 pca(obj_number,Objs,limit,Object,Pro);

 show_im(Image5->Canvas,Pro);

 cvThreshold_(Pro,Object,200,255,CV_THRESH_BINARY);

 show_im(Image6->Canvas,Object);

 cvMul_(Object,Objs[0],Pro);

 show_im(Image7->Canvas,Pro);

 cvMul_(Object,Objs[1],Pro);

 show_im(Image8->Canvas,Pro);

 cvMul_(Object,Objs[2],Pro);

 show_im(Image9->Canvas,Pro);

 e[0]=cvDotProduct_(Object,Objs[0])/cvDotProduct_(Objs[0],Objs[0]);

 e[1]=cvDotProduct_(Object,Objs[1])/cvDotProduct_(Objs[1],Objs[1]);

 e[2]=cvDotProduct_(Object,Objs[2])/cvDotProduct_(Objs[2],Objs[2]);

 Label1->Caption=FloatToStr(int(e[0]*1000)/1000.);

 Label2->Caption=FloatToStr(int(e[1]*1000)/1000.);

 Label3->Caption=FloatToStr(int(e[2]*1000)/1000.);

 if(e[0]>e[1])

if(e[0]>e[2])

ShowMessage("1");

 if(e[1]>e[0])

if(e[1]>e[2])

ShowMessage("2");

 if(e[2]>e[1])

if(e[2]>e[0])

ShowMessage("3");

}

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

void __fastcall TForm1::Image1Click(TObject *Sender)

{

 if(OpenPictureDialog1->Execute())

{

Objs[0] = cvLoadImage(OpenPictureDialog1->FileName.c_str(), 0);

show_im(Image1->Canvas,Objs[0]);

}

}

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

void __fastcall TForm1::Image2Click(TObject *Sender)

{

 if(OpenPictureDialog1->Execute())

{

Objs[1] = cvLoadImage(OpenPictureDialog1->FileName.c_str(), 0);

show_im(Image2->Canvas,Objs[1]);

}

}

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

void __fastcall TForm1::Image3Click(TObject *Sender)

{

 if(OpenPictureDialog1->Execute())

{

Objs[2] = cvLoadImage(OpenPictureDialog1->FileName.c_str(), 0);

show_im(Image3->Canvas,Objs[2]);

}

}

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

void __fastcall TForm1::Image4Click(TObject *Sender)

{

 if(OpenPictureDialog1->Execute())

{

Object = cvLoadImage(OpenPictureDialog1->FileName.c_str(), 0);

show_im(Image4->Canvas,Object);

}

}

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


Информация о работе «Реализация метода главных компонент с помощью библиотеки OpenCV»
Раздел: Информатика, программирование
Количество знаков с пробелами: 13750
Количество таблиц: 0
Количество изображений: 0

Похожие работы

Скачать
34718
5
0

... обработать найденные объекты, для этого используются: 1.         Метод максимальных площадей. 2.         Метод гистограмм. Алгоритм был реализован с помощью библиотеки для обработки изображений OpenСV. При тестировании алгоритма использовались изображения игровой доски для игры в го с белыми и чёрными камнями. Пример его работы представлен на рис . № Эталонное изображение Исследуемое ...

0 комментариев


Наверх